ReviewOS

also looking at this

craft-native/craft

Zig-native mobile: iOS compiles, serves a bridge call on a simulator, and is gated against drift

#83
Merged glennmichael123 wants to merge feat/mobile-zig-native into main
28 files +2460 -6557

Review threads live on the whole diff, not on one commit, so none are shown here - a thread's line means something in the branch's final form, and painting it into an intermediate step would put it on code it is not about.

docs/android-development.mdadded+503-0
Changes to docs/android-development.md
@@ -0,0 +1,503 @@
1# Android Development
2
3Making Android a Zig-native platform: Zig reaches Android's Java APIs through JNI, the way
4`packages/zig/src/macos.zig` reaches AppKit through `objc_msgSend`.
5
6This document is the working plan. It is meant to be checked off, and the phase gates are
7meant to be run.
8
9---
10
11## Where Android actually stands
12
13**`zig build build-android` exits 0 and ships nothing.**
14
15```console
16$ ls -l zig-out/lib/libcraft-android-arm64.a
17-rw-r--r-- 2990 bytes
18
19$ ar t zig-out/lib/libcraft-android-arm64.a
20/ ← symbol table (empty)
21// ← string table
22/0 ← one .o with no exported symbols
23
24$ nm zig-out/lib/libcraft-android-arm64.a | grep -c ' T '
250
26```
27
28An empty archive is a legal archive, so the build is green.
29
30**Root cause:** `build.zig:1807-1819` builds a static library rooted at `src/android.zig`,
31which has **zero `export fn`**. Zig only emits code reachable from an export — `pub` is
32visibility, not linkage.
33
34Because nothing is reachable, `mobile.zig` is never analysed at all, so its `comptime`
35`@export` block at `mobile.zig:165-170` never runs, silently dropping the only two `Java_*`
36symbols in the codebase. And even if they had survived, they bind to
37`app.craft.CraftValueCallback` and `app.craft.CraftActivity` — **classes that exist nowhere
38in this repo and that no template could generate.**
39
40Compare iOS, which gets this right: `src/ios_main.zig` has 8 `export fn craft_ios_*` and
41`build.zig:1590` roots the library there, not at `ios.zig`. **Android has no equivalent
42`android_main.zig`.**
43
44### What does ship
45
46`packages/android/templates/CraftBridge.kt.template` — 3,880 lines of Kotlin with **103**
47`@JavascriptInterface` methods — plus a genuinely functional builder
48(`packages/android/src/index.ts`, 599 lines) that runs `gradle wrapper`, `./gradlew`,
49`adb install -r`, and `adb shell am start -n`.
50
51Good news for the JNI plan: the Kotlin has **no coroutines and no Compose**
52(`suspend fun` count: 0). Everything it does is plain Java-API work that JNI can reach.
53
54### The bridge never connects
55
56Three verified mismatches:
57
58| | TypeScript expects | Native provides |
59|---|---|---|
60| interface name | `window.CraftBridge` | `addJavascriptInterface(craftBridge, "CraftAndroid")` |
61| envelope | `{method, params, callbackId}` | 103 typed methods, no `postMessage` at all |
62| ready event | `craft:ready` | `craftReady` |
63
64So `window.CraftBridge.postMessage(...)` is a `TypeError` on every call.
65
66---
67
68## Four blockers to clear before anything works
69
70### 1. Android currently links GTK
71
72`bridge.zig:7` switches on `builtin.os.tag`. Android's target is
73`.os_tag = .linux, .abi = .android` (`build.zig:1801-1804`), so the `.linux` arm catches it
74and routes `evalJS` into `linux.zig` — which holds **44** `extern "c"` GTK/WebKit2GTK
75declarations.
76
77Undefined symbols cost nothing in a *static archive*, which is precisely why this has never
78surfaced. **The moment we emit a `.so`, the linker demands `gtk_init` and 43 friends.**
79
80The `.linux` arm needs an `.abi == .android` guard, landed **in the same commit** as the
81linkage change. `build.zig:1940-1942`'s `linkPlatformLibraries` has the same landmine —
82its `.linux` arm links `gtk+-3.0` and `webkit2gtk-4.1`, and the Android libs must never
83start calling it without the same guard.
84
85### 2. `{⁠{PACKAGE_NAME}}` makes mangled `Java_*` symbols impossible
86
87`MainActivity.kt.template:1` is `package {⁠{PACKAGE_NAME}}`, substituted with the user's
88chosen id. JNI symbol mangling embeds the package, so a fixed export name cannot exist.
89
90**Fix, in two parts:**
91
921. **Put the native-binding class in a package Craft owns.** A new
93 `CraftNative.kt.template` declaring `package app.craft.runtime` — no substitution at all.
94 Gradle compiles multiple packages in one module without complaint, and
95 `applicationId`/`namespace` are unaffected. Now every native-facing class name is a
96 compile-time constant on the Zig side.
97
982. **Bind via `JNI_OnLoad` + `RegisterNatives`, exporting zero `Java_*` symbols.**
99
100Why `RegisterNatives` rather than mangled names, now that the package is fixed:
101
102- **It fails loudly at load.** A missing binding throws `UnsatisfiedLinkError` during
103 `onCreate`, naming the method. Mangled-name binding fails at the first call of that one
104 method, months later.
105- **The table is enumerable Zig data**, so a conformance test can assert bijection with the
106 Kotlin `external fun` declarations. Mangled names give you no artifact to check.
107- **It survives R8.** `build.gradle.kts.app.template:22-28` sets `isMinifyEnabled = true`
108 for release and `proguard-rules.pro.template` is 9 lines with no keep rule. Add
109 `-keep class app.craft.runtime.CraftNative { *; }`.
110
111### 3. The JNI vtable in the tree is mis-ordered
112
113`mobile.zig:25-40` declares `JNINativeInterface` with `reserved0..3`, then jumps straight to
114`GetVersion, FindClass, GetMethodID, …` with a literal comment at line 31:
115
116```zig
117// ... many more function pointers ...
118```
119
120The real vtable has ~230 slots in a fixed ABI order: `FindClass` is index 6,
121`GetObjectClass` is 31, `NewStringUTF` is 167. **Every function pointer read from this
122struct reads the wrong slot.** Even if it linked, every call would jump to a garbage
123address.
124
125There is also a *second*, incompatible `jni` namespace at `android.zig:20-30` — opaque
126aliases with no vtable at all.
127
128### 4. Nothing here has ever been compiled
129
130`mobile.zig:11` reads `const jni = if (target.os.tag == .linux) struct {...} else struct {};`
131so on a macOS host `jni` is an **empty struct** and `jni.JNIEnv` does not exist.
132
133Proof that no function body has ever been analysed: `mobile.zig:1292` has
134`if (callback) |cb|` where the parameter is the non-optional `*const fn (bool) void` — an
135unconditional compile error that has never fired.
136
137Other never-executed bugs in the same region: `requestPermission` (`:1275-1298`) resolves
138the **static** `ActivityCompat.requestPermissions` via `GetMethodID` and passes 2 varargs
139where the signature demands 3 with a `jobjectArray`; `createWebView` (`:1103-1106`) and
140`evaluateJavaScript` (`:1198-1206`) invoke constructors through `CallObjectMethod` where
141`NewObject` is required.
142
143---
144
145## Architecture
146
147```
148page ── craft.getPlatform()
149 │ craft-mobile.js → _req('device', 'getPlatform', d)
150 ▼
151 window.CraftBridge.postMessage(JSON.stringify({t, a, d, i}))
152 │ [JavaBridge thread]
153 ▼
154 CraftNative.postMessage → nativeHandleMessage (RegisterNatives)
155 │
156 ▼
157 android_dispatch.zig ── routes on `t`
158 │
159 ├── Zig arm → android_jni.zig → Java APIs
160 └── host arm → CraftNative.callHost(...) (Phase A6 escape hatch)
161 │
162 ▼
163 format reply ON the JavaBridge thread ← request_context is threadlocal
164 │
165 ▼
166 CraftNative.evaluateOnUi(script) → webView.post { evaluateJavascript }
167```
168
169### The threading constraint iOS doesn't have
170
171`@JavascriptInterface` methods run on the WebView's **JavaBridge** thread.
172`WebView.evaluateJavascript` **must** be called on the UI thread or it throws.
173
174And `request_context.zig` is `threadlocal` — a frame pushed on JavaBridge is invisible from
175the UI thread.
176
177**Therefore: format the reply on the JavaBridge thread, where the context frame lives, then
178hand the finished string across.** Three lines of Kotlin:
179
180```kotlin
181fun evaluateOnUi(script: String) = webView.post {
182 webView.evaluateJavascript(script, null)
183}
184```
185
186Do not reply from the UI thread. This removes an entire crash class and is worth the Kotlin.
187
188---
189
190## Decision: `@cImport` the NDK's `jni.h`
191
192**Do not hand-write the vtable. Do not vendor a copy of `jni.h`.**
193
194- **A wrong slot index compiles, links, and jumps to garbage at runtime.** `mobile.zig:25-40`
195 is the existence proof. There is no compiler check for "is `FindClass` the 7th field?",
196 the failure is silent, and it is silent *on a phone*. A 230-slot transcription is 230
197 chances to make that mistake, and reviewing it is unreviewable.
198- **Cross-compiling from macOS is already solved here.** `build.zig:9` takes `-Dmacos-sdk`
199 and `applySdkPaths` (`:1963-1976`) feeds it through `addSystemIncludePath`. Its docstring
200 is directly on point about avoiding `--sysroot` because it breaks `@cImport`. Mirror it
201 exactly as `-Dandroid-ndk`. `jni.h` is pure C — `stdarg.h` + `stdint.h` — with no Bionic
202 dependency, so translate-c reads it on a macOS host.
203- **Reproducibility comes from pinning the NDK**, which CI already does
204 (`mobile-e2e.yml:164-166` pins `ndk;26.1.10909125`). Pin it in `deps.yaml`/`pantry.jsonc`
205 beside the Zig pin.
206
207### Use only the `*A` call forms
208
209`jni.h` declares ~60 slots three times: `CallVoidMethod(...)` (C varargs),
210`CallVoidMethodV(va_list)`, and `CallVoidMethodA(const jvalue*)`.
211
212**Use `*A` exclusively.** They are non-variadic and ABI-exact, which sidesteps the pinned
213Zig version's one real hazard with variadic function-pointer fields. As a bonus, they
214structurally kill the constructor bug class: `NewObjectA` cannot be spelled as
215`CallObjectMethodA`.
216
217### The facade earns its keep
218
219`src/android_jni.zig` wraps the `@cImport` and exposes `callVoid(env, obj, mid, args)`-style
220helpers that:
221
2221. always use `*A`,
2232. call `ExceptionCheck`/`ExceptionDescribe`/`ExceptionClear` after **every** call — a
224 pending JNI exception makes the *next* JNI call abort the process, and nothing in the
225 current code checks even once,
2263. confine `@cImport` to one file, so nothing else becomes un-host-testable and a future
227 NDK change touches exactly one place.
228
229### The ABI test the hand-rolled version could never have
230
231Gated on `-Dandroid-ndk` being present:
232
233```zig
234@offsetOf(c.JNINativeInterface, "FindClass") / @sizeOf(usize) == 6
235@offsetOf(c.JNINativeInterface, "GetObjectClass") / @sizeOf(usize) == 31
236@offsetOf(c.JNINativeInterface, "NewStringUTF") / @sizeOf(usize) == 167
237@offsetOf(c.JNINativeInterface, "RegisterNatives") / @sizeOf(usize) == 215
238@sizeOf(c.JNINativeInterface) / @sizeOf(usize) >= 229 // non-vacuity floor
239```
240
241That last line matters: without it, a truncated or empty import passes. Same idiom as
242`capabilities_test.zig:92`.
243
244---
245
246## Phase A0 — Demolition
247
248Delete rather than fix. Every one of these is unreachable or actively misleading, and
249leaving them means the next reader can't tell new code from fossil.
250
251| Target | Lines | Why |
252|---|---:|---|
253| `src/android_template.zig` | 553 | Zero importers; a second Gradle/Kotlin generator superseded by `packages/android/templates/` |
254| `src/js_bridge.zig` | 635 | Zero importers (the 13 grep hits are struct *field* names, not imports) |
255| `test/android_test.zig` | 373 | Not wired into `build.zig` at all; uses the removed pre-0.15 `ArrayList.init(allocator)` at `:323`, so it wouldn't compile if it were |
256| `mobile.zig:11-110` — the `jni` namespace | 100 | Mis-ordered vtable; not fixable in place |
257| `mobile.zig:162-206` — `@export` block + both `Java_*_impl` | 45 | Bind to classes that don't exist |
258| `mobile.zig:1028-1377` — `pub const Android` | 350 | Every call reads the broken vtable; contains the static-method, constructor, and non-optional-callback bugs |
259| `mobile.zig:115-160` — `AndroidCallbackStorage` | 46 | A fixed 16-slot `% 16` table that silently aliases the 17th concurrent callback onto the 1st |
260| `android.zig:20-30` — the second `jni` namespace | 11 | Opaque aliases, no vtable |
261| `android.zig:333-412` — nine "handlers" | 80 | `handleShowToast` extracts the message, discards it, and replies `{"success":true}`. Worse than a missing handler |
262| `android.zig:419-493` — `AndroidFeatures` | 75 | Ten stubs; `isNetworkConnected()` hardcodes `true` |
263| `android.zig:260-295` — substring JSON | 36 | Breaks on any escaped quote; `std.json` is the house pattern |
264| `examples/android/main.zig` + its `build.zig` step | ~40 | Builds a *desktop* Cocoa/GTK executable and calls it the Android demo |
265
266**Keep:** `android.zig`'s `StringHashMap(Handler)` dispatcher shape (`:202-258`) as the seed
267for `android_dispatch.zig`, and `packages/android/templates/test-bridges.html` as the
268Phase A1 fixture page.
269
270**Gate:** `zig build && zig build test` green; `git grep -c 'jni\.' packages/zig/src` = 0.
271
272---
273
274## Phase A1 — Vertical slice: `device.getPlatform` on an emulator
275
276### Why this action
277
278It **cannot be faked past its own assertion**. CI compares the value the *page* printed
279against `adb shell getprop ro.build.version.sdk` and `ro.product.model`. The current stub at
280`android.zig:336` returns a hardcoded `{"os":"android","version":"14"}` and would fail.
281
282It also exercises the full vtable surface in one call — `FindClass("android/os/Build$VERSION")`
283→ `GetStaticFieldID` → `GetStaticIntField`, plus `GetStringUTFChars`/`ReleaseStringUTFChars`.
284If the imported slots were wrong, this crashes rather than lying.
285
286`showToast` was the obvious alternative and is the wrong choice: asserting a Toast from CI
287means OCR on a screenshot.
288
289### What lands
290
291**New Zig files:**
292
293| File | Contents |
294|---|---|
295| `src/android_jni.zig` | `@cImport` of `jni.h`, `*A`-only wrappers, `ExceptionCheck` on every path, `JavaVM*` cache, `attachCurrentThread()` |
296| `src/android_main.zig` | **The export root.** `JNI_OnLoad`, the `JNINativeMethod` table, `nativeOnCreate`, `nativeHandleMessage`, `nativeOnDestroy` |
297| `src/android_dispatch.zig` | `std.json` parse of `{t,a,d,i}`, `request_context` push/pop, route on `t`, reply via `bridge_error.sendResultToJS` |
298| `src/android_log.zig` | `__android_log_write` wrapper + a `std.log` `logFn` override so existing sites land in logcat |
299| `src/android_device.zig` | The `device` namespace with one action |
300
301**Zig edits:**
302
303- `bridge.zig:6-21` — an `.android` arm **before** `.linux`, guarded on
304 `builtin.abi == .android`. Without this, the `.so` link fails on GTK.
305- `build.zig:1807-1848` — root at `android_main.zig`; `.linkage = .dynamic`; name
306 `craft_android`; add `-Dandroid-ndk` and `applyAndroidNdkPaths` modelled on
307 `applySdkPaths`; `linkSystemLibrary("log")`; `-z max-page-size=16384`.
308- `src/js/craft-bridge.js:161-175` — `_post` gains a transport switch:
309 `webkit.messageHandlers.craft` → `window.CraftBridge` → warn. **Shared with iOS.**
310
311**Kotlin:**
312
313- New `CraftNative.kt.template` in `package app.craft.runtime`: `System.loadLibrary("craft_android")`,
314 `@JavascriptInterface fun postMessage(json: String)`, `fun evaluateOnUi(script: String)`,
315 and the `external fun` declarations.
316- `MainActivity.kt.template:100` — `"CraftAndroid"` → `"CraftBridge"`, fixing the name
317 mismatch against `core.ts:723`.
318- Install the bridge script via `WebViewCompat.addDocumentStartJavaScript`
319 (`androidx.webkit:webkit:1.12.1` is already a dependency, and `minSdk` is 26) rather than
320 at `onPageFinished` (`:70-73`), which any page calling `craft.*` at parse time loses today.
321 Dispatch **`craft:ready`**; emit the legacy `craftReady` alongside it for one release.
322
323`CraftBridge.kt` is **still generated and still registered** in Phase A1. The slice must not
324regress any existing app.
325
326**TypeScript / packaging:**
327
328- `index.ts` — `init()` writes `app/src/main/java/app/craft/runtime/CraftNative.kt`; a new
329 `syncNativeLibs()` copies the `.so` into `jniLibs/{arm64-v8a,x86_64}/`; **`init()` (not
330 `build()`) materializes the Gradle wrapper** — today `:341` writes
331 `gradle-wrapper.properties` but never `gradlew` itself.
332- `build.gradle.kts.app.template` — `ndk { abiFilters += listOf("arm64-v8a", "x86_64") }`.
333- `proguard-rules.pro.template` — the keep rule.
334
335### Gate
336
337```bash
338zig build build-android-x86 -Dandroid-ndk=$ANDROID_NDK_HOME
339llvm-nm -D --defined-only …/libcraft_android.so | grep -q ' T JNI_OnLoad'
340llvm-nm -D --undefined-only …/libcraft_android.so | grep -c 'gtk_\|webkit_' # must be 0
341llvm-readelf -l …/libcraft_android.so | grep LOAD | grep -q 0x4000 # 16KiB, Android 15+
342craft android init E2E --output /tmp/e2e && craft android build --output /tmp/e2e
343unzip -l …/app-debug.apk | grep -q 'lib/x86_64/libcraft_android.so'
344adb install -r … && adb shell am start -n …/.MainActivity
345adb logcat -d | grep CRAFT_RT > out
346test "$(jq -r .sdkInt <out)" = "$(adb shell getprop ro.build.version.sdk)"
347test "$(jq -r .model <out)" = "$(adb shell getprop ro.product.model)"
348```
349
350`WebChromeClient` is already set (`MainActivity.kt.template:97`) and forwards `console.log`
351to logcat.
352
353### Deferred
354
355102 of the 103 Kotlin methods (Kotlin keeps serving them); permissions; `onActivityResult`;
356event emission; arm64 exercise (builds, not tested); release/R8 builds;
357`AttachCurrentThread`; `PushLocalFrame`; the capability gate (A2).
358
359### Risks
360
361| Risk | Detection | Mitigation |
362|---|---|---|
363| **GTK link failure** — the likeliest blocker | Fires at the first `.so` link | Land the `bridge.zig` guard *before* flipping linkage; assert 0 undefined `gtk_` symbols |
364| `FindClass` returns null in `JNI_OnLoad` | `UnsatisfiedLinkError` at load | Fall back to one mangled `Java_app_craft_runtime_CraftNative_nativeBoot` called from Kotlin's static init, receiving `jclass` directly |
365| Replying off the UI thread | Silent dropped reply | The `evaluateOnUi` shim; detect via zero `E/chromium` lines |
366| 16 KiB page alignment | `.so` refuses to load on Android 15+ | `llvm-readelf -l` assertion above |
367| ABI directory naming | Zig emits `x86_64`/`aarch64`; jniLibs wants `x86_64`/`arm64-v8a`. A mismatch silently ships an APK with no native lib | The `unzip -l` assertion |
368
369---
370
371## Phases A2–A6
372
373| Phase | Scope | Gate |
374|---|---|---|
375| **A2** | Extract `macos.zig:4564-4645` into a shared `mobile_dispatch.zig` (iOS gets it free). Generalize `capabilities_test.zig`, which hardcodes desktop `@embedFile`s. Add the `RegisterNatives` ↔ Kotlin `external fun` parity test | `zig build test` fails on any drift |
376| **A3** | **Tier 0** (~20): pure JNI, no permissions, no async — `getDeviceInfo`, `getNetworkStatus`, `log`, `openURL`, `share`, `clipboard*`, `vibrate`, `haptic`, `setBadge`, `setKeepAwake`, `lockOrientation`, `setFlashlight` | `adb shell` ground truth per action (`cmd clipboard`, `dumpsys deviceidle`) |
377| **A4** | **Tier 1** (~25): state, storage, callbacks. First background threads → `AttachCurrentThread`. **`dbExecute`/`dbQuery` use the vendored SQLite** already compiled into every other target (`build.zig:1953-1959`), not JNI to `SQLiteDatabase` | Round-trip through the bridge + `dumpsys jobscheduler` |
378| **A5** | **Tier 2** (~30): permissions and Activity results | `pm grant`/`revoke`; **the denied path must reply with an error, not hang** |
379| **A6** | **Tier 3** (~28): Play Billing, ML Kit, Firebase, Health Connect, ARCore, Wear | Kotlin `@JavascriptInterface` ratchet reaches its floor |
380
381**A3 adds `PushLocalFrame`/`PopLocalFrame`** per handler, before `Intent`/`Uri` construction
382turns into a reference leak nobody can find.
383
384**A5 lands the two mechanisms as their own sub-phase before any action uses them.** Two new
385`RegisterNatives` entries (`nativeOnPermissionResult`, `nativeOnActivityResult`) fed from
386`MainActivity.kt.template:220-224`'s existing hook. Correlation needs a real
387`AutoHashMap(i32, PendingRequest)`, not a `% 16` array.
388
389`ActivityCompat.requestPermissions` is **static** (`GetStaticMethodID`,
390`CallStaticVoidMethodA`) and takes **three** args with a `jobjectArray` built by
391`NewObjectArray` + `SetObjectArrayElement`. `mobile.zig:1275-1298` gets both wrong and is
392the best worked example of what not to do.
393
394### A6: one declared escape hatch, not a JNI slog
395
396BillingClient, ML Kit, Play Review, Firebase, Health Connect, and ARCore are listener-heavy,
397generic-heavy builder APIs. Reaching them from JNI means hand-writing anonymous inner
398classes, which JNI cannot do at all without a Java shim. There is no Zig-purity win
399available; there is only a large, fragile, unreviewable surface.
400
401Instead: Zig calls `CraftNative.callHost(namespace, action, dataJson, requestId)`, and
402Kotlin answers through the **same** `nativeDeliverResult(requestId, json)` every other path
403uses. Zig still owns dispatch, correlation, capability truth, and the wire format. Kotlin
404becomes a leaf.
405
406Add `host_delegated` as a fifth `NamespaceStatus` beside `declared`, `undeclared`,
407`unavailable`, and `unrouted` (`capabilities.zig:64-73`), so `craft.capabilities()` tells
408apps honestly which surfaces are native-Zig and which are host-delegated. That is the same
409ethos as the existing "a namespace craft hasn't audited says so", extended one step.
410
411Only then delete the superseded Kotlin — expected residue 25–30 methods, down from 103.
412
413---
414
415## The conformance gate
416
417`max_undeclared = 0` for Android, **permanently**. Desktop's ratchet sits at 45
418(`capabilities_test.zig:57`) only because it inherited 52 unaudited namespaces. Android
419starts from an empty tree and has nothing to grandfather, so there is no reason to ever
420permit an undeclared Android namespace. This is the cheapest place to hold the line, and it
421is only cheap *now*.
422
423Three gates:
424
4251. **`test/capabilities_android_test.zig`** — every declared action dispatches; every
426 dispatched action is declared; a declared namespace contains no raw literal action
427 comparison. With a non-vacuity floor so a regex matching nothing fails.
4282. **`RegisterNatives` ↔ `CraftNative.kt` parity** — embed the template, scan `external fun`,
429 assert bijection with the Zig table including JNI signature strings. This is what makes
430 `RegisterNatives` worth choosing over mangled names.
4313. **Kotlin-surface ratchet** — embed `CraftBridge.kt.template`, count `@JavascriptInterface`
432 (103 today), assert `<= max_kotlin_javascript_interface`, and lower the constant each
433 phase. The spec becomes a countdown with a build-enforced direction.
434
435---
436
437## CI
438
439### `ci.yml` — every PR, no emulator, ~2 min
440
441After `zig build test` on the Linux leg:
442
443```bash
444sdkmanager --install "ndk;26.1.10909125"
445zig build build-android-all -Dandroid-ndk=$ANDROID_NDK_HOME -Doptimize=ReleaseSafe
446llvm-nm -D --defined-only …/libcraft_android.so | grep -q ' T JNI_OnLoad'
447llvm-nm -D --undefined-only …/libcraft_android.so | grep -c 'gtk_\|webkit_' | grep -q '^0$'
448llvm-readelf -l …/libcraft_android.so | grep LOAD | grep -q 0x4000
449test "$(stat -c%s …/libcraft_android.so)" -gt 100000
450```
451
452**That size floor is the direct answer to the 2,990-byte archive: an empty artifact must
453fail the build.** The `gtk_` check is the standing guard on the `bridge.zig` regression.
454
455### `mobile-e2e.yml` — currently proves nothing
456
457The Android job boots an AVD, takes a screenshot, and asserts nothing, because its only test
458step is behind `if [ -x "packages/android/gradlew" ]` — a path that **can never exist**,
459since projects are generated into a user-chosen `--output` directory.
460
461- Restore `pull_request` triggers on `packages/zig/src/android_*.zig`, `packages/android/**`, `build.zig`
462- Delete the `gradlew` guard
463- Replace the emulator script with the Phase A1 chain
464- Keep screenshots as **artifacts**, not tests
465
466`release.yml` is not touched.
467
468### `packages/android/src/index.ts`
469
4701. `init()` materializes the Gradle wrapper and fails loudly there — a project is either
471 complete or absent
4722. `syncNativeLibs()` copies the `.so` per ABI
4733. Writes `CraftNative.kt` with **no** `{⁠{PACKAGE_NAME}}` substitution
4744. `build()` fails when the `.so` is missing, rather than producing an APK that
475 `UnsatisfiedLinkError`s at launch
4765. `index.test.ts` asserts `jniLibs/`, `gradlew`, `CraftNative.kt`, and the `"CraftBridge"`
477 registration
478
479Per `CLAUDE.md`'s distribution rule, the `.so` resolution lives here in the Android builder
480— a legitimate dev-loop override — not in `binary-resolver.ts`.
481
482---
483
484## Prerequisites
485
486| | Needed | Status |
487|---|---|---|
488| Phase A0 | pinned Zig only | ✅ works today |
489| Phase A1+ | Android SDK, NDK (pinned `26.1.10909125`), `adb`, `gradle` | ❌ none present |
490
491Zig is pinned at `0.17.0-dev.1509+bb296ab9b`.
492
493---
494
495## Honest accounting
496
497Android is further from working than iOS: iOS has nine concrete compile errors, while
498Android has no JNI layer at all. But Android has one advantage — everything it needs to
499reach is plain Java API, with no Kotlin-only surface in the way.
500
501The `host_delegated` escape hatch in A6 exists so the last 28 actions don't become an
502open-ended JNI slog. And `CraftBridge.kt` keeps serving every action Zig hasn't taken over,
503so no phase ships a broken app.
docs/ios-development.mdadded+400-0
Changes to docs/ios-development.md
@@ -0,0 +1,400 @@
1# iOS Development
2
3Making iOS a Zig-native platform: Zig drives UIKit through `objc_msgSend`, exactly as
4`packages/zig/src/macos.zig` drives AppKit today.
5
6This document is the working plan. It is meant to be checked off, and the phase gates are
7meant to be run.
8
9---
10
11## Where iOS actually stands
12
13Three facts, each verified, that together explain why "iOS is broken" has been true for
14months without anyone being able to point at a single cause.
15
16**1. The Zig iOS sources have not compiled since 2026-05-07.** The Zig 0.17 migration
17(`1b6f285`) broke them; on 2026-08-18 the mobile E2E workflow was made
18`workflow_dispatch`-only (`e1bc449`) rather than repaired. `zig build build-ios-simulator`
19fails with 9 errors.
20
21**2. Nothing links the Zig library anyway.** There are no references to `craft_ios_*`,
22`@_silgen_name`, or `libcraft` anywhere in `packages/ios/`. The XcodeGen spec
23(`templates/project.yml.template`) sets no `LIBRARY_SEARCH_PATHS` and names no `.a`. Even a
24green Zig build would be dead weight.
25
26**3. What actually ships is Swift.** `packages/ios/templates/CraftApp.swift` is 5,169 lines
27with **106** dispatcher actions and a properly registered `WKScriptMessageHandler`. It
28works. `craft ios init/build/open/run` shells out to `xcodegen`, `xcodebuild`, and `simctl`,
29and those work too.
30
31So the goal is not "repair the Zig build." It is to move the native layer from Swift to Zig
32without ever having a non-working app in between.
33
34### The spec has already drifted inside one file
35
36`CraftApp.swift`'s injected JavaScript calls five `ota*` actions — `otaConfigure`,
37`otaCheckForUpdate`, `otaDownloadUpdate`, `otaApplyUpdate`, `otaRollback` — that its own
38`switch` handles **zero** times. Those promises never settle; they don't even time out,
39because the OTA methods bypass the `_createCallback` path that owns the timeout.
40
41A further 33 handled actions are unreachable from the injected JS.
42
43That is one file disagreeing with itself. The conformance gate in Phase 2 exists to make
44this class of bug impossible rather than merely fixed.
45
46---
47
48## Counting actions correctly
49
50The dispatcher region (`CraftApp.swift:516-1078`) holds exactly **106** distinct actions.
51
52A naive `grep 'case "'` over the whole file returns **139**, because sub-switches use string
53cases for haptic styles, permission names, orientations, health types, and AR primitives.
54
55**Any scanner must bound itself to the dispatcher region**, or it will fail forever on
56`case "box"`.
57
58---
59
60## Architecture
61
62```text
63page ── craft.getDeviceInfo()
64 │ craft-mobile.js → _req('mobile', 'getDeviceInfo', d)
65 ▼
66 window.webkit.messageHandlers.craft.postMessage({t, a, d, i})
67 │
68 ▼
69 WKScriptMessageHandler (Zig, registered at runtime)
70 │
71 ▼
72 ios_dispatch.zig ── routes on `t`
73 │
74 ├── Zig arm → bridge_*.zig → sendResultToJS
75 └── Swift arm → CraftSwiftShim (shrinks each phase)
76```
77
78### One envelope: `{t, a, d, i}`
79
80There are currently **five** incompatible bridge envelopes in the repo. iOS adopts the
81desktop one.
82
83Reply correlation is the hardest part of a bridge, and the desktop implementation is
84already written and tested — dual pending tables, per-call timeout, and a `_forget` so a
85late reply cannot settle someone else's call (`craft-bridge.js:203-233`), with
86`formatResultJS` stamping the request id from `request_context`
87(`bridge_error.zig:221-241`).
88
89Adopting Swift's envelope instead would mean rewriting all of that, including its reply
90escaping at `CraftApp.swift:2447`, which replaces only `'` — so any payload containing a
91backslash or a newline breaks out of the JS string literal. `bridge_error.escapeJsonString`
92already handles this correctly.
93
94Compatibility for page code written against `window.craft.getDeviceInfo()` comes from a JS
95shim, **not** from a second wire protocol. Shipping a second reply protocol "temporarily"
96is exactly how five accumulated.
97
98### What we get for free
99
100- `objc_runtime.zig` is already iOS-ready — its gate is
101 `is_darwin = .macos or .ios or .tvos or .watchos` (`objc_runtime.zig:6`).
102- `macos.zig:5071` `setupScriptMessageHandler` and `macos.zig:5017` `didReceiveScriptMessage`
103 use only the ObjC runtime, Foundation, and WebKit — **zero AppKit** — and register under
104 the name `"craft"`, which is what the page already posts to.
105- `craft-bridge.js:161-166` already builds `{t,a,d,i}` and posts to
106 `webkit.messageHandlers.craft`. iOS *is* WKWebView, so **the page side needs no change**.
107- Adding a `.ios` arm to `bridge.evalJS` (`bridge.zig:6-22`, currently
108 `error.UnsupportedPlatform`) lights up every existing `bridge_*.zig` reply path. Six lines.
109- ~20 of the 25 frameworks `CraftApp.swift` imports are Objective-C and reachable via
110 `objc_msgSend`.
111
112---
113
114## Phase 0 — Amputate, then gate
115
116**Needs no Xcode.** All of it works on Command Line Tools.
117
118Most of the nine reported errors live in code that should not exist, so deletion comes
119before repair.
120
121### Delete
122
123| Target | Lines | Why |
124|---|---:|---|
125| `src/js_bridge.zig` | 635 | Zero importers |
126| `src/ios_template.zig` | 633 | Zero importers; superseded by `packages/ios/templates/` |
127| `src/hotreload_mobile.zig` | 271 | Zero importers; won't compile under 0.17 |
128| `packages/typescript/src/bridge/ios.ts` | 1,004 | A fourth envelope, zero importers, not exported |
129| `ios.zig:556-846` — the `JSBridge` struct | ~290 | Substring JSON parsing (`extractJsonObject`'s unguarded `depth -= 1` underflows a `usize`); nine handlers calling four functions that don't exist; `handleMessage` has no caller anywhere |
130| `ios.zig:479-489` — `runMainLoop` | 11 | `UIApplicationMain` owns the run loop |
131| `ios.zig:199-263` — `injectBridgeScript` | 65 | Third envelope; injected before the navigation that wipes it; its fallback resolves `{success:true, browser:true}`, making "works" and "no bridge" indistinguishable |
132| `mobile.zig:972-1024` — `showAlert` | 53 | Uses `keyWindow`, nil in any scene-based app; computes a delay and discards it |
133| `mobile.zig:797-884` — `requestPermission` | 88 | `_ = callback;` at `:803` — discards the caller's callback and passes `null` for every completion handler |
134| `mobile.zig:667-795` — `checkPermissionStatus` + mappers | 129 | Only caller is the deleted `JSBridge` |
135| `ios_main.zig:211-223` — the export test block | 13 | The source of errors 1–3; asserts nothing a compiler wouldn't |
136
137**~3,200 lines**, removing six of the nine errors and three of the five `??*anyopaque`
138sites without writing a replacement.
139
140### Then fix what remains
141
142- `objc_runtime.zig:182,193` — `target.isDarwin()` → `target.os.tag.isDarwin()` (pre-0.17 API)
143- `objc_runtime.zig` — add `pub fn alloc(class: Class) !id` beside `allocInit`. `ios.zig:283`
144 needs the alloc half only, because `:284-286` sends `initWithFrame:` itself
145- `ios.zig:438` — `?objc.id` → `objc.id` in `LoadHTMLFn`
146- `mobile.zig:475-477` — `trackObject` takes `*anyopaque`; unwrap or skip when null
147- `mobile.zig:484` — `@ptrCast` cannot discard optionality; add the null check
148
149### The gate
150
151New `packages/zig/test/ios_surface_test.zig`, wired into `test_step` like `mobile_tests`:
152
153```zig
154test "every iOS decl compiles" {
155 std.testing.refAllDeclsRecursive(@import("../src/ios.zig"));
156 std.testing.refAllDeclsRecursive(@import("../src/mobile.zig").iOS);
157}
158```
159
160This builds for the **host** in seconds. `mobile_test.zig` is green today only because it
161touches enums and structs and Zig analyses function bodies lazily — this forces analysis,
162and every one of the nine errors plus the five latent ones becomes a host-visible compile
163error. Cross-compiling stays the source of truth; this is the loop to iterate in.
164
165**Gate:** `zig build test` passes, and passes *only after* the fixes — verify by reverting
166one and watching it fail. `zig build build-ios-simulator` and `zig build build-ios` both
167compile.
168
169---
170
171## Phase 1 — Vertical slice: `getDeviceInfo` on a simulator
172
173**Needs Xcode.**
174
175One action, round-tripped end to end, observed from inside the Zig process.
176
177### Why this action
178
179- It is a **real spec action** (`CraftApp.swift:647`), so nothing is thrown away later.
180- It reads UIKit through `objc_msgSend` — `[[UIDevice currentDevice] systemName]`,
181 `[[UIScreen mainScreen] bounds]` — proving the runtime is alive in-process.
182- Its result is **unforgeable**: `"systemName":"iOS"` and `"isSimulator":true` cannot come
183 from a fallback path. Compare `ios.zig:239-244`, whose fallback returns `{success:true}`
184 and looks exactly like success.
185
186Rejected, and worth recording why: `haptic` is fire-and-forget *and* a silent no-op on the
187simulator, so it would pass while doing nothing. `clipboardRead` triggers iOS 16+'s "Allow
188Paste?" prompt — a flake generator in CI. `showAlert` needs someone to dismiss it.
189
190### What lands
191
1921. **`UIApplicationMain` restructure.** `run()` shrinks to: register a `CraftAppDelegate`
193 class at runtime, then call `UIApplicationMain` — which never returns, so `run()` becomes
194 `noreturn`. Everything currently at `ios.zig:145-172` moves into
195 `export fn didFinishLaunching(...) callconv(.c) bool`, added under
196 `application:didFinishLaunchingWithOptions:` with type encoding `"B@:@@"`.
197
198 This is forced, not stylistic: `[UIScreen mainScreen]` returns nil before UIKit is
199 initialised, so `createWindow`'s `initWithFrame:` currently receives a garbage `CGRect`,
200 and `makeKeyAndVisible` traps with no `UIApplication` instance.
201
2022. **A real `WKScriptMessageHandler`** — port `macos.zig:5071-5122` and `:5017-5066`
203 structurally unchanged, including the `NSJSONSerialization` step. Do not write an ObjC
204 object walker; do not resurrect substring parsing.
205
2063. **User script at `atDocumentStart`** — port `macos.zig:4037-4049`.
207
208 **The order inverts.** `addScriptMessageHandler:name:` and `addUserScript:` both go on
209 the `WKUserContentController`, which must be attached to the `WKWebViewConfiguration`
210 *before* the webview is constructed. Today `ios.zig:154` injects before `:157` navigates,
211 so the navigation wipes the script.
212
2134. **`.ios` arm on `bridge.evalJS`**, plus `ios.evalJS` mirroring `macos.zig:4485-4496`.
214
2155. **A correct completion block.** `mobile.zig:555-646` is wrong four ways: `??*anyopaque`
216 parameters; a `Block.callback` signature mismatch against the function's own parameter;
217 a **stack-allocated** block handed to an asynchronous API; and a function-local
218 descriptor that dangles even if the block were copied, since `_Block_copy` copies the
219 block body but keeps the descriptor *pointer*.
220
221 Rewrite to `bridge_permissions.zig:131-164`'s shape: module-level `const` block and
222 descriptor, plain `objc.id` parameters, `extern var _NSConcreteStackBlock` with `&`.
223
2246. **`src/bridge_mobile.zig`** with exactly one action, plus a `t == "mobile"` arm in a new
225 `ios_dispatch.zig`.
226
2277. **`packages/ios/fixtures/zig-slice/`** — checked in. `main.m` is a three-line shim so
228 `_main` lives in the app target rather than the static archive.
229
230### Gate
231
232A **closed** loop, not a half loop: page posts → Zig serves → Zig replies → **Zig then
233evaluates `window.__craftSliceAck` through the block from step 5** and prints
234`CRAFT_SLICE_ACK <json>` to stderr. That final hop is what forces the block to be correct
235in Phase 1, where it belongs, since Phases 4–6 are built on it.
236
237`packages/ios/src/slice.test.ts` reuses the existing `pickSimulator` and `bootSimulator`
238(`index.ts:632,665`) and asserts `"systemName":"iOS"` and `"isSimulator":true` within 90s.
239It **skips rather than fails** when `xcode-select -p` reports Command Line Tools, so the
240repo stays green on machines without Xcode.
241
242Belt and braces: also write the ack into the app container and poll
243`simctl get_app_container`, since `--console-pipe` can drop stderr on a cold boot.
244
245### Deferred
246
247`craft-bridge.js` injection; the Swift shim; error replies; main-thread marshalling; config
248plumbing (`AppConfig.orientations`, `status_bar_style` stay inert fields); and the other 105
249actions — `ios_dispatch` answers `UNKNOWN_ACTION` for all of them, in one place.
250
251### Risks
252
253| Risk | Detection | Mitigation |
254|---|---|---|
255| Dead-strip removes `craft_ios_main` | Link error | It's referenced from `main.m`; else `-force_load` |
256| Zig `bool` ≠ ObjC `BOOL` on arm64 | App launches to black, no crash | `BOOL` is `signed char`; if it fails, return `i8` `1` |
257| `_NSConcreteStackBlock` unresolved | Link error | In libSystem; proven on macOS by `bridge_permissions.zig` |
258| `--console-pipe` drops stderr | Timeout, no output | The app-container fallback above |
259
260---
261
262## Phase 2 — Dispatcher, JS surface, and the hand-off
263
264`ios_dispatch.zig` becomes a real dispatcher: namespace routing, `sendErrorToJS` for unknown
265actions, `request_context` push/pop around every dispatch. Note `macos.zig:4646-4665` — the
266desktop bug where `handleMessage` discarded `d`. Do not repeat it.
267
268**The hand-off table is what makes everything after this incremental.** On an action it does
269not serve, `ios_dispatch` looks up `objc_getClass("CraftSwiftShim")` and sends
270`handleAction:payload:callbackId:`. One app, one message handler, one page-visible surface.
271Each later phase moves actions from the Swift arm to the Zig arm and the page notices
272nothing.
273
274`src/js/craft-mobile.js` — deliberately **not** `craft-bridge.js`, which defines
275`craft.window.*`, `craft.tray.*`, and `craft.menu.*` that iOS has no business exposing (a
276page calling `craft.tray.create()` on iOS should get a clear error, not silence). Extract
277the shared transport into `craft-bridge-core.js` and `@embedFile` it into both, so there is
278one transport rather than two.
279
280Also here: the Swift shim's reply helpers get rewritten to call `__craftBridgeResult`,
281which incidentally fixes the `'`-only escaping at `CraftApp.swift:2447`.
282
283---
284
285## Phases 3–9
286
287| Phase | Adds | Gate |
288|---|---|---|
289| **3** | +24 — no permission, no UI, no delegate: `log`, `clipboardRead/Write`, `haptic`, `openURL`, `setBadge`, `getSafeArea`, `setKeepAwake`… | A driver calling all 24, asserting 24/24 **and a floor** so a driver that finds nothing fails |
290| **4** | +10 — permissions and Keychain | **Two concurrent** permission requests resolve to the *right* promises |
291| **5** | +12 — presented UI, on a shared `ios_delegate.zig` class factory | XCUITest cancels each presenter; the rejection must reach JS |
292| **6** | +19 — long-lived subscriptions, `craft:*` events | `simctl location set 37.33,-122.03` → `craft:locationUpdate` with those coordinates |
293| **7** | +15 — contacts, calendar, notifications, health, db | Needs the SQLite fix below; watch `binary-size.yml` |
294| **8** | Swift 5,169 → ~600 lines | Conformance intersection empty |
295| **9** | +3 Vision. **AR stays Swift**, declared with a `reason` | Registry declares the boundary honestly |
296
297**Phase 3 fixes `getSafeArea`**, which currently queries the *window* (`ios.zig:498`) and
298therefore returns zeros. It needs the root view's `safeAreaInsets`.
299
300**Phase 3 also fixes `HapticType`.** `mobile.zig:887` has the seven real tags
301(`selection`, `impact_*`, `notification_*`); `ios.zig:756-761`'s six names were fiction.
302
303**Phase 4 is the highest-risk phase after Phase 1**, because it is the first time a reply is
304produced *outside* the dispatch that requested it. `request_context.current()` is a
305per-dispatch stack, so by the time an `AVCaptureDevice` completion block fires it is empty,
306`formatResultJS` stamps `null`, and correlation silently falls back to action name — which
307hands caller B's answer to caller A whenever two are in flight.
308
309This phase must land a **pending-request table** keyed by the `i` captured at dispatch. Do
310Keychain first (`SecItemAdd` is plain C with no blocks) to keep the two risks separate.
311
312**Phase 7 requires a build change.** `linkPlatformLibraries` adds `vendor/sqlite/sqlite3.c`
313(`build.zig:1955`) but is never called for any iOS target — the calls are at
314`:84,128,150,328,798,1519,1543,1566`, and the iOS targets are `:1586-1648`. `dbExecute` and
315`dbQuery` cannot work until SQLite is linked in.
316
317**Phase 9 recommendation: keep ARKit and SceneKit in Swift permanently.** `CraftApp.swift:4996-5054`
318is SceneKit node-graph manipulation; through `objc_msgSend` it would be miserable and
319low-value. Zig-native is a means, not an end, and five actions of SceneKit glue is where it
320stops paying. Declare the boundary in `capability_registry.zig` with a `reason`.
321
322### What stays Swift, permanently
323
324Thirteen actions have no usable Objective-C surface:
325
326- **StoreKit 2** — `getProducts`, `purchase`, `restorePurchases` (`Product.PurchaseResult` is Swift-only)
327- **ActivityKit** — `startLiveActivity`, `updateLiveActivity`, `endLiveActivity`
328- **WidgetKit** — `updateWidget`, `reloadWidgets`
329- **App Intents** — `registerSiriShortcut`, `removeSiriShortcut`
330- **WatchConnectivity** — `sendToWatch`, `updateWatchContext`, `isWatchReachable` (`WCSession`
331 *is* ObjC, but it is only useful paired with the Watch app template, so it stays with its peer)
332
333---
334
335## The conformance gate
336
337`packages/zig/test/ios_conformance_test.zig`, wired like `capability_conformance_tests`
338(`build.zig:786-819`). It embeds four sources and asserts four directions:
339
340| Assertion | Catches |
341|---|---|
342| **spec ⊆ (zig ∪ shim ∪ not_yet)** | An action silently dropped in migration. `not_yet` is explicit, with a **ratchet that may only go down** — like `max_undeclared` at `capabilities_test.zig:57`. Starts at 105 after Phase 1 |
343| **zig ∩ shim = ∅** | Two servers for one action, where the page gets whichever raced |
344| **js ⊆ (zig ∪ shim)**, no allow-list | The `ota*` class — a JS method whose promise nothing can settle. `CraftApp.swift` fails this **five times today** |
345| **(zig ∪ shim) ⊆ js** modulo `internal_only` | The 33 actions reachable only by hand-writing `postMessage` |
346
347Use `window_lifecycle_test.zig:52-65`'s `callsFunction` helper so a commented-out
348`// case "haptic":` doesn't count as an implementation — that is exactly the failure mode a
349substring scan invites.
350
351Bound the spec scan to the dispatcher region, and assert a floor, so a refactor that renames
352the function makes the scan find zero and **fail** rather than pass.
353
354### Extend it to TypeScript
355
356`api/mobile.ts:169` calls `craft.device.getInfo()` — a `craft.<ns>.<method>` shape no native
357side has ever provided. `packages/react/src/index.ts:6` declares `os_version` where Swift
358returns `systemVersion`.
359
360A bun test asserting every `craft.*` method the TS types promise actually exists in
361`craft-mobile.js` closes the third leg. Without it, Zig↔Swift is pinned and the TypeScript
362contract drifts on its own — which is how this happened in the first place.
363
364---
365
366## CI
367
368`mobile-e2e.yml` today boots a simulator and asserts nothing: both meaningful steps are
369gated on `hashFiles('packages/ios/TestApp/TestApp.xcodeproj')`, which has never matched.
370
371- Restore `pull_request` triggers for `packages/zig/src/ios*.zig`, `packages/zig/src/mobile.zig`,
372 `packages/ios/**`
373- Fix the two path filters the header comment flags as pointing at directories that don't exist
374- Replace the `hashFiles` guards with the checked-in fixture
375- Keep screenshots as **artifacts**, not tests
376
377`release.yml` is not touched. The Apple signing gate stays exactly as it is.
378
379---
380
381## Prerequisites
382
383| | Needed | Status |
384|---|---|---|
385| Phase 0 | nothing beyond the pinned Zig | ✅ works today on Command Line Tools |
386| Phase 1+ | full Xcode — SDK, simulator runtime | ❌ install required |
387
388Zig is pinned at `0.17.0-dev.1509+bb296ab9b`. Clear `.zig-cache` between heavy rounds.
389
390---
391
392## Honest accounting
393
394This replaces working Swift with Zig. The payoff — one implementation instead of three,
395enforced by a compiler and a conformance test rather than by convention — does not arrive
396until Phase 8.
397
398The hand-off table exists so that every phase before then ships a **working app**, not a
399half-migrated one. If this effort stalls at any point, the app still runs: Swift keeps
400serving everything Zig hasn't taken over yet.
packages/typescript/src/bridge/ios.tsdeleted+0-1004
Changes to packages/typescript/src/bridge/ios.ts
@@ -1,1004 +0,0 @@
1/**
2 * Craft iOS Bridge
3 * Complete iOS native bridge with WebView, permissions, haptics, and platform APIs
4 */
5
6import { secureId } from './ids.js'
7
8// Types
9export interface IOSWebViewConfig {
10 url?: string
11 html?: string
12 allowsBackForwardNavigationGestures?: boolean
13 allowsInlineMediaPlayback?: boolean
14 mediaTypesRequiringUserAction?: ('audio' | 'video' | 'all' | 'none')[]
15 suppressesIncrementalRendering?: boolean
16 allowsAirPlayForMediaPlayback?: boolean
17 scrollEnabled?: boolean
18 bounces?: boolean
19 contentInsetAdjustmentBehavior?: 'automatic' | 'scrollableAxes' | 'never' | 'always'
20}
21
22export interface IOSPermission {
23 type:
24 | 'camera'
25 | 'microphone'
26 | 'photos'
27 | 'location'
28 | 'locationAlways'
29 | 'contacts'
30 | 'calendar'
31 | 'reminders'
32 | 'notifications'
33 | 'bluetooth'
34 | 'healthKit'
35 | 'motion'
36 | 'speechRecognition'
37 | 'mediaLibrary'
38 | 'siri'
39 | 'faceID'
40 | 'tracking'
41 status: 'notDetermined' | 'restricted' | 'denied' | 'authorized' | 'authorizedWhenInUse' | 'provisional'
42}
43
44export interface IOSHapticFeedback {
45 type: 'impact' | 'notification' | 'selection'
46 style?: 'light' | 'medium' | 'heavy' | 'soft' | 'rigid'
47 notificationType?: 'success' | 'warning' | 'error'
48}
49
50export interface IOSAppClipConfig {
51 invocationURL: string
52 experienceType: 'default' | 'locationBased'
53 businessCategory?: string
54 subtitle?: string
55}
56
57export interface IOSSharePlayActivity {
58 activityIdentifier: string
59 fallbackURL?: string
60 title: string
61 subtitle?: string
62 image?: string
63}
64
65export interface IOSLiveActivity {
66 activityId: string
67 contentState: Record<string, unknown>
68 staleDate?: Date
69 relevanceScore?: number
70}
71
72export interface IOSFocusFilter {
73 identifier: string
74 name: string
75 iconSystemName?: string
76 parameters: Record<string, unknown>
77}
78
79export interface IOSAppIntent {
80 identifier: string
81 title: string
82 description?: string
83 parameters?: Array<{
84 name: string
85 type: 'string' | 'number' | 'boolean' | 'date' | 'url'
86 required?: boolean
87 }>
88}
89
90export interface IOSTipKitTip {
91 identifier: string
92 title: string
93 message: string
94 imageName?: string
95 actions?: Array<{ identifier: string; title: string }>
96}
97
98export interface IOSStoreKitProduct {
99 productId: string
100 displayName: string
101 description: string
102 price: number
103 displayPrice: string
104 type: 'consumable' | 'nonConsumable' | 'autoRenewable' | 'nonRenewable'
105}
106
107export interface IOSCarPlayTemplate {
108 type: 'list' | 'grid' | 'tab' | 'information' | 'pointOfInterest' | 'nowPlaying' | 'alert' | 'action'
109 title: string
110 items?: Array<{ title: string; subtitle?: string; image?: string; handler?: string }>
111}
112
113// iOS WebView Bridge
114export class IOSWebView {
115 private id: string
116 private config: IOSWebViewConfig
117
118 constructor(config: IOSWebViewConfig = {}) {
119 this.id = secureId('webview')
120 this.config = config
121 }
122
123 /**
124 * Create the WebView (calls Objective-C runtime)
125 */
126 async create(): Promise<void> {
127 await this.callNative('createWebView', {
128 id: this.id,
129 config: this.config,
130 })
131 }
132
133 /**
134 * Load a URL
135 */
136 async loadURL(url: string): Promise<void> {
137 await this.callNative('loadURL', { id: this.id, url })
138 }
139
140 /**
141 * Load HTML content
142 */
143 async loadHTML(html: string, baseURL?: string): Promise<void> {
144 await this.callNative('loadHTML', { id: this.id, html, baseURL })
145 }
146
147 /**
148 * Evaluate JavaScript in the WebView
149 */
150 async evaluateJavaScript<T = unknown>(script: string): Promise<T> {
151 return this.callNative('evaluateJavaScript', { id: this.id, script })
152 }
153
154 /**
155 * Go back in history
156 */
157 async goBack(): Promise<void> {
158 await this.callNative('goBack', { id: this.id })
159 }
160
161 /**
162 * Go forward in history
163 */
164 async goForward(): Promise<void> {
165 await this.callNative('goForward', { id: this.id })
166 }
167
168 /**
169 * Reload the current page
170 */
171 async reload(): Promise<void> {
172 await this.callNative('reload', { id: this.id })
173 }
174
175 /**
176 * Stop loading
177 */
178 async stopLoading(): Promise<void> {
179 await this.callNative('stopLoading', { id: this.id })
180 }
181
182 /**
183 * Take a snapshot of the WebView
184 */
185 async takeSnapshot(): Promise<string> {
186 return this.callNative('takeSnapshot', { id: this.id })
187 }
188
189 /**
190 * Destroy the WebView
191 */
192 async destroy(): Promise<void> {
193 await this.callNative('destroyWebView', { id: this.id })
194 }
195
196 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
197 // Bridge to native via window.webkit.messageHandlers or custom bridge
198 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
199 return new Promise((resolve, reject) => {
200 const callbackId = secureId('cb')
201 ;(window as any)[callbackId] = (result: T, error?: string) => {
202 delete (window as any)[callbackId]
203 if (error) reject(new Error(error))
204 else resolve(result)
205 }
206 ;(window as any).webkit.messageHandlers.craft.postMessage({
207 method,
208 params,
209 callbackId,
210 })
211 })
212 }
213 // Fallback for non-iOS environments
214 console.warn(`[IOSBridge] ${method} called but not in iOS WebView context`)
215 return undefined as T
216 }
217}
218
219// iOS Permissions
220export class IOSPermissions {
221 /**
222 * Check permission status
223 */
224 async check(type: IOSPermission['type']): Promise<IOSPermission['status']> {
225 return this.callNative('checkPermission', { type })
226 }
227
228 /**
229 * Request permission
230 */
231 async request(type: IOSPermission['type']): Promise<IOSPermission['status']> {
232 return this.callNative('requestPermission', { type })
233 }
234
235 /**
236 * Open app settings
237 */
238 async openSettings(): Promise<void> {
239 await this.callNative('openSettings', {})
240 }
241
242 /**
243 * Check if can open settings
244 */
245 async canOpenSettings(): Promise<boolean> {
246 return this.callNative('canOpenSettings', {})
247 }
248
249 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
250 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
251 return new Promise((resolve, reject) => {
252 const callbackId = secureId('cb')
253 ;(window as any)[callbackId] = (result: T, error?: string) => {
254 delete (window as any)[callbackId]
255 if (error) reject(new Error(error))
256 else resolve(result)
257 }
258 ;(window as any).webkit.messageHandlers.craft.postMessage({
259 method,
260 params,
261 callbackId,
262 })
263 })
264 }
265 return 'authorized' as T // Default for non-iOS
266 }
267}
268
269// iOS Haptics
270export class IOSHaptics {
271 /**
272 * Trigger impact feedback
273 */
274 async impact(style: IOSHapticFeedback['style'] = 'medium'): Promise<void> {
275 await this.callNative('triggerHaptic', { type: 'impact', style })
276 }
277
278 /**
279 * Trigger notification feedback
280 */
281 async notification(type: IOSHapticFeedback['notificationType'] = 'success'): Promise<void> {
282 await this.callNative('triggerHaptic', { type: 'notification', notificationType: type })
283 }
284
285 /**
286 * Trigger selection feedback
287 */
288 async selection(): Promise<void> {
289 await this.callNative('triggerHaptic', { type: 'selection' })
290 }
291
292 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
293 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
294 return new Promise((resolve) => {
295 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params })
296 resolve(undefined as T)
297 })
298 }
299 return undefined as T
300 }
301}
302
303// iOS App Clips
304export class IOSAppClips {
305 /**
306 * Configure App Clip experience
307 */
308 async configure(config: IOSAppClipConfig): Promise<void> {
309 await this.callNative('configureAppClip', config)
310 }
311
312 /**
313 * Get invocation URL
314 */
315 async getInvocationURL(): Promise<string | null> {
316 return this.callNative('getAppClipInvocationURL', {})
317 }
318
319 /**
320 * Check if running as App Clip
321 */
322 async isAppClip(): Promise<boolean> {
323 return this.callNative('isAppClip', {})
324 }
325
326 /**
327 * Request full app installation
328 */
329 async requestFullAppInstallation(): Promise<void> {
330 await this.callNative('requestFullAppInstallation', {})
331 }
332
333 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
334 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
335 return new Promise((resolve, reject) => {
336 const callbackId = `cb_${Date.now()}`
337 ;(window as any)[callbackId] = (result: T, error?: string) => {
338 delete (window as any)[callbackId]
339 if (error) reject(new Error(error))
340 else resolve(result)
341 }
342 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
343 })
344 }
345 return null as T
346 }
347}
348
349// iOS SharePlay
350export class IOSSharePlay {
351 private activity: IOSSharePlayActivity | null = null
352
353 /**
354 * Start a SharePlay activity
355 */
356 async startActivity(activity: IOSSharePlayActivity): Promise<void> {
357 this.activity = activity
358 await this.callNative('startSharePlayActivity', activity)
359 }
360
361 /**
362 * End the current SharePlay activity
363 */
364 async endActivity(): Promise<void> {
365 if (this.activity) {
366 await this.callNative('endSharePlayActivity', { activityId: this.activity.activityIdentifier })
367 this.activity = null
368 }
369 }
370
371 /**
372 * Check if SharePlay is available
373 */
374 async isAvailable(): Promise<boolean> {
375 return this.callNative('isSharePlayAvailable', {})
376 }
377
378 /**
379 * Send message to participants
380 */
381 async sendMessage(data: unknown): Promise<void> {
382 await this.callNative('sendSharePlayMessage', { data })
383 }
384
385 /**
386 * Listen for messages
387 */
388 onMessage(callback: (data: unknown) => void): () => void {
389 const handler = (event: CustomEvent) => callback(event.detail)
390 window.addEventListener('shareplay-message' as any, handler)
391 return () => window.removeEventListener('shareplay-message' as any, handler)
392 }
393
394 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
395 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
396 return new Promise((resolve, reject) => {
397 const callbackId = `cb_${Date.now()}`
398 ;(window as any)[callbackId] = (result: T, error?: string) => {
399 delete (window as any)[callbackId]
400 if (error) reject(new Error(error))
401 else resolve(result)
402 }
403 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
404 })
405 }
406 return false as T
407 }
408}
409
410// iOS Live Activities
411export class IOSLiveActivities {
412 /**
413 * Start a Live Activity
414 */
415 async start(activity: Omit<IOSLiveActivity, 'activityId'>): Promise<string> {
416 return this.callNative('startLiveActivity', activity)
417 }
418
419 /**
420 * Update a Live Activity
421 */
422 async update(activityId: string, contentState: Record<string, unknown>): Promise<void> {
423 await this.callNative('updateLiveActivity', { activityId, contentState })
424 }
425
426 /**
427 * End a Live Activity
428 */
429 async end(activityId: string, dismissalPolicy?: 'immediate' | 'default' | 'after'): Promise<void> {
430 await this.callNative('endLiveActivity', { activityId, dismissalPolicy })
431 }
432
433 /**
434 * Get all active Live Activities
435 */
436 async getAll(): Promise<IOSLiveActivity[]> {
437 return this.callNative('getAllLiveActivities', {})
438 }
439
440 /**
441 * Check if Live Activities are supported
442 */
443 async areSupported(): Promise<boolean> {
444 return this.callNative('areLiveActivitiesSupported', {})
445 }
446
447 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
448 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
449 return new Promise((resolve, reject) => {
450 const callbackId = `cb_${Date.now()}`
451 ;(window as any)[callbackId] = (result: T, error?: string) => {
452 delete (window as any)[callbackId]
453 if (error) reject(new Error(error))
454 else resolve(result)
455 }
456 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
457 })
458 }
459 return [] as T
460 }
461}
462
463// iOS Focus Filters
464export class IOSFocusFilters {
465 /**
466 * Register a focus filter
467 */
468 async register(filter: IOSFocusFilter): Promise<void> {
469 await this.callNative('registerFocusFilter', filter)
470 }
471
472 /**
473 * Get current focus filter
474 */
475 async getCurrent(): Promise<IOSFocusFilter | null> {
476 return this.callNative('getCurrentFocusFilter', {})
477 }
478
479 /**
480 * Check if a focus is active
481 */
482 async isFocusActive(): Promise<boolean> {
483 return this.callNative('isFocusActive', {})
484 }
485
486 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
487 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
488 return new Promise((resolve, reject) => {
489 const callbackId = `cb_${Date.now()}`
490 ;(window as any)[callbackId] = (result: T, error?: string) => {
491 delete (window as any)[callbackId]
492 if (error) reject(new Error(error))
493 else resolve(result)
494 }
495 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
496 })
497 }
498 return null as T
499 }
500}
501
502// iOS App Intents
503export class IOSAppIntents {
504 /**
505 * Register an App Intent
506 */
507 async register(intent: IOSAppIntent): Promise<void> {
508 await this.callNative('registerAppIntent', intent)
509 }
510
511 /**
512 * Donate an intent (for suggestions)
513 */
514 async donate(intentIdentifier: string, parameters?: Record<string, unknown>): Promise<void> {
515 await this.callNative('donateAppIntent', { intentIdentifier, parameters })
516 }
517
518 /**
519 * Handle intent execution
520 */
521 onExecute(callback: (intent: IOSAppIntent, parameters: Record<string, unknown>) => Promise<unknown>): () => void {
522 const handler = async (event: CustomEvent) => {
523 const result = await callback(event.detail.intent, event.detail.parameters)
524 if ((window as any).webkit?.messageHandlers?.craft) {
525 ;(window as any).webkit.messageHandlers.craft.postMessage({
526 method: 'appIntentResult',
527 params: { intentId: event.detail.intentId, result },
528 })
529 }
530 }
531 window.addEventListener('app-intent-execute' as any, handler)
532 return () => window.removeEventListener('app-intent-execute' as any, handler)
533 }
534
535 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
536 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
537 return new Promise((resolve, reject) => {
538 const callbackId = `cb_${Date.now()}`
539 ;(window as any)[callbackId] = (result: T, error?: string) => {
540 delete (window as any)[callbackId]
541 if (error) reject(new Error(error))
542 else resolve(result)
543 }
544 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
545 })
546 }
547 return undefined as T
548 }
549}
550
551// iOS TipKit
552export class IOSTipKit {
553 /**
554 * Configure TipKit
555 */
556 async configure(options?: { displayFrequency?: 'immediate' | 'hourly' | 'daily' | 'weekly' | 'monthly' }): Promise<void> {
557 await this.callNative('configureTipKit', options || {})
558 }
559
560 /**
561 * Register a tip
562 */
563 async registerTip(tip: IOSTipKitTip): Promise<void> {
564 await this.callNative('registerTip', tip)
565 }
566
567 /**
568 * Show a tip
569 */
570 async showTip(identifier: string): Promise<void> {
571 await this.callNative('showTip', { identifier })
572 }
573
574 /**
575 * Invalidate a tip
576 */
577 async invalidateTip(identifier: string): Promise<void> {
578 await this.callNative('invalidateTip', { identifier })
579 }
580
581 /**
582 * Reset all tips
583 */
584 async resetAllTips(): Promise<void> {
585 await this.callNative('resetAllTips', {})
586 }
587
588 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
589 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
590 return new Promise((resolve, reject) => {
591 const callbackId = `cb_${Date.now()}`
592 ;(window as any)[callbackId] = (result: T, error?: string) => {
593 delete (window as any)[callbackId]
594 if (error) reject(new Error(error))
595 else resolve(result)
596 }
597 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
598 })
599 }
600 return undefined as T
601 }
602}
603
604// iOS StoreKit 2
605export class IOSStoreKit {
606 /**
607 * Get available products
608 */
609 async getProducts(productIds: string[]): Promise<IOSStoreKitProduct[]> {
610 return this.callNative('getProducts', { productIds })
611 }
612
613 /**
614 * Purchase a product
615 */
616 async purchase(productId: string): Promise<{ transactionId: string; status: 'purchased' | 'pending' | 'cancelled' }> {
617 return this.callNative('purchaseProduct', { productId })
618 }
619
620 /**
621 * Restore purchases
622 */
623 async restorePurchases(): Promise<Array<{ productId: string; transactionId: string }>> {
624 return this.callNative('restorePurchases', {})
625 }
626
627 /**
628 * Check entitlement
629 */
630 async checkEntitlement(productId: string): Promise<boolean> {
631 return this.callNative('checkEntitlement', { productId })
632 }
633
634 /**
635 * Get subscription status
636 */
637 async getSubscriptionStatus(productId: string): Promise<{
638 isActive: boolean
639 willRenew: boolean
640 expirationDate?: string
641 gracePeriodExpirationDate?: string
642 } | null> {
643 return this.callNative('getSubscriptionStatus', { productId })
644 }
645
646 /**
647 * Present offer code redemption sheet
648 */
649 async presentOfferCodeRedemption(): Promise<void> {
650 await this.callNative('presentOfferCodeRedemption', {})
651 }
652
653 /**
654 * Listen for transaction updates
655 */
656 onTransactionUpdate(callback: (transaction: { productId: string; transactionId: string; status: string }) => void): () => void {
657 const handler = (event: CustomEvent) => callback(event.detail)
658 window.addEventListener('storekit-transaction' as any, handler)
659 return () => window.removeEventListener('storekit-transaction' as any, handler)
660 }
661
662 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
663 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
664 return new Promise((resolve, reject) => {
665 const callbackId = `cb_${Date.now()}`
666 ;(window as any)[callbackId] = (result: T, error?: string) => {
667 delete (window as any)[callbackId]
668 if (error) reject(new Error(error))
669 else resolve(result)
670 }
671 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
672 })
673 }
674 return [] as T
675 }
676}
677
678// iOS CarPlay
679export class IOSCarPlay {
680 private connected = false
681
682 /**
683 * Check if CarPlay is connected
684 */
685 async isConnected(): Promise<boolean> {
686 return this.callNative('isCarPlayConnected', {})
687 }
688
689 /**
690 * Set root template
691 */
692 async setRootTemplate(template: IOSCarPlayTemplate): Promise<void> {
693 await this.callNative('setCarPlayRootTemplate', template)
694 }
695
696 /**
697 * Push a template
698 */
699 async pushTemplate(template: IOSCarPlayTemplate, animated = true): Promise<void> {
700 await this.callNative('pushCarPlayTemplate', { template, animated })
701 }
702
703 /**
704 * Pop the current template
705 */
706 async popTemplate(animated = true): Promise<void> {
707 await this.callNative('popCarPlayTemplate', { animated })
708 }
709
710 /**
711 * Present an alert
712 */
713 async presentAlert(title: string, message?: string, actions?: Array<{ title: string; style?: 'default' | 'cancel' | 'destructive' }>): Promise<number> {
714 return this.callNative('presentCarPlayAlert', { title, message, actions })
715 }
716
717 /**
718 * Update Now Playing info
719 */
720 async updateNowPlaying(info: {
721 title: string
722 artist?: string
723 album?: string
724 artwork?: string
725 duration?: number
726 elapsedTime?: number
727 playbackRate?: number
728 }): Promise<void> {
729 await this.callNative('updateCarPlayNowPlaying', info)
730 }
731
732 /**
733 * Listen for CarPlay connection changes
734 */
735 onConnectionChange(callback: (connected: boolean) => void): () => void {
736 const handler = (event: CustomEvent) => {
737 this.connected = event.detail.connected
738 callback(event.detail.connected)
739 }
740 window.addEventListener('carplay-connection' as any, handler)
741 return () => window.removeEventListener('carplay-connection' as any, handler)
742 }
743
744 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
745 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
746 return new Promise((resolve, reject) => {
747 const callbackId = `cb_${Date.now()}`
748 ;(window as any)[callbackId] = (result: T, error?: string) => {
749 delete (window as any)[callbackId]
750 if (error) reject(new Error(error))
751 else resolve(result)
752 }
753 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
754 })
755 }
756 return false as T
757 }
758}
759
760// iOS Native Components
761export class IOSNativeComponents {
762 /**
763 * Create a native navigation controller
764 */
765 async createNavigationController(config: {
766 title?: string
767 largeTitleDisplayMode?: 'automatic' | 'always' | 'never'
768 prefersLargeTitles?: boolean
769 tintColor?: string
770 }): Promise<string> {
771 return this.callNative('createNavigationController', config)
772 }
773
774 /**
775 * Create a native tab bar controller
776 */
777 async createTabBarController(tabs: Array<{
778 title: string
779 icon: string
780 selectedIcon?: string
781 badgeValue?: string
782 }>): Promise<string> {
783 return this.callNative('createTabBarController', { tabs })
784 }
785
786 /**
787 * Create a native collection view
788 */
789 async createCollectionView(config: {
790 layout: 'flow' | 'compositional' | 'list'
791 itemSize?: { width: number; height: number }
792 sectionInsets?: { top: number; left: number; bottom: number; right: number }
793 minimumLineSpacing?: number
794 minimumInteritemSpacing?: number
795 }): Promise<string> {
796 return this.callNative('createCollectionView', config)
797 }
798
799 /**
800 * Show SwiftUI view
801 */
802 async showSwiftUIView(viewName: string, props?: Record<string, unknown>): Promise<void> {
803 await this.callNative('showSwiftUIView', { viewName, props })
804 }
805
806 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
807 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
808 return new Promise((resolve, reject) => {
809 const callbackId = `cb_${Date.now()}`
810 ;(window as any)[callbackId] = (result: T, error?: string) => {
811 delete (window as any)[callbackId]
812 if (error) reject(new Error(error))
813 else resolve(result)
814 }
815 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
816 })
817 }
818 return '' as T
819 }
820}
821
822// iOS Push Notifications
823export class IOSPushNotifications {
824 /**
825 * Register for remote notifications
826 */
827 async register(): Promise<string> {
828 return this.callNative('registerForRemoteNotifications', {})
829 }
830
831 /**
832 * Get APNs device token
833 */
834 async getDeviceToken(): Promise<string | null> {
835 return this.callNative('getAPNsDeviceToken', {})
836 }
837
838 /**
839 * Schedule a local notification
840 */
841 async scheduleLocal(notification: {
842 identifier: string
843 title: string
844 body: string
845 subtitle?: string
846 badge?: number
847 sound?: string | 'default'
848 userInfo?: Record<string, unknown>
849 trigger: { type: 'timeInterval'; seconds: number; repeats?: boolean } | { type: 'calendar'; dateComponents: Record<string, number>; repeats?: boolean } | { type: 'location'; latitude: number; longitude: number; radius: number; notifyOnEntry?: boolean; notifyOnExit?: boolean }
850 categoryIdentifier?: string
851 threadIdentifier?: string
852 interruptionLevel?: 'passive' | 'active' | 'timeSensitive' | 'critical'
853 relevanceScore?: number
854 }): Promise<void> {
855 await this.callNative('scheduleLocalNotification', notification)
856 }
857
858 /**
859 * Cancel pending notifications
860 */
861 async cancelPending(identifiers: string[]): Promise<void> {
862 await this.callNative('cancelPendingNotifications', { identifiers })
863 }
864
865 /**
866 * Get pending notifications
867 */
868 async getPending(): Promise<Array<{ identifier: string; trigger: unknown }>> {
869 return this.callNative('getPendingNotifications', {})
870 }
871
872 /**
873 * Handle notification response
874 */
875 onNotificationResponse(callback: (response: { identifier: string; actionIdentifier: string; userInfo: Record<string, unknown> }) => void): () => void {
876 const handler = (event: CustomEvent) => callback(event.detail)
877 window.addEventListener('notification-response' as any, handler)
878 return () => window.removeEventListener('notification-response' as any, handler)
879 }
880
881 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
882 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
883 return new Promise((resolve, reject) => {
884 const callbackId = `cb_${Date.now()}`
885 ;(window as any)[callbackId] = (result: T, error?: string) => {
886 delete (window as any)[callbackId]
887 if (error) reject(new Error(error))
888 else resolve(result)
889 }
890 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
891 })
892 }
893 return null as T
894 }
895}
896
897// iOS App Lifecycle
898export class IOSAppLifecycle {
899 /**
900 * Get current app state
901 */
902 async getState(): Promise<'active' | 'inactive' | 'background'> {
903 return this.callNative('getAppState', {})
904 }
905
906 /**
907 * Register for state restoration
908 */
909 async registerStateRestoration(activityType: string): Promise<void> {
910 await this.callNative('registerStateRestoration', { activityType })
911 }
912
913 /**
914 * Save user activity for state restoration
915 */
916 async saveUserActivity(activityType: string, userInfo: Record<string, unknown>): Promise<void> {
917 await this.callNative('saveUserActivity', { activityType, userInfo })
918 }
919
920 /**
921 * Register background task
922 */
923 async registerBackgroundTask(identifier: string, handler: () => Promise<void>): Promise<void> {
924 const wrappedHandler = async (event: CustomEvent) => {
925 if (event.detail.identifier === identifier) {
926 await handler()
927 if ((window as any).webkit?.messageHandlers?.craft) {
928 ;(window as any).webkit.messageHandlers.craft.postMessage({
929 method: 'backgroundTaskComplete',
930 params: { identifier },
931 })
932 }
933 }
934 }
935 window.addEventListener('background-task' as any, wrappedHandler)
936 await this.callNative('registerBackgroundTask', { identifier })
937 }
938
939 /**
940 * Schedule background refresh
941 */
942 async scheduleBackgroundRefresh(identifier: string, earliestBeginDate?: Date): Promise<void> {
943 await this.callNative('scheduleBackgroundRefresh', { identifier, earliestBeginDate: earliestBeginDate?.toISOString() })
944 }
945
946 /**
947 * Listen for app state changes
948 */
949 onStateChange(callback: (state: 'active' | 'inactive' | 'background') => void): () => void {
950 const handler = (event: CustomEvent) => callback(event.detail.state)
951 window.addEventListener('app-state-change' as any, handler)
952 return () => window.removeEventListener('app-state-change' as any, handler)
953 }
954
955 private async callNative<T>(method: string, params: Record<string, unknown> | object): Promise<T> {
956 if (typeof window !== 'undefined' && (window as any).webkit?.messageHandlers?.craft) {
957 return new Promise((resolve, reject) => {
958 const callbackId = `cb_${Date.now()}`
959 ;(window as any)[callbackId] = (result: T, error?: string) => {
960 delete (window as any)[callbackId]
961 if (error) reject(new Error(error))
962 else resolve(result)
963 }
964 ;(window as any).webkit.messageHandlers.craft.postMessage({ method, params, callbackId })
965 })
966 }
967 return 'active' as T
968 }
969}
970
971// Export all iOS modules
972export const ios: {
973 WebView: typeof IOSWebView
974 Permissions: IOSPermissions
975 Haptics: IOSHaptics
976 AppClips: IOSAppClips
977 SharePlay: IOSSharePlay
978 LiveActivities: IOSLiveActivities
979 FocusFilters: IOSFocusFilters
980 AppIntents: IOSAppIntents
981 TipKit: IOSTipKit
982 StoreKit: IOSStoreKit
983 CarPlay: IOSCarPlay
984 NativeComponents: IOSNativeComponents
985 PushNotifications: IOSPushNotifications
986 AppLifecycle: IOSAppLifecycle
987} = {
988 WebView: IOSWebView,
989 Permissions: new IOSPermissions(),
990 Haptics: new IOSHaptics(),
991 AppClips: new IOSAppClips(),
992 SharePlay: new IOSSharePlay(),
993 LiveActivities: new IOSLiveActivities(),
994 FocusFilters: new IOSFocusFilters(),
995 AppIntents: new IOSAppIntents(),
996 TipKit: new IOSTipKit(),
997 StoreKit: new IOSStoreKit(),
998 CarPlay: new IOSCarPlay(),
999 NativeComponents: new IOSNativeComponents(),
1000 PushNotifications: new IOSPushNotifications(),
1001 AppLifecycle: new IOSAppLifecycle(),
1002}
1003
1004export default ios
packages/zig/build.zigmodified+42-0
Changes to packages/zig/build.zig
@@ -161,6 +161,13 @@ pub fn build(b: *std.Build) void {
161161 .root_source_file = b.path("src/mobile.zig"),
162162 });
163163
164 // Rooted at `src/ios.zig`, which reaches `src/mobile.zig` through its own
165 // relative import — so this module owns both files and must not be mixed
166 // with `mobile_module` in one compilation.
167 const ios_module = b.createModule(.{
168 .root_source_file = b.path("src/ios.zig"),
169 });
170
164171 const menubar_module = b.createModule(.{
165172 .root_source_file = b.path("src/menubar.zig"),
166173 });
@@ -292,6 +299,36 @@ pub fn build(b: *std.Build) void {
292299 }),
293300 });
294301
302 // The iOS surface gate. Rooted at `src/ios.zig` rather than sharing
303 // `mobile_module`, because a file may belong to only one module per
304 // compilation and `ios.zig` reaches `mobile.zig` through a relative
305 // import of its own. The `mobile.iOS` half of the gate therefore lives in
306 // `test/mobile_test.zig`, which already owns that module.
307 //
308 // This builds for the host, so it costs seconds and runs in `zig build
309 // test` — which is the point. Cross-compiling to iOS is the truth, but it
310 // is not a loop anyone iterates in locally.
311 const ios_surface_tests = b.addTest(.{
312 .root_module = b.createModule(.{
313 .root_source_file = b.path("test/ios_surface_test.zig"),
314 .target = target,
315 .optimize = optimize,
316 .imports = &.{
317 .{ .name = "../src/ios.zig", .module = ios_module },
318 },
319 }),
320 });
321 // Forcing analysis of every declaration means the linker now sees every
322 // `objc_msgSend`/`sel_registerName` reference too, so the ObjC runtime has
323 // to be present. No frameworks are needed: nothing here calls UIKit or
324 // AppKit, it only resolves classes by name at runtime — which is exactly
325 // why `[UIScreen mainScreen]` returns null on the host rather than failing
326 // to link.
327 if (target.result.os.tag.isDarwin()) {
328 ios_surface_tests.root_module.link_libc = true;
329 ios_surface_tests.root_module.linkSystemLibrary("objc", .{});
330 }
331
295332 const menubar_tests = b.addTest(.{
296333 .root_module = b.createModule(.{
297334 .root_source_file = b.path("test/menubar_test.zig"),
@@ -1136,6 +1173,7 @@ pub fn build(b: *std.Build) void {
11361173
11371174 const run_api_tests = b.addRunArtifact(api_tests);
11381175 const run_mobile_tests = b.addRunArtifact(mobile_tests);
1176 const run_ios_surface_tests = b.addRunArtifact(ios_surface_tests);
11391177 const run_menubar_tests = b.addRunArtifact(menubar_tests);
11401178 const run_components_tests = b.addRunArtifact(components_tests);
11411179 const run_gpu_tests = b.addRunArtifact(gpu_tests);
@@ -1261,6 +1299,7 @@ pub fn build(b: *std.Build) void {
12611299 if (js_test_run) |run| test_step.dependOn(&run.step);
12621300 test_step.dependOn(&run_api_tests.step);
12631301 test_step.dependOn(&run_mobile_tests.step);
1302 test_step.dependOn(&run_ios_surface_tests.step);
12641303 test_step.dependOn(&run_menubar_tests.step);
12651304 test_step.dependOn(&run_components_tests.step);
12661305 test_step.dependOn(&run_gpu_tests.step);
@@ -1339,6 +1378,9 @@ pub fn build(b: *std.Build) void {
13391378 const test_mobile_step = b.step("test:mobile", "Run Mobile tests");
13401379 test_mobile_step.dependOn(&run_mobile_tests.step);
13411380
1381 const test_ios_step = b.step("test:ios", "Run the iOS surface gate");
1382 test_ios_step.dependOn(&run_ios_surface_tests.step);
1383
13421384 const test_menubar_step = b.step("test:menubar", "Run Menubar tests");
13431385 test_menubar_step.dependOn(&run_menubar_tests.step);
13441386
packages/zig/src/hotreload_mobile.zigdeleted+0-271
Changes to packages/zig/src/hotreload_mobile.zig
@@ -1,271 +0,0 @@
1const std = @import("std");
2const hotreload = @import("hotreload.zig");
3
4/// Mobile Hot Reload
5/// WebSocket-based hot reload for iOS and Android
6pub const MobileHotReloadServer = struct {
7 allocator: std.mem.Allocator,
8 port: u16,
9 running: bool = false,
10 clients: std.ArrayList(Client),
11
12 const Client = struct {
13 socket: std.net.Stream,
14 platform: []const u8,
15 };
16
17 pub fn init(allocator: std.mem.Allocator, port: u16) MobileHotReloadServer {
18 return .{
19 .allocator = allocator,
20 .port = port,
21 .clients = std.ArrayList(Client).init(allocator),
22 };
23 }
24
25 pub fn deinit(self: *MobileHotReloadServer) void {
26 for (self.clients.items) |client| {
27 client.socket.close();
28 }
29 self.clients.deinit();
30 }
31
32 pub fn start(self: *MobileHotReloadServer) !void {
33 const address = try std.net.Address.parseIp("127.0.0.1", self.port);
34 var server = try address.listen(.{
35 .reuse_address = true,
36 });
37 defer server.deinit();
38
39 self.running = true;
40 std.debug.print("Mobile hot reload server listening on 127.0.0.1:{d}\n", .{self.port});
41
42 while (self.running) {
43 const connection = try server.accept();
44 try self.handleClient(connection);
45 }
46 }
47
48 fn handleClient(self: *MobileHotReloadServer, connection: std.net.Server.Connection) !void {
49 // Simple WebSocket handshake
50 var buffer: [4096]u8 = undefined;
51 const bytes_read = try connection.stream.read(&buffer);
52
53 if (bytes_read == 0) return;
54
55 // Check if it's a WebSocket upgrade request
56 const request = buffer[0..bytes_read];
57 if (std.mem.indexOf(u8, request, "Upgrade: websocket") == null) {
58 connection.stream.close();
59 return;
60 }
61
62 // Send WebSocket handshake response
63 const response =
64 \\HTTP/1.1 101 Switching Protocols
65 \\Upgrade: websocket
66 \\Connection: Upgrade
67 \\Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=
68 \\
69 \\
70 ;
71 try connection.stream.writeAll(response);
72
73 // Add client to list
74 try self.clients.append(.{
75 .socket = connection.stream,
76 .platform = "unknown",
77 });
78
79 std.debug.print("Mobile client connected. Total clients: {d}\n", .{self.clients.items.len});
80 }
81
82 pub fn broadcastReload(self: *MobileHotReloadServer, file_path: []const u8) !void {
83 const message = try std.fmt.allocPrint(
84 self.allocator,
85 "{⁠{\"type\":\"reload\",\"file\":\"{s}\"}}",
86 .{file_path},
87 );
88 defer self.allocator.free(message);
89
90 // WebSocket frame for text message
91 var frame = std.ArrayList(u8).init(self.allocator);
92 defer frame.deinit();
93
94 try frame.append(0x81); // FIN + text frame
95 if (message.len < 126) {
96 try frame.append(@as(u8, @intCast(message.len)));
97 } else if (message.len < 65536) {
98 try frame.append(126);
99 try frame.append(@as(u8, @intCast((message.len >> 8) & 0xFF)));
100 try frame.append(@as(u8, @intCast(message.len & 0xFF)));
101 }
102 try frame.appendSlice(message);
103
104 var i: usize = 0;
105 while (i < self.clients.items.len) {
106 const client = self.clients.items[i];
107 client.socket.writeAll(frame.items) catch {
108 // Remove disconnected client
109 _ = self.clients.swapRemove(i);
110 client.socket.close();
111 continue;
112 };
113 i += 1;
114 }
115
116 std.debug.print("Broadcast reload to {d} clients\n", .{self.clients.items.len});
117 }
118
119 pub fn stop(self: *MobileHotReloadServer) void {
120 self.running = false;
121 }
122};
123
124/// Mobile Hot Reload Manager
125/// Integrates file watching with WebSocket broadcast
126pub const MobileHotReloadManager = struct {
127 allocator: std.mem.Allocator,
128 server: MobileHotReloadServer,
129 watcher: hotreload.FileWatcher,
130 running: bool = false,
131
132 pub fn init(allocator: std.mem.Allocator, config: hotreload.HotReloadConfig, port: u16) !MobileHotReloadManager {
133 const server = MobileHotReloadServer.init(allocator, port);
134 const watcher = try hotreload.FileWatcher.init(allocator, config);
135
136 return .{
137 .allocator = allocator,
138 .server = server,
139 .watcher = watcher,
140 };
141 }
142
143 pub fn deinit(self: *MobileHotReloadManager) void {
144 self.server.deinit();
145 self.watcher.deinit();
146 }
147
148 pub fn start(self: *MobileHotReloadManager) !void {
149 self.running = true;
150
151 // Start server in separate thread
152 const server_thread = try std.Thread.spawn(.{}, serverLoop, .{&self.server});
153 defer server_thread.join();
154
155 // Watch for file changes
156 while (self.running) {
157 if (try self.watcher.check()) {
158 try self.server.broadcastReload("*");
159 }
160 std.time.sleep(100 * std.time.ns_per_ms);
161 }
162 }
163
164 fn serverLoop(server: *MobileHotReloadServer) !void {
165 try server.start();
166 }
167
168 pub fn stop(self: *MobileHotReloadManager) void {
169 self.running = false;
170 self.server.stop();
171 }
172};
173
174/// Generate mobile hot reload client script
175pub fn generateClientScript(allocator: std.mem.Allocator, server_url: []const u8) ![]u8 {
176 const script = try std.fmt.allocPrint(
177 allocator,
178 \\(function() {⁠{
179 \\ const HOTRELOAD_URL = '{s}';
180 \\ let ws = null;
181 \\ let reconnectAttempts = 0;
182 \\ const MAX_RECONNECT_ATTEMPTS = 10;
183 \\
184 \\ function connect() {⁠{
185 \\ if (ws && ws.readyState === WebSocket.OPEN) {⁠{
186 \\ return;
187 \\ }}
188 \\
189 \\ console.log('[HotReload] Connecting to ' + HOTRELOAD_URL);
190 \\ ws = new WebSocket(HOTRELOAD_URL);
191 \\
192 \\ ws.onopen = function() {⁠{
193 \\ console.log('[HotReload] Connected');
194 \\ reconnectAttempts = 0;
195 \\ }};
196 \\
197 \\ ws.onmessage = function(event) {⁠{
198 \\ try {⁠{
199 \\ const data = JSON.parse(event.data);
200 \\ console.log('[HotReload] Received:', data);
201 \\
202 \\ if (data.type === 'reload') {⁠{
203 \\ console.log('[HotReload] Reloading...');
204 \\ window.location.reload();
205 \\ }}
206 \\ }} catch (e) {⁠{
207 \\ console.error('[HotReload] Error parsing message:', e);
208 \\ }}
209 \\ }};
210 \\
211 \\ ws.onerror = function(error) {⁠{
212 \\ console.error('[HotReload] Error:', error);
213 \\ }};
214 \\
215 \\ ws.onclose = function() {⁠{
216 \\ console.log('[HotReload] Disconnected');
217 \\ ws = null;
218 \\
219 \\ if (reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {⁠{
220 \\ const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 10000);
221 \\ console.log('[HotReload] Reconnecting in ' + delay + 'ms...');
222 \\ setTimeout(connect, delay);
223 \\ reconnectAttempts++;
224 \\ }} else {⁠{
225 \\ console.error('[HotReload] Max reconnect attempts reached');
226 \\ }}
227 \\ }};
228 \\ }}
229 \\
230 \\ // Start connection
231 \\ connect();
232 \\
233 \\ // Expose API
234 \\ window.craftHotReload = {⁠{
235 \\ reconnect: connect,
236 \\ disconnect: function() {⁠{
237 \\ if (ws) {⁠{
238 \\ ws.close();
239 \\ ws = null;
240 \\ }}
241 \\ }}
242 \\ }};
243 \\
244 \\ console.log('[HotReload] Client initialized');
245 \\}})();
246 \\
247 ,
248 .{server_url},
249 );
250
251 return script;
252}
253
254// Tests
255test "Mobile hot reload server init" {
256 const allocator = std.testing.allocator;
257 var server = MobileHotReloadServer.init(allocator, 8765);
258 defer server.deinit();
259
260 try std.testing.expect(server.port == 8765);
261 try std.testing.expect(server.clients.items.len == 0);
262}
263
264test "Generate client script" {
265 const allocator = std.testing.allocator;
266 const script = try generateClientScript(allocator, "ws://localhost:8765");
267 defer allocator.free(script);
268
269 try std.testing.expect(std.mem.indexOf(u8, script, "WebSocket") != null);
270 try std.testing.expect(std.mem.indexOf(u8, script, "localhost:8765") != null);
271}
packages/zig/src/ios.zigmodified+61-471
Changes to packages/zig/src/ios.zig
@@ -16,7 +16,6 @@ pub const CraftAppDelegate = struct {
1616 window: ?objc.id = null,
1717 root_view_controller: ?objc.id = null,
1818 webview: ?*mobile.iOS.WKWebView = null,
19 js_bridge: ?*JSBridge = null,
2019 allocator: std.mem.Allocator,
2120 config: AppConfig,
2221
@@ -107,18 +106,12 @@ pub const CraftAppDelegate = struct {
107106 self.on_memory_warning = callback;
108107 }
109108
110 /// Register a custom JavaScript handler
111 /// The handler will be called when JS calls: craft.invoke('name', params)
112 pub fn registerJSHandler(self: *Self, name: []const u8, handler: JSBridge.Handler) !void {
113 if (self.js_bridge) |bridge| {
114 try bridge.registerHandler(name, handler);
115 }
116 }
117
118 /// Get the JavaScript bridge for advanced usage
119 pub fn getBridge(self: *Self) ?*JSBridge {
120 return self.js_bridge;
121 }
109 // `registerJSHandler` and `getBridge` used to sit here, handing callers a
110 // `*JSBridge` whose `handleMessage` had no caller anywhere in the tree —
111 // `setupJSBridge` below never registered a `WKScriptMessageHandler`, so
112 // nothing could ever deliver a message to it. They are gone along with the
113 // bridge itself; the replacement routes through `ios_dispatch.zig` and the
114 // same `bridge_*.zig` modules the desktop uses.
122115
123116 /// Start the iOS application
124117 /// This should be called from main() and will not return until the app terminates
@@ -131,48 +124,34 @@ pub const CraftAppDelegate = struct {
131124 mobile.initGlobalObjectManager(self.allocator);
132125 defer mobile.deinitGlobalObjectManager();
133126
134 // Initialize JavaScript bridge
135 const bridge = try self.allocator.create(JSBridge);
136 bridge.* = JSBridge.init(self.allocator);
137 bridge.app_delegate = self;
138 self.js_bridge = bridge;
139 defer {
140 bridge.deinit();
141 self.allocator.destroy(bridge);
142 }
143
144 // Create UIWindow
127 // These four are the pieces that survive into the real startup path,
128 // and they are called here so the compiler keeps checking them. They
129 // must not run in this order on a device: every one of them touches
130 // UIKit, and UIKit is not initialised until `UIApplicationMain` has
131 // been called. `[UIScreen mainScreen]` returns nil before that, so
132 // `createWindow` builds its `initWithFrame:` rect out of garbage, and
133 // `showWindow`'s `makeKeyAndVisible` traps with no `UIApplication`
134 // instance to key against.
145135 try self.createWindow();
146
147 // Create and configure root view controller with WKWebView
148136 try self.createRootViewController();
149
150 // Set up JavaScript bridge with WKWebView
151137 try self.setupJSBridge();
152
153 // Inject craft bridge JavaScript
154 try self.injectBridgeScript();
155
156 // Load initial content
157138 try self.loadInitialContent();
158
159 // Make window visible
160139 try self.showWindow();
161140
162 // Dispatch ready event to JavaScript
163 if (self.js_bridge) |bridge_ptr| {
164 bridge_ptr.sendEvent("ready", "{}") catch |err| {
165 std.log.warn("failed to send ready event to JS bridge: {}", .{err});
166 };
167 }
168
169 // Call launch callback
170141 if (self.on_launch) |callback| {
171142 callback();
172143 }
173144
174 // Start the run loop (blocks until app terminates)
175 try self.runMainLoop();
145 // There is no run loop to enter. The previous version spun
146 // `[[NSRunLoop currentRunLoop] run]`, which is not how an iOS app
147 // starts and gave no touch delivery and no lifecycle events.
148 //
149 // Saying so is the honest state of this file: iOS compiles again, and
150 // it does not yet launch. The next phase registers a delegate class,
151 // calls `UIApplicationMain`, and moves the five calls above into
152 // `application:didFinishLaunchingWithOptions:`, which is the only
153 // point at which they are legal.
154 return error.RunLoopNotImplemented;
176155 }
177156
178157 /// Set up WKScriptMessageHandler for JavaScript bridge
@@ -188,80 +167,19 @@ pub const CraftAppDelegate = struct {
188167 const sel_userContentController = objc.sel_registerName("userContentController") orelse return error.SelectorNotFound;
189168 const content_controller = objc.msgSendId(configuration, sel_userContentController);
190169
191 // Note: In a full implementation, we would create a custom Objective-C class
192 // that implements WKScriptMessageHandler protocol and register it here.
193 // For now, the JS bridge will work through evaluateJavaScript polling.
194
170 // Nothing is registered on the controller yet, so a page's
171 // `window.webkit.messageHandlers.craft` is undefined and every call
172 // from JS is silently dropped. The comment that used to sit here said
173 // the bridge would "work through evaluateJavaScript polling" instead —
174 // no such polling was ever written, which is why iOS has looked wired
175 // up without being reachable.
176 //
177 // `macos.zig:5071` already does this correctly and uses nothing from
178 // AppKit — objc runtime, Foundation, and WebKit only — so the next
179 // phase ports it here rather than inventing a second one.
195180 _ = content_controller;
196181 }
197182
198 /// Inject the craft bridge JavaScript into the webview
199 fn injectBridgeScript(self: *Self) !void {
200 if (self.webview == null) return error.WebViewNotInitialized;
201
202 // This JavaScript sets up the craft object that web apps can use
203 const bridge_script =
204 \\(function() {
205 \\ if (window.craft) return; // Already initialized
206 \\
207 \\ window.craft = {
208 \\ _callbacks: {},
209 \\ _callbackId: 0,
210 \\
211 \\ isNative: function() {
212 \\ return !!(window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.craft);
213 \\ },
214 \\
215 \\ invoke: function(method, params) {
216 \\ var self = this;
217 \\ params = params || {};
218 \\
219 \\ return new Promise(function(resolve, reject) {
220 \\ var callbackId = String(++self._callbackId);
221 \\
222 \\ // Store callback
223 \\ window['__craftCallback_' + callbackId] = function(result) {
224 \\ delete window['__craftCallback_' + callbackId];
225 \\ if (result && result.error) {
226 \\ reject(new Error(result.error));
227 \\ } else {
228 \\ resolve(result);
229 \\ }
230 \\ };
231 \\
232 \\ // Send to native
233 \\ if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.craft) {
234 \\ window.webkit.messageHandlers.craft.postMessage({
235 \\ method: method,
236 \\ params: params,
237 \\ callbackId: callbackId
238 \\ });
239 \\ } else {
240 \\ // Browser fallback - simulate native response
241 \\ setTimeout(function() {
242 \\ window['__craftCallback_' + callbackId]({ success: true, browser: true });
243 \\ }, 10);
244 \\ }
245 \\
246 \\ // Timeout after 10 seconds
247 \\ setTimeout(function() {
248 \\ if (window['__craftCallback_' + callbackId]) {
249 \\ delete window['__craftCallback_' + callbackId];
250 \\ reject(new Error('Timeout'));
251 \\ }
252 \\ }, 10000);
253 \\ });
254 \\ }
255 \\ };
256 \\
257 \\ // Dispatch ready event
258 \\ window.dispatchEvent(new CustomEvent('craft:ready'));
259 \\})();
260 ;
261
262 try self.evaluateJavaScript(bridge_script, null);
263 }
264
265183 /// Create the main UIWindow
266184 fn createWindow(self: *Self) !void {
267185 // Get UIScreen mainScreen bounds
@@ -435,7 +353,12 @@ pub const CraftAppDelegate = struct {
435353
436354 // Load HTML: [webview loadHTMLString__stx_html=""<section class=\"diff-file panel\" id=\"file-packages/zig/src/ios.zig\"><header class=\"diff-head\"><button type=\"button\" class=\"diff-toggle\" aria-expanded=\"true\" aria-controls=\"body-packages/zig/src/ios.zig\"><span class=\"i-hugeicons-arrow-down-01\" aria-hidden=\"true\"></span></button><span class=\"diff-path mono\">packages/zig/src/ios.zig</span><span class=\"diff-status pill pill-modified\">modified</span><span class=\"diff-counts mono\" aria-label=\"61 added, 471 removed\"><span class=\"count-add\">+61</span><span class=\"count-del\">-471</span></span></header><div id=\"body-packages/zig/src/ios.zig\" class=\"diff-body\"><table class=\"diff-table\" data-columns=\"3\"><caption class=\"visually-hidden\">Changes to packages/zig/src/ios.zig</caption><tbody><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"1\" data-expand-to=\"15\" data-expand-offset=\"0\" title=\"Show the 15 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">15 lines</span><span class=\"visually-hidden\">Show the 15 lines above this hunk</span></button>@@ -16,7 +16,6 @@ <span class=\"muted\">pub const CraftAppDelegate = struct {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"16\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:16\" aria-label=\"Line 16\">16</a></td><td class=\"gutter num\" data-line=\"16\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:16\" aria-label=\"Line 16\">16</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    window: ?objc.id = null,</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"17\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:17\" aria-label=\"Line 17\">17</a></td><td class=\"gutter num\" data-line=\"17\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:17\" aria-label=\"Line 17\">17</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    root_view_controller: ?objc.id = null,</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"18\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:18\" aria-label=\"Line 18\">18</a></td><td class=\"gutter num\" data-line=\"18\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:18\" aria-label=\"Line 18\">18</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    webview: ?*mobile.iOS.WKWebView = null,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"19\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:19\" aria-label=\"Line 19\">19</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    js_bridge: ?*JSBridge = null,</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"20\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:20\" aria-label=\"Line 20\">20</a></td><td class=\"gutter num\" data-line=\"19\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:19\" aria-label=\"Line 19\">19</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    allocator: std.mem.Allocator,</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"21\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:21\" aria-label=\"Line 21\">21</a></td><td class=\"gutter num\" data-line=\"20\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:20\" aria-label=\"Line 20\">20</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    config: AppConfig,</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"22\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:22\" aria-label=\"Line 22\">22</a></td><td class=\"gutter num\" data-line=\"21\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:21\" aria-label=\"Line 21\">21</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"22\" data-expand-to=\"105\" data-expand-offset=\"-1\" title=\"Show the 84 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">84 lines</span><span class=\"visually-hidden\">Show the 84 lines above this hunk</span></button>@@ -107,18 +106,12 @@ <span class=\"muted\">pub const CraftAppDelegate = struct {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"107\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:107\" aria-label=\"Line 107\">107</a></td><td class=\"gutter num\" data-line=\"106\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:106\" aria-label=\"Line 106\">106</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        self.on_memory_warning = callback;</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"108\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:108\" aria-label=\"Line 108\">108</a></td><td class=\"gutter num\" data-line=\"107\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:107\" aria-label=\"Line 107\">107</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"109\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:109\" aria-label=\"Line 109\">109</a></td><td class=\"gutter num\" data-line=\"108\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:108\" aria-label=\"Line 108\">108</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"110\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:110\" aria-label=\"Line 110\">110</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Register a custom JavaScript handler</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"111\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:111\" aria-label=\"Line 111\">111</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// The handler will be called when JS calls: craft.invoke('name', params)</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"112\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:112\" aria-label=\"Line 112\">112</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn registerJSHandler(self: *Self, name: []const u8, handler: JSBridge.Handler) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"113\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:113\" aria-label=\"Line 113\">113</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (self.js_bridge) |bridge| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"114\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:114\" aria-label=\"Line 114\">114</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            try bridge.registerHandler(name, handler);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"115\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:115\" aria-label=\"Line 115\">115</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"116\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:116\" aria-label=\"Line 116\">116</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"117\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:117\" aria-label=\"Line 117\">117</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"118\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:118\" aria-label=\"Line 118\">118</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Get the JavaScript bridge for advanced usage</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"119\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:119\" aria-label=\"Line 119\">119</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn getBridge(self: *Self) ?*JSBridge {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"120\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:120\" aria-label=\"Line 120\">120</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        return self.js_bridge;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"121\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:121\" aria-label=\"Line 121\">121</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"109\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:109\" aria-label=\"Line 109\">109</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // `registerJSHandler` and `getBridge` used to sit here, handing callers a</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"110\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:110\" aria-label=\"Line 110\">110</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // `*JSBridge` whose `handleMessage` had no caller anywhere in the tree —</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"111\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:111\" aria-label=\"Line 111\">111</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // `setupJSBridge` below never registered a `WKScriptMessageHandler`, so</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"112\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:112\" aria-label=\"Line 112\">112</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // nothing could ever deliver a message to it. They are gone along with the</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"113\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:113\" aria-label=\"Line 113\">113</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // bridge itself; the replacement routes through `ios_dispatch.zig` and the</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"114\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:114\" aria-label=\"Line 114\">114</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // same `bridge_*.zig` modules the desktop uses.</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"122\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:122\" aria-label=\"Line 122\">122</a></td><td class=\"gutter num\" data-line=\"115\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:115\" aria-label=\"Line 115\">115</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"123\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:123\" aria-label=\"Line 123\">123</a></td><td class=\"gutter num\" data-line=\"116\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:116\" aria-label=\"Line 116\">116</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    /// Start the iOS application</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"124\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:124\" aria-label=\"Line 124\">124</a></td><td class=\"gutter num\" data-line=\"117\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:117\" aria-label=\"Line 117\">117</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    /// This should be called from main() and will not return until the app terminates</span></td></tr><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"118\" data-expand-to=\"123\" data-expand-offset=\"-7\" title=\"Show the 6 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">6 lines</span><span class=\"visually-hidden\">Show the 6 lines above this hunk</span></button>@@ -131,48 +124,34 @@ <span class=\"muted\">pub const CraftAppDelegate = struct {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"131\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:131\" aria-label=\"Line 131\">131</a></td><td class=\"gutter num\" data-line=\"124\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:124\" aria-label=\"Line 124\">124</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        mobile.initGlobalObjectManager(self.allocator);</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"132\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:132\" aria-label=\"Line 132\">132</a></td><td class=\"gutter num\" data-line=\"125\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:125\" aria-label=\"Line 125\">125</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        defer mobile.deinitGlobalObjectManager();</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"133\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:133\" aria-label=\"Line 133\">133</a></td><td class=\"gutter num\" data-line=\"126\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:126\" aria-label=\"Line 126\">126</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"134\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:134\" aria-label=\"Line 134\">134</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Initialize JavaScript bridge</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"135\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:135\" aria-label=\"Line 135\">135</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const bridge = try self.allocator.create(JSBridge);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"136\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:136\" aria-label=\"Line 136\">136</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.* = JSBridge.init(self.allocator);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"137\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:137\" aria-label=\"Line 137\">137</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.app_delegate = self;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"138\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:138\" aria-label=\"Line 138\">138</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        self.js_bridge = bridge;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"139\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:139\" aria-label=\"Line 139\">139</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        defer {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"140\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:140\" aria-label=\"Line 140\">140</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            bridge.deinit();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"141\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:141\" aria-label=\"Line 141\">141</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            self.allocator.destroy(bridge);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"142\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:142\" aria-label=\"Line 142\">142</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"143\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:143\" aria-label=\"Line 143\">143</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"144\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:144\" aria-label=\"Line 144\">144</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Create UIWindow</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"127\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:127\" aria-label=\"Line 127\">127</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // These four are the pieces that survive into the real startup path,</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"128\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:128\" aria-label=\"Line 128\">128</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // and they are called here so the compiler keeps checking them. They</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"129\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:129\" aria-label=\"Line 129\">129</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // must not run in this order on a device: every one of them touches</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"130\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:130\" aria-label=\"Line 130\">130</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // UIKit, and UIKit is not initialised until `UIApplicationMain` has</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"131\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:131\" aria-label=\"Line 131\">131</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // been called. `[UIScreen mainScreen]` returns nil before that, so</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"132\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:132\" aria-label=\"Line 132\">132</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // `createWindow` builds its `initWithFrame:` rect out of garbage, and</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"133\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:133\" aria-label=\"Line 133\">133</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // `showWindow`'s `makeKeyAndVisible` traps with no `UIApplication`</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"134\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:134\" aria-label=\"Line 134\">134</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // instance to key against.</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"145\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:145\" aria-label=\"Line 145\">145</a></td><td class=\"gutter num\" data-line=\"135\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:135\" aria-label=\"Line 135\">135</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        try self.createWindow();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"146\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:146\" aria-label=\"Line 146\">146</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"147\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:147\" aria-label=\"Line 147\">147</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Create and configure root view controller with WKWebView</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"148\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:148\" aria-label=\"Line 148\">148</a></td><td class=\"gutter num\" data-line=\"136\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:136\" aria-label=\"Line 136\">136</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        try self.createRootViewController();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"149\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:149\" aria-label=\"Line 149\">149</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"150\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:150\" aria-label=\"Line 150\">150</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Set up JavaScript bridge with WKWebView</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"151\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:151\" aria-label=\"Line 151\">151</a></td><td class=\"gutter num\" data-line=\"137\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:137\" aria-label=\"Line 137\">137</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        try self.setupJSBridge();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"152\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:152\" aria-label=\"Line 152\">152</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"153\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:153\" aria-label=\"Line 153\">153</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Inject craft bridge JavaScript</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"154\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:154\" aria-label=\"Line 154\">154</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.injectBridgeScript();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"155\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:155\" aria-label=\"Line 155\">155</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"156\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:156\" aria-label=\"Line 156\">156</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Load initial content</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"157\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:157\" aria-label=\"Line 157\">157</a></td><td class=\"gutter num\" data-line=\"138\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:138\" aria-label=\"Line 138\">138</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        try self.loadInitialContent();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"158\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:158\" aria-label=\"Line 158\">158</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"159\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:159\" aria-label=\"Line 159\">159</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Make window visible</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"160\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:160\" aria-label=\"Line 160\">160</a></td><td class=\"gutter num\" data-line=\"139\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:139\" aria-label=\"Line 139\">139</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        try self.showWindow();</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"161\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:161\" aria-label=\"Line 161\">161</a></td><td class=\"gutter num\" data-line=\"140\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:140\" aria-label=\"Line 140\">140</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"162\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:162\" aria-label=\"Line 162\">162</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Dispatch ready event to JavaScript</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"163\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:163\" aria-label=\"Line 163\">163</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (self.js_bridge) |bridge_ptr| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"164\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:164\" aria-label=\"Line 164\">164</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            bridge_ptr.sendEvent(&quot;ready&quot;, &quot;{}&quot;) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"165\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:165\" aria-label=\"Line 165\">165</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                std.log.warn(&quot;failed to send ready event to JS bridge: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"166\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:166\" aria-label=\"Line 166\">166</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"167\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:167\" aria-label=\"Line 167\">167</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"168\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:168\" aria-label=\"Line 168\">168</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"169\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:169\" aria-label=\"Line 169\">169</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Call launch callback</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"170\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:170\" aria-label=\"Line 170\">170</a></td><td class=\"gutter num\" data-line=\"141\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:141\" aria-label=\"Line 141\">141</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        if (self.on_launch) |callback| {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"171\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:171\" aria-label=\"Line 171\">171</a></td><td class=\"gutter num\" data-line=\"142\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:142\" aria-label=\"Line 142\">142</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">            callback();</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"172\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:172\" aria-label=\"Line 172\">172</a></td><td class=\"gutter num\" data-line=\"143\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:143\" aria-label=\"Line 143\">143</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        }</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"173\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:173\" aria-label=\"Line 173\">173</a></td><td class=\"gutter num\" data-line=\"144\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:144\" aria-label=\"Line 144\">144</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"174\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:174\" aria-label=\"Line 174\">174</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // </span><span class=\"t-text w\">Start</span><span class=\"t-text\"> </span><span class=\"t-text w\">the</span><span class=\"t-text\"> run loop </span><span class=\"t-text w\">(blocks</span><span class=\"t-text\"> </span><span class=\"t-text w\">until</span><span class=\"t-text\"> </span><span class=\"t-text w\">app</span><span class=\"t-text\"> </span><span class=\"t-text w\">terminates)</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"175\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:175\" aria-label=\"Line 175\">175</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.runMainLoop();</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"145\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:145\" aria-label=\"Line 145\">145</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // </span><span class=\"t-text w\">There</span><span class=\"t-text\"> </span><span class=\"t-text w\">is</span><span class=\"t-text\"> </span><span class=\"t-text w\">no </span><span class=\"t-text\">run loop </span><span class=\"t-text w\">to</span><span class=\"t-text\"> </span><span class=\"t-text w\">enter.</span><span class=\"t-text\"> </span><span class=\"t-text w\">The</span><span class=\"t-text\"> </span><span class=\"t-text w\">previous version spun</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"146\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:146\" aria-label=\"Line 146\">146</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // `[[NSRunLoop currentRunLoop] run]`, which is not how an iOS app</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"147\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:147\" aria-label=\"Line 147\">147</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // starts and gave no touch delivery and no lifecycle events.</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"148\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:148\" aria-label=\"Line 148\">148</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        //</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"149\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:149\" aria-label=\"Line 149\">149</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // Saying so is the honest state of this file: iOS compiles again, and</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"150\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:150\" aria-label=\"Line 150\">150</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // it does not yet launch. The next phase registers a delegate class,</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"151\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:151\" aria-label=\"Line 151\">151</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // calls `UIApplicationMain`, and moves the five calls above into</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"152\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:152\" aria-label=\"Line 152\">152</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // `application:didFinishLaunchingWithOptions:`, which is the only</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"153\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:153\" aria-label=\"Line 153\">153</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // point at which they are legal.</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"154\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:154\" aria-label=\"Line 154\">154</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        return error.RunLoopNotImplemented;</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"176\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:176\" aria-label=\"Line 176\">176</a></td><td class=\"gutter num\" data-line=\"155\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:155\" aria-label=\"Line 155\">155</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"177\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:177\" aria-label=\"Line 177\">177</a></td><td class=\"gutter num\" data-line=\"156\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:156\" aria-label=\"Line 156\">156</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"178\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:178\" aria-label=\"Line 178\">178</a></td><td class=\"gutter num\" data-line=\"157\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:157\" aria-label=\"Line 157\">157</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    /// Set up WKScriptMessageHandler for JavaScript bridge</span></td></tr><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"158\" data-expand-to=\"166\" data-expand-offset=\"-21\" title=\"Show the 9 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">9 lines</span><span class=\"visually-hidden\">Show the 9 lines above this hunk</span></button>@@ -188,80 +167,19 @@ <span class=\"muted\">pub const CraftAppDelegate = struct {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"188\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:188\" aria-label=\"Line 188\">188</a></td><td class=\"gutter num\" data-line=\"167\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:167\" aria-label=\"Line 167\">167</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        const sel_userContentController = objc.sel_registerName(&quot;userContentController&quot;) orelse return error.SelectorNotFound;</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"189\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:189\" aria-label=\"Line 189\">189</a></td><td class=\"gutter num\" data-line=\"168\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:168\" aria-label=\"Line 168\">168</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        const content_controller = objc.msgSendId(configuration, sel_userContentController);</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"190\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:190\" aria-label=\"Line 190\">190</a></td><td class=\"gutter num\" data-line=\"169\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:169\" aria-label=\"Line 169\">169</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"191\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:191\" aria-label=\"Line 191\">191</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Note: In a full implementation, we would create a custom Objective-C class</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"192\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:192\" aria-label=\"Line 192\">192</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // that implements WKScriptMessageHandler protocol and register it here.</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"193\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:193\" aria-label=\"Line 193\">193</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // For now, the JS bridge will work through evaluateJavaScript polling.</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"194\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:194\" aria-label=\"Line 194\">194</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"170\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:170\" aria-label=\"Line 170\">170</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // Nothing is registered on the controller yet, so a page's</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"171\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:171\" aria-label=\"Line 171\">171</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // `window.webkit.messageHandlers.craft` is undefined and every call</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"172\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:172\" aria-label=\"Line 172\">172</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // from JS is silently dropped. The comment that used to sit here said</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"173\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:173\" aria-label=\"Line 173\">173</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // the bridge would &quot;work through evaluateJavaScript polling&quot; instead —</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"174\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:174\" aria-label=\"Line 174\">174</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // no such polling was ever written, which is why iOS has looked wired</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"175\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:175\" aria-label=\"Line 175\">175</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // up without being reachable.</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"176\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:176\" aria-label=\"Line 176\">176</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        //</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"177\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:177\" aria-label=\"Line 177\">177</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // `macos.zig:5071` already does this correctly and uses nothing from</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"178\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:178\" aria-label=\"Line 178\">178</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // AppKit — objc runtime, Foundation, and WebKit only — so the next</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"179\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:179\" aria-label=\"Line 179\">179</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // phase ports it here rather than inventing a second one.</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"195\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:195\" aria-label=\"Line 195\">195</a></td><td class=\"gutter num\" data-line=\"180\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:180\" aria-label=\"Line 180\">180</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        _ = content_controller;</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"196\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:196\" aria-label=\"Line 196\">196</a></td><td class=\"gutter num\" data-line=\"181\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:181\" aria-label=\"Line 181\">181</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"197\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:197\" aria-label=\"Line 197\">197</a></td><td class=\"gutter num\" data-line=\"182\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:182\" aria-label=\"Line 182\">182</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"198\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:198\" aria-label=\"Line 198\">198</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Inject the craft bridge JavaScript into the webview</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"199\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:199\" aria-label=\"Line 199\">199</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn injectBridgeScript(self: *Self) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"200\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:200\" aria-label=\"Line 200\">200</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (self.webview == null) return error.WebViewNotInitialized;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"201\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:201\" aria-label=\"Line 201\">201</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"202\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:202\" aria-label=\"Line 202\">202</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // This JavaScript sets up the craft object that web apps can use</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"203\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:203\" aria-label=\"Line 203\">203</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const bridge_script =</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"204\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:204\" aria-label=\"Line 204\">204</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\(function() {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"205\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:205\" aria-label=\"Line 205\">205</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\    if (window.craft) return; // Already initialized</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"206\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:206\" aria-label=\"Line 206\">206</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"207\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:207\" aria-label=\"Line 207\">207</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\    window.craft = {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"208\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:208\" aria-label=\"Line 208\">208</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\        _callbacks: {},</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"209\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:209\" aria-label=\"Line 209\">209</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\        _callbackId: 0,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"210\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:210\" aria-label=\"Line 210\">210</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"211\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:211\" aria-label=\"Line 211\">211</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\        isNative: function() {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"212\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:212\" aria-label=\"Line 212\">212</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\            return !!(window.webkit &amp;&amp; window.webkit.messageHandlers &amp;&amp; window.webkit.messageHandlers.craft);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"213\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:213\" aria-label=\"Line 213\">213</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\        },</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"214\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:214\" aria-label=\"Line 214\">214</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"215\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:215\" aria-label=\"Line 215\">215</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\        invoke: function(method, params) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"216\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:216\" aria-label=\"Line 216\">216</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\            var self = this;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"217\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:217\" aria-label=\"Line 217\">217</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\            params = params || {};</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"218\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:218\" aria-label=\"Line 218\">218</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"219\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:219\" aria-label=\"Line 219\">219</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\            return new Promise(function(resolve, reject) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"220\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:220\" aria-label=\"Line 220\">220</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                var callbackId = String(++self._callbackId);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"221\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:221\" aria-label=\"Line 221\">221</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"222\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:222\" aria-label=\"Line 222\">222</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                // Store callback</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"223\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:223\" aria-label=\"Line 223\">223</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                window['__craftCallback_' + callbackId] = function(result) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"224\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:224\" aria-label=\"Line 224\">224</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    delete window['__craftCallback_' + callbackId];</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"225\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:225\" aria-label=\"Line 225\">225</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    if (result &amp;&amp; result.error) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"226\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:226\" aria-label=\"Line 226\">226</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                        reject(new Error(result.error));</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"227\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:227\" aria-label=\"Line 227\">227</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    } else {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"228\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:228\" aria-label=\"Line 228\">228</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                        resolve(result);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"229\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:229\" aria-label=\"Line 229\">229</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"230\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:230\" aria-label=\"Line 230\">230</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"231\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:231\" aria-label=\"Line 231\">231</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"232\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:232\" aria-label=\"Line 232\">232</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                // Send to native</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"233\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:233\" aria-label=\"Line 233\">233</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                if (window.webkit &amp;&amp; window.webkit.messageHandlers &amp;&amp; window.webkit.messageHandlers.craft) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"234\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:234\" aria-label=\"Line 234\">234</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    window.webkit.messageHandlers.craft.postMessage({</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"235\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:235\" aria-label=\"Line 235\">235</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                        method: method,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"236\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:236\" aria-label=\"Line 236\">236</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                        params: params,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"237\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:237\" aria-label=\"Line 237\">237</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                        callbackId: callbackId</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"238\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:238\" aria-label=\"Line 238\">238</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    });</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"239\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:239\" aria-label=\"Line 239\">239</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                } else {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"240\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:240\" aria-label=\"Line 240\">240</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    // Browser fallback - simulate native response</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"241\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:241\" aria-label=\"Line 241\">241</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    setTimeout(function() {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"242\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:242\" aria-label=\"Line 242\">242</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                        window['__craftCallback_' + callbackId]({ success: true, browser: true });</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"243\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:243\" aria-label=\"Line 243\">243</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    }, 10);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"244\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:244\" aria-label=\"Line 244\">244</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"245\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:245\" aria-label=\"Line 245\">245</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"246\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:246\" aria-label=\"Line 246\">246</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                // Timeout after 10 seconds</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"247\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:247\" aria-label=\"Line 247\">247</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                setTimeout(function() {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"248\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:248\" aria-label=\"Line 248\">248</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    if (window['__craftCallback_' + callbackId]) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"249\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:249\" aria-label=\"Line 249\">249</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                        delete window['__craftCallback_' + callbackId];</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"250\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:250\" aria-label=\"Line 250\">250</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                        reject(new Error('Timeout'));</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"251\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:251\" aria-label=\"Line 251\">251</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"252\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:252\" aria-label=\"Line 252\">252</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\                }, 10000);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"253\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:253\" aria-label=\"Line 253\">253</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\            });</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"254\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:254\" aria-label=\"Line 254\">254</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"255\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:255\" aria-label=\"Line 255\">255</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\    };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"256\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:256\" aria-label=\"Line 256\">256</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"257\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:257\" aria-label=\"Line 257\">257</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\    // Dispatch ready event</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"258\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:258\" aria-label=\"Line 258\">258</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\    window.dispatchEvent(new CustomEvent('craft:ready'));</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"259\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:259\" aria-label=\"Line 259\">259</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\})();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"260\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:260\" aria-label=\"Line 260\">260</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        ;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"261\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:261\" aria-label=\"Line 261\">261</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"262\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:262\" aria-label=\"Line 262\">262</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.evaluateJavaScript(bridge_script, null);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"263\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:263\" aria-label=\"Line 263\">263</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"264\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:264\" aria-label=\"Line 264\">264</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"265\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:265\" aria-label=\"Line 265\">265</a></td><td class=\"gutter num\" data-line=\"183\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:183\" aria-label=\"Line 183\">183</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    /// Create the main UIWindow</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"266\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:266\" aria-label=\"Line 266\">266</a></td><td class=\"gutter num\" data-line=\"184\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:184\" aria-label=\"Line 184\">184</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    fn createWindow(self: *Self) !void {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"267\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:267\" aria-label=\"Line 267\">267</a></td><td class=\"gutter num\" data-line=\"185\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:185\" aria-label=\"Line 185\">185</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        // Get UIScreen mainScreen bounds</span></td></tr><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"186\" data-expand-to=\"352\" data-expand-offset=\"-82\" title=\"Show the 167 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">167 lines</span><span class=\"visually-hidden\">Show the 167 lines above this hunk</span></button>@@ -435,7 +353,12 @@ <span class=\"muted\">pub const CraftAppDelegate = struct {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"435\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:435\" aria-label=\"Line 435\">435</a></td><td class=\"gutter num\" data-line=\"353\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:353\" aria-label=\"Line 353\">353</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"436\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:436\" aria-label=\"Line 436\">436</a></td><td class=\"gutter num\" data-line=\"354\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:354\" aria-label=\"Line 354\">354</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        // Load HTML: [webview loadHTMLString:html baseURL:baseURL]</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"437\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:437\" aria-label=\"Line 437\">437</a></td><td class=\"gutter num\" data-line=\"355\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:355\" aria-label=\"Line 355\">355</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        const sel_loadHTMLString = objc.sel_registerName(&quot;loadHTMLString:baseURL:&quot;) orelse return error.SelectorNotFound;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"438\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:438\" aria-label=\"Line 438\">438</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        </span><span class=\"t-text w\">const LoadHTMLFn = *const fn</span><span class=\"t-text\"> </span><span class=\"t-text w\">(</span><span class=\"t-text\">objc.id</span><span class=\"t-text w\">,</span><span class=\"t-text\"> </span><span class=\"t-text w\">objc.SEL,</span><span class=\"t-text\"> </span><span class=\"t-text w\">objc.id</span><span class=\"t-text\">, ?objc.id</span><span class=\"t-text w\">)</span><span class=\"t-text\"> </span><span class=\"t-text w\">callconv(.c)</span><span class=\"t-text\"> </span><span class=\"t-text w\">objc.id;</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"356\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:356\" aria-label=\"Line 356\">356</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        </span><span class=\"t-text w\">//</span><span class=\"t-text\"> </span><span class=\"t-text w\">`</span><span class=\"t-text\">objc.id</span><span class=\"t-text w\">`</span><span class=\"t-text\"> </span><span class=\"t-text w\">is</span><span class=\"t-text\"> </span><span class=\"t-text w\">already `?*anyopaque`</span><span class=\"t-text\">, </span><span class=\"t-text w\">so `</span><span class=\"t-text\">?objc.id</span><span class=\"t-text w\">`</span><span class=\"t-text\"> </span><span class=\"t-text w\">is</span><span class=\"t-text\"> </span><span class=\"t-text w\">a double</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"357\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:357\" aria-label=\"Line 357\">357</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // optional — and a non-pointer optional has no guaranteed in-memory</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"358\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:358\" aria-label=\"Line 358\">358</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // representation, which makes it illegal in a `callconv(.c)`</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"359\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:359\" aria-label=\"Line 359\">359</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // signature. A nil `baseURL:` is spelled by passing a null `objc.id`,</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"360\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:360\" aria-label=\"Line 360\">360</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        // not by wrapping the type in another optional.</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"361\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:361\" aria-label=\"Line 361\">361</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">        const LoadHTMLFn = *const fn (objc.id, objc.SEL, objc.id, objc.id) callconv(.c) objc.id;</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"439\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:439\" aria-label=\"Line 439\">439</a></td><td class=\"gutter num\" data-line=\"362\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:362\" aria-label=\"Line 362\">362</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        const loadHTMLFn: LoadHTMLFn = &#64;ptrCast(&amp;objc_runtime.objc.objc_msgSend);</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"440\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:440\" aria-label=\"Line 440\">440</a></td><td class=\"gutter num\" data-line=\"363\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:363\" aria-label=\"Line 363\">363</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        _ = loadHTMLFn(webview_ptr, sel_loadHTMLString, html_ns, base_url);</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"441\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:441\" aria-label=\"Line 441\">441</a></td><td class=\"gutter num\" data-line=\"364\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:364\" aria-label=\"Line 364\">364</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    }</span></td></tr><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"365\" data-expand-to=\"397\" data-expand-offset=\"-77\" title=\"Show the 33 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">33 lines</span><span class=\"visually-hidden\">Show the 33 lines above this hunk</span></button>@@ -475,18 +398,17 @@ <span class=\"muted\">pub const CraftAppDelegate = struct {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"475\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:475\" aria-label=\"Line 475\">475</a></td><td class=\"gutter num\" data-line=\"398\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:398\" aria-label=\"Line 398\">398</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        objc.msgSend(self.window.?, sel_makeKeyAndVisible);</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"476\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:476\" aria-label=\"Line 476\">476</a></td><td class=\"gutter num\" data-line=\"399\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:399\" aria-label=\"Line 399\">399</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"477\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:477\" aria-label=\"Line 477\">477</a></td><td class=\"gutter num\" data-line=\"400\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:400\" aria-label=\"Line 400\">400</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"478\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:478\" aria-label=\"Line 478\">478</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Run the main event loop</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"479\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:479\" aria-label=\"Line 479\">479</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn runMainLoop(self: *Self) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"480\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:480\" aria-label=\"Line 480\">480</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = self;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"481\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:481\" aria-label=\"Line 481\">481</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"482\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:482\" aria-label=\"Line 482\">482</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Get NSRunLoop</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"483\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:483\" aria-label=\"Line 483\">483</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const NSRunLoopClass = objc.objc_getClass(&quot;NSRunLoop&quot;) orelse return error.ClassNotFound;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"484\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:484\" aria-label=\"Line 484\">484</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const sel_currentRunLoop = objc.sel_registerName(&quot;currentRunLoop&quot;) orelse return error.SelectorNotFound;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"485\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:485\" aria-label=\"Line 485\">485</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const sel_run = objc.sel_registerName(&quot;run&quot;) orelse return error.SelectorNotFound;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"486\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:486\" aria-label=\"Line 486\">486</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"487\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:487\" aria-label=\"Line 487\">487</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const runLoop = objc.msgSendId(NSRunLoopClass, sel_currentRunLoop);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"488\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:488\" aria-label=\"Line 488\">488</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        objc.msgSend(runLoop, sel_run);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"489\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:489\" aria-label=\"Line 489\">489</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"401\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:401\" aria-label=\"Line 401\">401</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // `runMainLoop` used to live here, spinning</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"402\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:402\" aria-label=\"Line 402\">402</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // `[[NSRunLoop currentRunLoop] run]`. That is not how an iOS app starts.</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"403\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:403\" aria-label=\"Line 403\">403</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // UIKit owns the run loop, and it only owns it once `UIApplicationMain`</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"404\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:404\" aria-label=\"Line 404\">404</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // has been called — which is also what makes `UIApplication.sharedApplication`</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"405\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:405\" aria-label=\"Line 405\">405</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // and `[UIScreen mainScreen]` return anything but nil. Spinning a bare</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"406\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:406\" aria-label=\"Line 406\">406</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // NSRunLoop meant no touch delivery, no lifecycle notifications, and a</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"407\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:407\" aria-label=\"Line 407\">407</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // window built against a garbage frame.</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"408\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:408\" aria-label=\"Line 408\">408</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    //</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"409\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:409\" aria-label=\"Line 409\">409</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // The replacement is not a function; it is a restructure. `run()` registers</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"410\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:410\" aria-label=\"Line 410\">410</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // a delegate class and calls `UIApplicationMain`, and everything this file</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"411\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:411\" aria-label=\"Line 411\">411</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // used to do inline moves into `application:didFinishLaunchingWithOptions:`.</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"490\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:490\" aria-label=\"Line 490\">490</a></td><td class=\"gutter num\" data-line=\"412\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:412\" aria-label=\"Line 412\">412</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"491\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:491\" aria-label=\"Line 491\">491</a></td><td class=\"gutter num\" data-line=\"413\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:413\" aria-label=\"Line 413\">413</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    /// Execute JavaScript in the webview</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"492\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:492\" aria-label=\"Line 492\">492</a></td><td class=\"gutter num\" data-line=\"414\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:414\" aria-label=\"Line 414\">414</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    pub fn evaluateJavaScript(self: *Self, script: []const u8, callback: ?*const fn ([]const u8) void) !void {</span></td></tr><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"415\" data-expand-to=\"439\" data-expand-offset=\"-78\" title=\"Show the 25 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">25 lines</span><span class=\"visually-hidden\">Show the 25 lines above this hunk</span></button>@@ -518,23 +440,16 @@ <span class=\"muted\">pub const CraftAppDelegate = struct {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"518\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:518\" aria-label=\"Line 518\">518</a></td><td class=\"gutter num\" data-line=\"440\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:440\" aria-label=\"Line 440\">440</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        mobile.iOS.triggerHaptic(haptic_type);</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"519\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:519\" aria-label=\"Line 519\">519</a></td><td class=\"gutter num\" data-line=\"441\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:441\" aria-label=\"Line 441\">441</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"520\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:520\" aria-label=\"Line 520\">520</a></td><td class=\"gutter num\" data-line=\"442\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:442\" aria-label=\"Line 442\">442</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"521\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:521\" aria-label=\"Line 521\">521</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Show alert</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"522\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:522\" aria-label=\"Line 522\">522</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn showAlert(self: *Self, message: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"523\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:523\" aria-label=\"Line 523\">523</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = self;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"524\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:524\" aria-label=\"Line 524\">524</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        mobile.iOS.showAlert(message, true);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"525\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:525\" aria-label=\"Line 525\">525</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"526\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:526\" aria-label=\"Line 526\">526</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"527\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:527\" aria-label=\"Line 527\">527</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Request permission</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"528\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:528\" aria-label=\"Line 528\">528</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn requestPermission(self: *Self, permission: mobile.iOS.Permission, callback: *const fn (bool) void) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"529\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:529\" aria-label=\"Line 529\">529</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = self;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"530\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:530\" aria-label=\"Line 530\">530</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try mobile.iOS.requestPermission(permission, callback);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"531\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:531\" aria-label=\"Line 531\">531</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"532\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:532\" aria-label=\"Line 532\">532</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"533\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:533\" aria-label=\"Line 533\">533</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Check permission status</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"534\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:534\" aria-label=\"Line 534\">534</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn checkPermission(self: *Self, permission: mobile.iOS.Permission) !mobile.iOS.PermissionStatus {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"535\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:535\" aria-label=\"Line 535\">535</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = self;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"536\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:536\" aria-label=\"Line 536\">536</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        return try mobile.iOS.checkPermissionStatus(permission);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"537\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:537\" aria-label=\"Line 537\">537</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"443\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:443\" aria-label=\"Line 443\">443</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // `showAlert`, `requestPermission`, and `checkPermission` were one-line</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"444\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:444\" aria-label=\"Line 444\">444</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // forwards to `mobile.iOS` functions that have been deleted, for reasons</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"445\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:445\" aria-label=\"Line 445\">445</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // recorded where they used to live: the alert presented against</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"446\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:446\" aria-label=\"Line 446\">446</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // `keyWindow`, nil in any scene-based app; the permission request threw</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"447\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:447\" aria-label=\"Line 447\">447</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // its caller's callback away (`_ = callback;`) and passed null for every</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"448\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:448\" aria-label=\"Line 448\">448</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // completion handler; and the status check returned `.not_determined` for</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"449\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:449\" aria-label=\"Line 449\">449</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // notifications no matter what the system said.</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"450\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:450\" aria-label=\"Line 450\">450</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    //</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"451\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:451\" aria-label=\"Line 451\">451</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // They come back in the permissions phase, against a pending-request table</span></td></tr><tr class=\"line line-added\"><td class=\"gutter num\"></td><td class=\"gutter num\" data-line=\"452\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:452\" aria-label=\"Line 452\">452</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">+</span><span class=\"t-text\">    // keyed by the envelope's request id — not a callback that nothing calls.</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"538\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:538\" aria-label=\"Line 538\">538</a></td><td class=\"gutter num\" data-line=\"453\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:453\" aria-label=\"Line 453\">453</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">};</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"539\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:539\" aria-label=\"Line 539\">539</a></td><td class=\"gutter num\" data-line=\"454\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:454\" aria-label=\"Line 454\">454</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"540\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:540\" aria-label=\"Line 540\">540</a></td><td class=\"gutter num\" data-line=\"455\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:455\" aria-label=\"Line 455\">455</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">/// Safe area insets</span></td></tr><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"456\" data-expand-to=\"467\" data-expand-offset=\"-85\" title=\"Show the 12 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">12 lines</span><span class=\"visually-hidden\">Show the 12 lines above this hunk</span></button>@@ -553,298 +468,6 @@ <span class=\"muted\">const UIEdgeInsets = extern struct {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"553\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:553\" aria-label=\"Line 553\">553</a></td><td class=\"gutter num\" data-line=\"468\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:468\" aria-label=\"Line 468\">468</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    right: f64,</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"554\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:554\" aria-label=\"Line 554\">554</a></td><td class=\"gutter num\" data-line=\"469\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:469\" aria-label=\"Line 469\">469</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">};</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"555\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:555\" aria-label=\"Line 555\">555</a></td><td class=\"gutter num\" data-line=\"470\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:470\" aria-label=\"Line 470\">470</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"556\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:556\" aria-label=\"Line 556\">556</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">// ============================================================================</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"557\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:557\" aria-label=\"Line 557\">557</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">// JavaScript Bridge</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"558\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:558\" aria-label=\"Line 558\">558</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">// ============================================================================</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"559\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:559\" aria-label=\"Line 559\">559</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"560\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:560\" aria-label=\"Line 560\">560</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">/// JavaScript bridge message handler</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"561\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:561\" aria-label=\"Line 561\">561</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">/// Handles messages from JavaScript: window.webkit.messageHandlers.craft.postMessage(data)</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"562\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:562\" aria-label=\"Line 562\">562</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">///</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"563\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:563\" aria-label=\"Line 563\">563</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">/// Expected message format:</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"564\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:564\" aria-label=\"Line 564\">564</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">/// {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"565\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:565\" aria-label=\"Line 565\">565</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">///     &quot;method&quot;: &quot;methodName&quot;,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"566\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:566\" aria-label=\"Line 566\">566</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">///     &quot;params&quot;: { ... },</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"567\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:567\" aria-label=\"Line 567\">567</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">///     &quot;callbackId&quot;: &quot;unique_id&quot;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"568\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:568\" aria-label=\"Line 568\">568</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">/// }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"569\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:569\" aria-label=\"Line 569\">569</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">pub const JSBridge = struct {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"570\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:570\" aria-label=\"Line 570\">570</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    handlers: std.StringHashMap(Handler),</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"571\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:571\" aria-label=\"Line 571\">571</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    allocator: std.mem.Allocator,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"572\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:572\" aria-label=\"Line 572\">572</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    app_delegate: ?*CraftAppDelegate = null,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"573\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:573\" aria-label=\"Line 573\">573</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"574\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:574\" aria-label=\"Line 574\">574</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub const Handler = *const fn (params: []const u8, bridge: *JSBridge, callback_id: []const u8) void;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"575\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:575\" aria-label=\"Line 575\">575</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"576\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:576\" aria-label=\"Line 576\">576</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    const Self = &#64;This();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"577\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:577\" aria-label=\"Line 577\">577</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"578\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:578\" aria-label=\"Line 578\">578</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn init(allocator: std.mem.Allocator) JSBridge {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"579\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:579\" aria-label=\"Line 579\">579</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        var bridge = JSBridge{</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"580\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:580\" aria-label=\"Line 580\">580</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            .handlers = std.StringHashMap(Handler).init(allocator),</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"581\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:581\" aria-label=\"Line 581\">581</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            .allocator = allocator,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"582\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:582\" aria-label=\"Line 582\">582</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"583\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:583\" aria-label=\"Line 583\">583</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"584\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:584\" aria-label=\"Line 584\">584</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Register built-in handlers</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"585\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:585\" aria-label=\"Line 585\">585</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.registerBuiltinHandlers() catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"586\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:586\" aria-label=\"Line 586\">586</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.warn(&quot;failed to register iOS built-in JS handlers: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"587\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:587\" aria-label=\"Line 587\">587</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"588\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:588\" aria-label=\"Line 588\">588</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"589\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:589\" aria-label=\"Line 589\">589</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        return bridge;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"590\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:590\" aria-label=\"Line 590\">590</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"591\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:591\" aria-label=\"Line 591\">591</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"592\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:592\" aria-label=\"Line 592\">592</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn deinit(self: *JSBridge) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"593\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:593\" aria-label=\"Line 593\">593</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        self.handlers.deinit();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"594\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:594\" aria-label=\"Line 594\">594</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"595\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:595\" aria-label=\"Line 595\">595</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"596\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:596\" aria-label=\"Line 596\">596</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Register built-in handlers for common native features</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"597\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:597\" aria-label=\"Line 597\">597</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn registerBuiltinHandlers(self: *Self) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"598\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:598\" aria-label=\"Line 598\">598</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;getPlatform&quot;, handleGetPlatform);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"599\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:599\" aria-label=\"Line 599\">599</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;showAlert&quot;, handleShowAlert);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"600\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:600\" aria-label=\"Line 600\">600</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;haptic&quot;, handleHaptic);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"601\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:601\" aria-label=\"Line 601\">601</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;setClipboard&quot;, handleSetClipboard);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"602\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:602\" aria-label=\"Line 602\">602</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;getClipboard&quot;, handleGetClipboard);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"603\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:603\" aria-label=\"Line 603\">603</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;getNetworkStatus&quot;, handleGetNetworkStatus);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"604\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:604\" aria-label=\"Line 604\">604</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;getSafeArea&quot;, handleGetSafeArea);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"605\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:605\" aria-label=\"Line 605\">605</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;openURL&quot;, handleOpenURL);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"606\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:606\" aria-label=\"Line 606\">606</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(&quot;share&quot;, handleShare);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"607\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:607\" aria-label=\"Line 607\">607</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"608\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:608\" aria-label=\"Line 608\">608</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"609\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:609\" aria-label=\"Line 609\">609</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Register a custom handler for a specific method</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"610\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:610\" aria-label=\"Line 610\">610</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn registerHandler(self: *Self, name: []const u8, handler: Handler) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"611\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:611\" aria-label=\"Line 611\">611</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.handlers.put(name, handler);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"612\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:612\" aria-label=\"Line 612\">612</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"613\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:613\" aria-label=\"Line 613\">613</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"614\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:614\" aria-label=\"Line 614\">614</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Handle incoming message from JavaScript</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"615\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:615\" aria-label=\"Line 615\">615</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Parses JSON message and routes to appropriate handler</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"616\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:616\" aria-label=\"Line 616\">616</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn handleMessage(self: *Self, message: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"617\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:617\" aria-label=\"Line 617\">617</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Parse the message - expected format:</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"618\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:618\" aria-label=\"Line 618\">618</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // {&quot;method&quot;: &quot;name&quot;, &quot;params&quot;: {...}, &quot;callbackId&quot;: &quot;123&quot;}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"619\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:619\" aria-label=\"Line 619\">619</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"620\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:620\" aria-label=\"Line 620\">620</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const method = self.extractJsonString(message, &quot;method&quot;) orelse return;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"621\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:621\" aria-label=\"Line 621\">621</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const callback_id = self.extractJsonString(message, &quot;callbackId&quot;) orelse &quot;&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"622\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:622\" aria-label=\"Line 622\">622</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const params = self.extractJsonObject(message, &quot;params&quot;) orelse &quot;{}&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"623\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:623\" aria-label=\"Line 623\">623</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"624\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:624\" aria-label=\"Line 624\">624</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (self.handlers.get(method)) |handler| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"625\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:625\" aria-label=\"Line 625\">625</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            handler(params, self, callback_id);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"626\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:626\" aria-label=\"Line 626\">626</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        } else {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"627\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:627\" aria-label=\"Line 627\">627</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            // Unknown method - send error response</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"628\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:628\" aria-label=\"Line 628\">628</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            self.sendError(callback_id, &quot;Unknown method&quot;) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"629\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:629\" aria-label=\"Line 629\">629</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                std.log.debug(&quot;failed to send unknown method error to JS: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"630\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:630\" aria-label=\"Line 630\">630</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"631\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:631\" aria-label=\"Line 631\">631</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"632\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:632\" aria-label=\"Line 632\">632</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"633\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:633\" aria-label=\"Line 633\">633</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"634\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:634\" aria-label=\"Line 634\">634</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Extract a string value from JSON</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"635\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:635\" aria-label=\"Line 635\">635</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn extractJsonString(self: *Self, json: []const u8, key: []const u8) ?[]const u8 {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"636\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:636\" aria-label=\"Line 636\">636</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = self;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"637\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:637\" aria-label=\"Line 637\">637</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"638\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:638\" aria-label=\"Line 638\">638</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Build search pattern: &quot;key&quot;:&quot;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"639\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:639\" aria-label=\"Line 639\">639</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        var pattern_buf: [64]u8 = undefined;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"640\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:640\" aria-label=\"Line 640\">640</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const pattern = std.fmt.bufPrint(&amp;pattern_buf, &quot;\\&quot;{s}\\&quot;:\\&quot;&quot;, .{key}) catch return null;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"641\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:641\" aria-label=\"Line 641\">641</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"642\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:642\" aria-label=\"Line 642\">642</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (std.mem.indexOf(u8, json, pattern)) |start| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"643\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:643\" aria-label=\"Line 643\">643</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            const value_start = start + pattern.len;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"644\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:644\" aria-label=\"Line 644\">644</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            if (value_start &lt; json.len) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"645\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:645\" aria-label=\"Line 645\">645</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                // Find closing quote</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"646\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:646\" aria-label=\"Line 646\">646</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                if (std.mem.indexOf(u8, json[value_start..], &quot;\\&quot;&quot;)) |end| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"647\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:647\" aria-label=\"Line 647\">647</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                    return json[value_start..][0..end];</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"648\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:648\" aria-label=\"Line 648\">648</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"649\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:649\" aria-label=\"Line 649\">649</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"650\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:650\" aria-label=\"Line 650\">650</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"651\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:651\" aria-label=\"Line 651\">651</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        return null;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"652\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:652\" aria-label=\"Line 652\">652</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"653\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:653\" aria-label=\"Line 653\">653</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"654\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:654\" aria-label=\"Line 654\">654</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Extract an object value from JSON</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"655\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:655\" aria-label=\"Line 655\">655</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn extractJsonObject(self: *Self, json: []const u8, key: []const u8) ?[]const u8 {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"656\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:656\" aria-label=\"Line 656\">656</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = self;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"657\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:657\" aria-label=\"Line 657\">657</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"658\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:658\" aria-label=\"Line 658\">658</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Build search pattern: &quot;key&quot;:{</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"659\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:659\" aria-label=\"Line 659\">659</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        var pattern_buf: [64]u8 = undefined;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"660\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:660\" aria-label=\"Line 660\">660</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const pattern = std.fmt.bufPrint(&amp;pattern_buf, &quot;\\&quot;{s}\\&quot;:&#123;&#8288;&#123;&quot;, .{key}) catch return null;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"661\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:661\" aria-label=\"Line 661\">661</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"662\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:662\" aria-label=\"Line 662\">662</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (std.mem.indexOf(u8, json, pattern)) |start| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"663\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:663\" aria-label=\"Line 663\">663</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            const value_start = start + pattern.len - 1; // Include opening brace</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"664\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:664\" aria-label=\"Line 664\">664</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            if (value_start &lt; json.len) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"665\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:665\" aria-label=\"Line 665\">665</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                // Find matching closing brace (simple nested brace counting)</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"666\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:666\" aria-label=\"Line 666\">666</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                var depth: usize = 0;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"667\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:667\" aria-label=\"Line 667\">667</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                var i: usize = value_start;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"668\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:668\" aria-label=\"Line 668\">668</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                while (i &lt; json.len) : (i += 1) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"669\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:669\" aria-label=\"Line 669\">669</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                    if (json[i] == '{') {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"670\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:670\" aria-label=\"Line 670\">670</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                        depth += 1;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"671\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:671\" aria-label=\"Line 671\">671</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                    } else if (json[i] == '}') {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"672\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:672\" aria-label=\"Line 672\">672</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                        depth -= 1;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"673\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:673\" aria-label=\"Line 673\">673</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                        if (depth == 0) {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"674\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:674\" aria-label=\"Line 674\">674</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                            return json[value_start .. i + 1];</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"675\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:675\" aria-label=\"Line 675\">675</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"676\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:676\" aria-label=\"Line 676\">676</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"677\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:677\" aria-label=\"Line 677\">677</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"678\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:678\" aria-label=\"Line 678\">678</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"679\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:679\" aria-label=\"Line 679\">679</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"680\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:680\" aria-label=\"Line 680\">680</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        return null;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"681\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:681\" aria-label=\"Line 681\">681</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"682\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:682\" aria-label=\"Line 682\">682</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"683\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:683\" aria-label=\"Line 683\">683</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Send success response to JavaScript callback</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"684\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:684\" aria-label=\"Line 684\">684</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn sendResponse(self: *Self, callback_id: []const u8, result: []const u8) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"685\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:685\" aria-label=\"Line 685\">685</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (self.app_delegate == null) return error.NoAppDelegate;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"686\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:686\" aria-label=\"Line 686\">686</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (callback_id.len == 0) return;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"687\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:687\" aria-label=\"Line 687\">687</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"688\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:688\" aria-label=\"Line 688\">688</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        var buf: [2048]u8 = undefined;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"689\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:689\" aria-label=\"Line 689\">689</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const script = std.fmt.bufPrint(&amp;buf,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"690\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:690\" aria-label=\"Line 690\">690</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\if (window['__craftCallback_{s}']) &#123;&#8288;&#123; window['__craftCallback_{s}']({s}); }}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"691\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:691\" aria-label=\"Line 691\">691</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        , .{ callback_id, callback_id, result }) catch return;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"692\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:692\" aria-label=\"Line 692\">692</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"693\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:693\" aria-label=\"Line 693\">693</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.app_delegate.?.evaluateJavaScript(script, null);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"694\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:694\" aria-label=\"Line 694\">694</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"695\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:695\" aria-label=\"Line 695\">695</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"696\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:696\" aria-label=\"Line 696\">696</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Send error response to JavaScript callback</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"697\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:697\" aria-label=\"Line 697\">697</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn sendError(self: *Self, callback_id: []const u8, error_message: []const u8) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"698\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:698\" aria-label=\"Line 698\">698</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (self.app_delegate == null) return error.NoAppDelegate;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"699\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:699\" aria-label=\"Line 699\">699</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (callback_id.len == 0) return;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"700\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:700\" aria-label=\"Line 700\">700</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"701\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:701\" aria-label=\"Line 701\">701</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        var buf: [2048]u8 = undefined;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"702\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:702\" aria-label=\"Line 702\">702</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const script = std.fmt.bufPrint(&amp;buf,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"703\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:703\" aria-label=\"Line 703\">703</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\if (window['__craftCallback_{s}']) &#123;&#8288;&#123; window['__craftCallback_{s}'](&#123;&#8288;&#123; error: '{s}' }}); }}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"704\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:704\" aria-label=\"Line 704\">704</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        , .{ callback_id, callback_id, error_message }) catch return;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"705\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:705\" aria-label=\"Line 705\">705</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"706\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:706\" aria-label=\"Line 706\">706</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.app_delegate.?.evaluateJavaScript(script, null);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"707\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:707\" aria-label=\"Line 707\">707</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"708\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:708\" aria-label=\"Line 708\">708</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"709\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:709\" aria-label=\"Line 709\">709</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    /// Send event to JavaScript (not a callback response)</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"710\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:710\" aria-label=\"Line 710\">710</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    pub fn sendEvent(self: *Self, event: []const u8, data: []const u8) !void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"711\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:711\" aria-label=\"Line 711\">711</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (self.app_delegate == null) return error.NoAppDelegate;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"712\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:712\" aria-label=\"Line 712\">712</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"713\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:713\" aria-label=\"Line 713\">713</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        var buf: [2048]u8 = undefined;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"714\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:714\" aria-label=\"Line 714\">714</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const script = std.fmt.bufPrint(&amp;buf,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"715\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:715\" aria-label=\"Line 715\">715</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\window.dispatchEvent(new CustomEvent('craft:{s}', &#123;&#8288;&#123; detail: {s} }}));</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"716\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:716\" aria-label=\"Line 716\">716</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        , .{ event, data }) catch return;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"717\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:717\" aria-label=\"Line 717\">717</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"718\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:718\" aria-label=\"Line 718\">718</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        try self.app_delegate.?.evaluateJavaScript(script, null);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"719\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:719\" aria-label=\"Line 719\">719</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"720\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:720\" aria-label=\"Line 720\">720</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"721\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:721\" aria-label=\"Line 721\">721</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    // ========================================================================</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"722\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:722\" aria-label=\"Line 722\">722</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    // Built-in Handlers</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"723\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:723\" aria-label=\"Line 723\">723</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    // ========================================================================</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"724\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:724\" aria-label=\"Line 724\">724</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"725\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:725\" aria-label=\"Line 725\">725</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleGetPlatform(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"726\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:726\" aria-label=\"Line 726\">726</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = params;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"727\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:727\" aria-label=\"Line 727\">727</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"728\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:728\" aria-label=\"Line 728\">728</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const response =</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"729\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:729\" aria-label=\"Line 729\">729</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            \\\\{&quot;os&quot;: &quot;ios&quot;, &quot;version&quot;: &quot;17.0&quot;, &quot;device&quot;: &quot;iPhone&quot;, &quot;native&quot;: true}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"730\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:730\" aria-label=\"Line 730\">730</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        ;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"731\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:731\" aria-label=\"Line 731\">731</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"732\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:732\" aria-label=\"Line 732\">732</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.sendResponse(callback_id, response) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"733\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:733\" aria-label=\"Line 733\">733</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.debug(&quot;failed to send getPlatform response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"734\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:734\" aria-label=\"Line 734\">734</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"735\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:735\" aria-label=\"Line 735\">735</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"736\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:736\" aria-label=\"Line 736\">736</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"737\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:737\" aria-label=\"Line 737\">737</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleShowAlert(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"738\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:738\" aria-label=\"Line 738\">738</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Extract title and message from params</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"739\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:739\" aria-label=\"Line 739\">739</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const title = bridge.extractJsonString(params, &quot;title&quot;) orelse &quot;Alert&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"740\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:740\" aria-label=\"Line 740\">740</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const message = bridge.extractJsonString(params, &quot;message&quot;) orelse &quot;&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"741\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:741\" aria-label=\"Line 741\">741</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = title;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"742\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:742\" aria-label=\"Line 742\">742</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"743\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:743\" aria-label=\"Line 743\">743</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Show native alert</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"744\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:744\" aria-label=\"Line 744\">744</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        mobile.iOS.showAlert(message, true);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"745\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:745\" aria-label=\"Line 745\">745</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"746\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:746\" aria-label=\"Line 746\">746</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.sendResponse(callback_id, &quot;{ \\&quot;success\\&quot;: true }&quot;) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"747\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:747\" aria-label=\"Line 747\">747</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.debug(&quot;failed to send showAlert response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"748\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:748\" aria-label=\"Line 748\">748</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"749\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:749\" aria-label=\"Line 749\">749</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"750\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:750\" aria-label=\"Line 750\">750</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"751\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:751\" aria-label=\"Line 751\">751</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleHaptic(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"752\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:752\" aria-label=\"Line 752\">752</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // Extract haptic type</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"753\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:753\" aria-label=\"Line 753\">753</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const haptic_type_str = bridge.extractJsonString(params, &quot;type&quot;) orelse &quot;light&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"754\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:754\" aria-label=\"Line 754\">754</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"755\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:755\" aria-label=\"Line 755\">755</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const haptic_type: mobile.iOS.HapticType = blk: {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"756\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:756\" aria-label=\"Line 756\">756</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            if (std.mem.eql(u8, haptic_type_str, &quot;success&quot;)) break :blk .success;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"757\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:757\" aria-label=\"Line 757\">757</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            if (std.mem.eql(u8, haptic_type_str, &quot;warning&quot;)) break :blk .warning;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"758\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:758\" aria-label=\"Line 758\">758</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            if (std.mem.eql(u8, haptic_type_str, &quot;error&quot;)) break :blk .error_haptic;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"759\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:759\" aria-label=\"Line 759\">759</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            if (std.mem.eql(u8, haptic_type_str, &quot;light&quot;)) break :blk .light;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"760\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:760\" aria-label=\"Line 760\">760</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            if (std.mem.eql(u8, haptic_type_str, &quot;medium&quot;)) break :blk .medium;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"761\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:761\" aria-label=\"Line 761\">761</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            if (std.mem.eql(u8, haptic_type_str, &quot;heavy&quot;)) break :blk .heavy;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"762\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:762\" aria-label=\"Line 762\">762</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            break :blk .light;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"763\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:763\" aria-label=\"Line 763\">763</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"764\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:764\" aria-label=\"Line 764\">764</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"765\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:765\" aria-label=\"Line 765\">765</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        mobile.iOS.triggerHaptic(haptic_type);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"766\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:766\" aria-label=\"Line 766\">766</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"767\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:767\" aria-label=\"Line 767\">767</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.sendResponse(callback_id, &quot;{ \\&quot;success\\&quot;: true }&quot;) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"768\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:768\" aria-label=\"Line 768\">768</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.debug(&quot;failed to send haptic response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"769\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:769\" aria-label=\"Line 769\">769</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"770\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:770\" aria-label=\"Line 770\">770</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"771\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:771\" aria-label=\"Line 771\">771</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"772\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:772\" aria-label=\"Line 772\">772</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleSetClipboard(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"773\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:773\" aria-label=\"Line 773\">773</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const text = bridge.extractJsonString(params, &quot;text&quot;) orelse &quot;&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"774\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:774\" aria-label=\"Line 774\">774</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"775\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:775\" aria-label=\"Line 775\">775</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        mobile.iOS.setClipboard(text);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"776\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:776\" aria-label=\"Line 776\">776</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"777\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:777\" aria-label=\"Line 777\">777</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.sendResponse(callback_id, &quot;{ \\&quot;success\\&quot;: true }&quot;) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"778\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:778\" aria-label=\"Line 778\">778</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.debug(&quot;failed to send setClipboard response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"779\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:779\" aria-label=\"Line 779\">779</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"780\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:780\" aria-label=\"Line 780\">780</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"781\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:781\" aria-label=\"Line 781\">781</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"782\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:782\" aria-label=\"Line 782\">782</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleGetClipboard(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"783\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:783\" aria-label=\"Line 783\">783</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = params;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"784\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:784\" aria-label=\"Line 784\">784</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"785\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:785\" aria-label=\"Line 785\">785</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const text = mobile.iOS.getClipboard(bridge.allocator) catch &quot;&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"786\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:786\" aria-label=\"Line 786\">786</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"787\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:787\" aria-label=\"Line 787\">787</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        var buf: [1024]u8 = undefined;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"788\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:788\" aria-label=\"Line 788\">788</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const response = std.fmt.bufPrint(&amp;buf, &quot;&#123;&#8288;&#123; \\&quot;text\\&quot;: \\&quot;{s}\\&quot; }}&quot;, .{text}) catch &quot;{}&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"789\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:789\" aria-label=\"Line 789\">789</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"790\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:790\" aria-label=\"Line 790\">790</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.sendResponse(callback_id, response) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"791\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:791\" aria-label=\"Line 791\">791</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.debug(&quot;failed to send getClipboard response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"792\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:792\" aria-label=\"Line 792\">792</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"793\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:793\" aria-label=\"Line 793\">793</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"794\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:794\" aria-label=\"Line 794\">794</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"795\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:795\" aria-label=\"Line 795\">795</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleGetNetworkStatus(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"796\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:796\" aria-label=\"Line 796\">796</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = params;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"797\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:797\" aria-label=\"Line 797\">797</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"798\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:798\" aria-label=\"Line 798\">798</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        // For now, assume connected - real implementation would check reachability</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"799\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:799\" aria-label=\"Line 799\">799</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const response = &quot;{ \\&quot;connected\\&quot;: true, \\&quot;type\\&quot;: \\&quot;wifi\\&quot; }&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"800\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:800\" aria-label=\"Line 800\">800</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"801\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:801\" aria-label=\"Line 801\">801</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.sendResponse(callback_id, response) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"802\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:802\" aria-label=\"Line 802\">802</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.debug(&quot;failed to send getNetworkStatus response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"803\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:803\" aria-label=\"Line 803\">803</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"804\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:804\" aria-label=\"Line 804\">804</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"805\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:805\" aria-label=\"Line 805\">805</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"806\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:806\" aria-label=\"Line 806\">806</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleGetSafeArea(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"807\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:807\" aria-label=\"Line 807\">807</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        _ = params;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"808\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:808\" aria-label=\"Line 808\">808</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"809\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:809\" aria-label=\"Line 809\">809</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        if (bridge.app_delegate) |app| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"810\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:810\" aria-label=\"Line 810\">810</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            const insets = app.getSafeAreaInsets() catch SafeAreaInsets{ .top = 0, .bottom = 0, .left = 0, .right = 0 };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"811\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:811\" aria-label=\"Line 811\">811</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"812\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:812\" aria-label=\"Line 812\">812</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            var buf: [256]u8 = undefined;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"813\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:813\" aria-label=\"Line 813\">813</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            const response = std.fmt.bufPrint(&amp;buf,</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"814\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:814\" aria-label=\"Line 814\">814</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                \\\\&#123;&#8288;&#123; &quot;top&quot;: {d}, &quot;bottom&quot;: {d}, &quot;left&quot;: {d}, &quot;right&quot;: {d} }}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"815\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:815\" aria-label=\"Line 815\">815</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            , .{ insets.top, insets.bottom, insets.left, insets.right }) catch &quot;{}&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"816\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:816\" aria-label=\"Line 816\">816</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"817\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:817\" aria-label=\"Line 817\">817</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            bridge.sendResponse(callback_id, response) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"818\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:818\" aria-label=\"Line 818\">818</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                std.log.debug(&quot;failed to send getSafeArea response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"819\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:819\" aria-label=\"Line 819\">819</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"820\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:820\" aria-label=\"Line 820\">820</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        } else {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"821\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:821\" aria-label=\"Line 821\">821</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            bridge.sendResponse(callback_id, &quot;{ \\&quot;top\\&quot;: 0, \\&quot;bottom\\&quot;: 0, \\&quot;left\\&quot;: 0, \\&quot;right\\&quot;: 0 }&quot;) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"822\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:822\" aria-label=\"Line 822\">822</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">                std.log.debug(&quot;failed to send getSafeArea fallback response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"823\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:823\" aria-label=\"Line 823\">823</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"824\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:824\" aria-label=\"Line 824\">824</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"825\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:825\" aria-label=\"Line 825\">825</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"826\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:826\" aria-label=\"Line 826\">826</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"827\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:827\" aria-label=\"Line 827\">827</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleOpenURL(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"828\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:828\" aria-label=\"Line 828\">828</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const url = bridge.extractJsonString(params, &quot;url&quot;) orelse &quot;&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"829\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:829\" aria-label=\"Line 829\">829</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"830\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:830\" aria-label=\"Line 830\">830</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        mobile.iOS.openURL(url);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"831\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:831\" aria-label=\"Line 831\">831</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"832\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:832\" aria-label=\"Line 832\">832</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.sendResponse(callback_id, &quot;{ \\&quot;success\\&quot;: true }&quot;) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"833\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:833\" aria-label=\"Line 833\">833</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.debug(&quot;failed to send openURL response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"834\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:834\" aria-label=\"Line 834\">834</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"835\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:835\" aria-label=\"Line 835\">835</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"836\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:836\" aria-label=\"Line 836\">836</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"837\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:837\" aria-label=\"Line 837\">837</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    fn handleShare(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"838\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:838\" aria-label=\"Line 838\">838</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        const text = bridge.extractJsonString(params, &quot;text&quot;) orelse &quot;&quot;;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"839\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:839\" aria-label=\"Line 839\">839</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"840\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:840\" aria-label=\"Line 840\">840</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        mobile.iOS.share(text);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"841\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:841\" aria-label=\"Line 841\">841</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"842\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:842\" aria-label=\"Line 842\">842</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        bridge.sendResponse(callback_id, &quot;{ \\&quot;success\\&quot;: true }&quot;) catch |err| {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"843\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:843\" aria-label=\"Line 843\">843</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">            std.log.debug(&quot;failed to send share response: {}&quot;, .{err});</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"844\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:844\" aria-label=\"Line 844\">844</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        };</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"845\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:845\" aria-label=\"Line 845\">845</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"846\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:846\" aria-label=\"Line 846\">846</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">};</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"847\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:847\" aria-label=\"Line 847\">847</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"848\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:848\" aria-label=\"Line 848\">848</a></td><td class=\"gutter num\" data-line=\"471\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:471\" aria-label=\"Line 471\">471</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">// ============================================================================</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"849\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:849\" aria-label=\"Line 849\">849</a></td><td class=\"gutter num\" data-line=\"472\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:472\" aria-label=\"Line 472\">472</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">// Convenience Functions</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"850\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:850\" aria-label=\"Line 850\">850</a></td><td class=\"gutter num\" data-line=\"473\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:473\" aria-label=\"Line 473\">473</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">// ============================================================================</span></td></tr><tr class=\"hunk-head\"><td class=\"gutter\" colspan=\"2\"></td><td class=\"hunk-label mono\" colspan=\"1\"><button type=\"button\" class=\"hunk-expand\" data-expand-from=\"474\" data-expand-to=\"509\" data-expand-offset=\"-377\" title=\"Show the 36 lines above this\"><span aria-hidden=\"true\">⋯</span><span class=\"hunk-skipped\">36 lines</span><span class=\"visually-hidden\">Show the 36 lines above this hunk</span></button>@@ -887,39 +510,6 @@ <span class=\"muted\">test &quot;CraftAppDelegate initialization&quot; {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"887\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:887\" aria-label=\"Line 887\">887</a></td><td class=\"gutter num\" data-line=\"510\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:510\" aria-label=\"Line 510\">510</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    // Can't fully test without iOS runtime</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"888\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:888\" aria-label=\"Line 888\">888</a></td><td class=\"gutter num\" data-line=\"511\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:511\" aria-label=\"Line 511\">511</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">}</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"889\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:889\" aria-label=\"Line 889\">889</a></td><td class=\"gutter num\" data-line=\"512\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:512\" aria-label=\"Line 512\">512</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"890\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:890\" aria-label=\"Line 890\">890</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">test &quot;JSBridge initialization&quot; {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"891\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:891\" aria-label=\"Line 891\">891</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    const allocator = std.testing.allocator;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"892\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:892\" aria-label=\"Line 892\">892</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"893\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:893\" aria-label=\"Line 893\">893</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    var bridge = JSBridge.init(allocator);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"894\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:894\" aria-label=\"Line 894\">894</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    defer bridge.deinit();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"895\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:895\" aria-label=\"Line 895\">895</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"896\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:896\" aria-label=\"Line 896\">896</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    const handler = struct {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"897\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:897\" aria-label=\"Line 897\">897</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        fn handle(_: []const u8, _: *JSBridge, _: []const u8) void {}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"898\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:898\" aria-label=\"Line 898\">898</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    }.handle;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"899\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:899\" aria-label=\"Line 899\">899</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"900\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:900\" aria-label=\"Line 900\">900</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    try bridge.registerHandler(&quot;test&quot;, handler);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"901\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:901\" aria-label=\"Line 901\">901</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"902\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:902\" aria-label=\"Line 902\">902</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"903\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:903\" aria-label=\"Line 903\">903</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">test &quot;JSBridge JSON parsing&quot; {</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"904\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:904\" aria-label=\"Line 904\">904</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    const allocator = std.testing.allocator;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"905\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:905\" aria-label=\"Line 905\">905</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"906\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:906\" aria-label=\"Line 906\">906</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    var bridge = JSBridge.init(allocator);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"907\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:907\" aria-label=\"Line 907\">907</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    defer bridge.deinit();</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"908\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:908\" aria-label=\"Line 908\">908</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"909\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:909\" aria-label=\"Line 909\">909</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    // Test extractJsonString</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"910\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:910\" aria-label=\"Line 910\">910</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    const json =</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"911\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:911\" aria-label=\"Line 911\">911</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">        \\\\{&quot;method&quot;:&quot;getPlatform&quot;,&quot;params&quot;:{},&quot;callbackId&quot;:&quot;123&quot;}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"912\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:912\" aria-label=\"Line 912\">912</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    ;</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"913\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:913\" aria-label=\"Line 913\">913</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"914\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:914\" aria-label=\"Line 914\">914</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    const method = bridge.extractJsonString(json, &quot;method&quot;);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"915\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:915\" aria-label=\"Line 915\">915</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    try std.testing.expect(method != null);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"916\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:916\" aria-label=\"Line 916\">916</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    try std.testing.expectEqualStrings(&quot;getPlatform&quot;, method.?);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"917\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:917\" aria-label=\"Line 917\">917</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"918\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:918\" aria-label=\"Line 918\">918</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    const callback_id = bridge.extractJsonString(json, &quot;callbackId&quot;);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"919\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:919\" aria-label=\"Line 919\">919</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    try std.testing.expect(callback_id != null);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"920\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:920\" aria-label=\"Line 920\">920</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">    try std.testing.expectEqualStrings(&quot;123&quot;, callback_id.?);</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"921\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:921\" aria-label=\"Line 921\">921</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\">}</span></td></tr><tr class=\"line line-removed\"><td class=\"gutter num\" data-line=\"922\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:922\" aria-label=\"Line 922\">922</a></td><td class=\"gutter num\"></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\">-</span><span class=\"t-text\"></span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"923\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:923\" aria-label=\"Line 923\">923</a></td><td class=\"gutter num\" data-line=\"513\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:513\" aria-label=\"Line 513\">513</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">test &quot;SafeAreaInsets&quot; {</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"924\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:924\" aria-label=\"Line 924\">924</a></td><td class=\"gutter num\" data-line=\"514\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:514\" aria-label=\"Line 514\">514</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">    const insets = SafeAreaInsets{</span></td></tr><tr class=\"line line-context\"><td class=\"gutter num\" data-line=\"925\" data-side=\"left\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:L:925\" aria-label=\"Line 925\">925</a></td><td class=\"gutter num\" data-line=\"515\" data-side=\"right\"><a class=\"line-anchor\" href=\"#packages%2Fzig%2Fsrc%2Fios.zig:R:515\" aria-label=\"Line 515\">515</a></td><td class=\"code mono\"><span class=\"marker\" aria-hidden=\"true\"> </span><span class=\"t-text\">        .top = 47.0,</span></td></tr></tbody></table></div></section>"" baseURL:baseURL]
437355 const sel_loadHTMLString = objc.sel_registerName("loadHTMLString:baseURL:") orelse return error.SelectorNotFound;
438 const LoadHTMLFn = *const fn (objc.id, objc.SEL, objc.id, ?objc.id) callconv(.c) objc.id;
356 // `objc.id` is already `?*anyopaque`, so `?objc.id` is a double
357 // optional — and a non-pointer optional has no guaranteed in-memory
358 // representation, which makes it illegal in a `callconv(.c)`
359 // signature. A nil `baseURL:` is spelled by passing a null `objc.id`,
360 // not by wrapping the type in another optional.
361 const LoadHTMLFn = *const fn (objc.id, objc.SEL, objc.id, objc.id) callconv(.c) objc.id;
439362 const loadHTMLFn: LoadHTMLFn = @ptrCast(&objc_runtime.objc.objc_msgSend);
440363 _ = loadHTMLFn(webview_ptr, sel_loadHTMLString, html_ns, base_url);
441364 }
@@ -475,18 +398,17 @@ pub const CraftAppDelegate = struct {
475398 objc.msgSend(self.window.?, sel_makeKeyAndVisible);
476399 }
477400
478 /// Run the main event loop
479 fn runMainLoop(self: *Self) !void {
480 _ = self;
481
482 // Get NSRunLoop
483 const NSRunLoopClass = objc.objc_getClass("NSRunLoop") orelse return error.ClassNotFound;
484 const sel_currentRunLoop = objc.sel_registerName("currentRunLoop") orelse return error.SelectorNotFound;
485 const sel_run = objc.sel_registerName("run") orelse return error.SelectorNotFound;
486
487 const runLoop = objc.msgSendId(NSRunLoopClass, sel_currentRunLoop);
488 objc.msgSend(runLoop, sel_run);
489 }
401 // `runMainLoop` used to live here, spinning
402 // `[[NSRunLoop currentRunLoop] run]`. That is not how an iOS app starts.
403 // UIKit owns the run loop, and it only owns it once `UIApplicationMain`
404 // has been called — which is also what makes `UIApplication.sharedApplication`
405 // and `[UIScreen mainScreen]` return anything but nil. Spinning a bare
406 // NSRunLoop meant no touch delivery, no lifecycle notifications, and a
407 // window built against a garbage frame.
408 //
409 // The replacement is not a function; it is a restructure. `run()` registers
410 // a delegate class and calls `UIApplicationMain`, and everything this file
411 // used to do inline moves into `application:didFinishLaunchingWithOptions:`.
490412
491413 /// Execute JavaScript in the webview
492414 pub fn evaluateJavaScript(self: *Self, script: []const u8, callback: ?*const fn ([]const u8) void) !void {
@@ -518,23 +440,16 @@ pub const CraftAppDelegate = struct {
518440 mobile.iOS.triggerHaptic(haptic_type);
519441 }
520442
521 /// Show alert
522 pub fn showAlert(self: *Self, message: []const u8) void {
523 _ = self;
524 mobile.iOS.showAlert(message, true);
525 }
526
527 /// Request permission
528 pub fn requestPermission(self: *Self, permission: mobile.iOS.Permission, callback: *const fn (bool) void) !void {
529 _ = self;
530 try mobile.iOS.requestPermission(permission, callback);
531 }
532
533 /// Check permission status
534 pub fn checkPermission(self: *Self, permission: mobile.iOS.Permission) !mobile.iOS.PermissionStatus {
535 _ = self;
536 return try mobile.iOS.checkPermissionStatus(permission);
537 }
443 // `showAlert`, `requestPermission`, and `checkPermission` were one-line
444 // forwards to `mobile.iOS` functions that have been deleted, for reasons
445 // recorded where they used to live: the alert presented against
446 // `keyWindow`, nil in any scene-based app; the permission request threw
447 // its caller's callback away (`_ = callback;`) and passed null for every
448 // completion handler; and the status check returned `.not_determined` for
449 // notifications no matter what the system said.
450 //
451 // They come back in the permissions phase, against a pending-request table
452 // keyed by the envelope's request id — not a callback that nothing calls.
538453};
539454
540455/// Safe area insets
@@ -553,298 +468,6 @@ const UIEdgeInsets = extern struct {
553468 right: f64,
554469};
555470
556// ============================================================================
557// JavaScript Bridge
558// ============================================================================
559
560/// JavaScript bridge message handler
561/// Handles messages from JavaScript: window.webkit.messageHandlers.craft.postMessage(data)
562///
563/// Expected message format:
564/// {
565/// "method": "methodName",
566/// "params": { ... },
567/// "callbackId": "unique_id"
568/// }
569pub const JSBridge = struct {
570 handlers: std.StringHashMap(Handler),
571 allocator: std.mem.Allocator,
572 app_delegate: ?*CraftAppDelegate = null,
573
574 pub const Handler = *const fn (params: []const u8, bridge: *JSBridge, callback_id: []const u8) void;
575
576 const Self = @This();
577
578 pub fn init(allocator: std.mem.Allocator) JSBridge {
579 var bridge = JSBridge{
580 .handlers = std.StringHashMap(Handler).init(allocator),
581 .allocator = allocator,
582 };
583
584 // Register built-in handlers
585 bridge.registerBuiltinHandlers() catch |err| {
586 std.log.warn("failed to register iOS built-in JS handlers: {}", .{err});
587 };
588
589 return bridge;
590 }
591
592 pub fn deinit(self: *JSBridge) void {
593 self.handlers.deinit();
594 }
595
596 /// Register built-in handlers for common native features
597 fn registerBuiltinHandlers(self: *Self) !void {
598 try self.handlers.put("getPlatform", handleGetPlatform);
599 try self.handlers.put("showAlert", handleShowAlert);
600 try self.handlers.put("haptic", handleHaptic);
601 try self.handlers.put("setClipboard", handleSetClipboard);
602 try self.handlers.put("getClipboard", handleGetClipboard);
603 try self.handlers.put("getNetworkStatus", handleGetNetworkStatus);
604 try self.handlers.put("getSafeArea", handleGetSafeArea);
605 try self.handlers.put("openURL", handleOpenURL);
606 try self.handlers.put("share", handleShare);
607 }
608
609 /// Register a custom handler for a specific method
610 pub fn registerHandler(self: *Self, name: []const u8, handler: Handler) !void {
611 try self.handlers.put(name, handler);
612 }
613
614 /// Handle incoming message from JavaScript
615 /// Parses JSON message and routes to appropriate handler
616 pub fn handleMessage(self: *Self, message: []const u8) void {
617 // Parse the message - expected format:
618 // {"method": "name", "params": {...}, "callbackId": "123"}
619
620 const method = self.extractJsonString(message, "method") orelse return;
621 const callback_id = self.extractJsonString(message, "callbackId") orelse "";
622 const params = self.extractJsonObject(message, "params") orelse "{}";
623
624 if (self.handlers.get(method)) |handler| {
625 handler(params, self, callback_id);
626 } else {
627 // Unknown method - send error response
628 self.sendError(callback_id, "Unknown method") catch |err| {
629 std.log.debug("failed to send unknown method error to JS: {}", .{err});
630 };
631 }
632 }
633
634 /// Extract a string value from JSON
635 fn extractJsonString(self: *Self, json: []const u8, key: []const u8) ?[]const u8 {
636 _ = self;
637
638 // Build search pattern: "key":"
639 var pattern_buf: [64]u8 = undefined;
640 const pattern = std.fmt.bufPrint(&pattern_buf, "\"{s}\":\"", .{key}) catch return null;
641
642 if (std.mem.indexOf(u8, json, pattern)) |start| {
643 const value_start = start + pattern.len;
644 if (value_start < json.len) {
645 // Find closing quote
646 if (std.mem.indexOf(u8, json[value_start..], "\"")) |end| {
647 return json[value_start..][0..end];
648 }
649 }
650 }
651 return null;
652 }
653
654 /// Extract an object value from JSON
655 fn extractJsonObject(self: *Self, json: []const u8, key: []const u8) ?[]const u8 {
656 _ = self;
657
658 // Build search pattern: "key":{
659 var pattern_buf: [64]u8 = undefined;
660 const pattern = std.fmt.bufPrint(&pattern_buf, "\"{s}\":{⁠{", .{key}) catch return null;
661
662 if (std.mem.indexOf(u8, json, pattern)) |start| {
663 const value_start = start + pattern.len - 1; // Include opening brace
664 if (value_start < json.len) {
665 // Find matching closing brace (simple nested brace counting)
666 var depth: usize = 0;
667 var i: usize = value_start;
668 while (i < json.len) : (i += 1) {
669 if (json[i] == '{') {
670 depth += 1;
671 } else if (json[i] == '}') {
672 depth -= 1;
673 if (depth == 0) {
674 return json[value_start .. i + 1];
675 }
676 }
677 }
678 }
679 }
680 return null;
681 }
682
683 /// Send success response to JavaScript callback
684 pub fn sendResponse(self: *Self, callback_id: []const u8, result: []const u8) !void {
685 if (self.app_delegate == null) return error.NoAppDelegate;
686 if (callback_id.len == 0) return;
687
688 var buf: [2048]u8 = undefined;
689 const script = std.fmt.bufPrint(&buf,
690 \\if (window['__craftCallback_{s}']) {⁠{ window['__craftCallback_{s}']({s}); }}
691 , .{ callback_id, callback_id, result }) catch return;
692
693 try self.app_delegate.?.evaluateJavaScript(script, null);
694 }
695
696 /// Send error response to JavaScript callback
697 pub fn sendError(self: *Self, callback_id: []const u8, error_message: []const u8) !void {
698 if (self.app_delegate == null) return error.NoAppDelegate;
699 if (callback_id.len == 0) return;
700
701 var buf: [2048]u8 = undefined;
702 const script = std.fmt.bufPrint(&buf,
703 \\if (window['__craftCallback_{s}']) {⁠{ window['__craftCallback_{s}']({⁠{ error: '{s}' }}); }}
704 , .{ callback_id, callback_id, error_message }) catch return;
705
706 try self.app_delegate.?.evaluateJavaScript(script, null);
707 }
708
709 /// Send event to JavaScript (not a callback response)
710 pub fn sendEvent(self: *Self, event: []const u8, data: []const u8) !void {
711 if (self.app_delegate == null) return error.NoAppDelegate;
712
713 var buf: [2048]u8 = undefined;
714 const script = std.fmt.bufPrint(&buf,
715 \\window.dispatchEvent(new CustomEvent('craft:{s}', {⁠{ detail: {s} }}));
716 , .{ event, data }) catch return;
717
718 try self.app_delegate.?.evaluateJavaScript(script, null);
719 }
720
721 // ========================================================================
722 // Built-in Handlers
723 // ========================================================================
724
725 fn handleGetPlatform(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
726 _ = params;
727
728 const response =
729 \\{"os": "ios", "version": "17.0", "device": "iPhone", "native": true}
730 ;
731
732 bridge.sendResponse(callback_id, response) catch |err| {
733 std.log.debug("failed to send getPlatform response: {}", .{err});
734 };
735 }
736
737 fn handleShowAlert(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
738 // Extract title and message from params
739 const title = bridge.extractJsonString(params, "title") orelse "Alert";
740 const message = bridge.extractJsonString(params, "message") orelse "";
741 _ = title;
742
743 // Show native alert
744 mobile.iOS.showAlert(message, true);
745
746 bridge.sendResponse(callback_id, "{ \"success\": true }") catch |err| {
747 std.log.debug("failed to send showAlert response: {}", .{err});
748 };
749 }
750
751 fn handleHaptic(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
752 // Extract haptic type
753 const haptic_type_str = bridge.extractJsonString(params, "type") orelse "light";
754
755 const haptic_type: mobile.iOS.HapticType = blk: {
756 if (std.mem.eql(u8, haptic_type_str, "success")) break :blk .success;
757 if (std.mem.eql(u8, haptic_type_str, "warning")) break :blk .warning;
758 if (std.mem.eql(u8, haptic_type_str, "error")) break :blk .error_haptic;
759 if (std.mem.eql(u8, haptic_type_str, "light")) break :blk .light;
760 if (std.mem.eql(u8, haptic_type_str, "medium")) break :blk .medium;
761 if (std.mem.eql(u8, haptic_type_str, "heavy")) break :blk .heavy;
762 break :blk .light;
763 };
764
765 mobile.iOS.triggerHaptic(haptic_type);
766
767 bridge.sendResponse(callback_id, "{ \"success\": true }") catch |err| {
768 std.log.debug("failed to send haptic response: {}", .{err});
769 };
770 }
771
772 fn handleSetClipboard(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
773 const text = bridge.extractJsonString(params, "text") orelse "";
774
775 mobile.iOS.setClipboard(text);
776
777 bridge.sendResponse(callback_id, "{ \"success\": true }") catch |err| {
778 std.log.debug("failed to send setClipboard response: {}", .{err});
779 };
780 }
781
782 fn handleGetClipboard(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
783 _ = params;
784
785 const text = mobile.iOS.getClipboard(bridge.allocator) catch "";
786
787 var buf: [1024]u8 = undefined;
788 const response = std.fmt.bufPrint(&buf, "{⁠{ \"text\": \"{s}\" }}", .{text}) catch "{}";
789
790 bridge.sendResponse(callback_id, response) catch |err| {
791 std.log.debug("failed to send getClipboard response: {}", .{err});
792 };
793 }
794
795 fn handleGetNetworkStatus(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
796 _ = params;
797
798 // For now, assume connected - real implementation would check reachability
799 const response = "{ \"connected\": true, \"type\": \"wifi\" }";
800
801 bridge.sendResponse(callback_id, response) catch |err| {
802 std.log.debug("failed to send getNetworkStatus response: {}", .{err});
803 };
804 }
805
806 fn handleGetSafeArea(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
807 _ = params;
808
809 if (bridge.app_delegate) |app| {
810 const insets = app.getSafeAreaInsets() catch SafeAreaInsets{ .top = 0, .bottom = 0, .left = 0, .right = 0 };
811
812 var buf: [256]u8 = undefined;
813 const response = std.fmt.bufPrint(&buf,
814 \\{⁠{ "top": {d}, "bottom": {d}, "left": {d}, "right": {d} }}
815 , .{ insets.top, insets.bottom, insets.left, insets.right }) catch "{}";
816
817 bridge.sendResponse(callback_id, response) catch |err| {
818 std.log.debug("failed to send getSafeArea response: {}", .{err});
819 };
820 } else {
821 bridge.sendResponse(callback_id, "{ \"top\": 0, \"bottom\": 0, \"left\": 0, \"right\": 0 }") catch |err| {
822 std.log.debug("failed to send getSafeArea fallback response: {}", .{err});
823 };
824 }
825 }
826
827 fn handleOpenURL(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
828 const url = bridge.extractJsonString(params, "url") orelse "";
829
830 mobile.iOS.openURL(url);
831
832 bridge.sendResponse(callback_id, "{ \"success\": true }") catch |err| {
833 std.log.debug("failed to send openURL response: {}", .{err});
834 };
835 }
836
837 fn handleShare(params: []const u8, bridge: *JSBridge, callback_id: []const u8) void {
838 const text = bridge.extractJsonString(params, "text") orelse "";
839
840 mobile.iOS.share(text);
841
842 bridge.sendResponse(callback_id, "{ \"success\": true }") catch |err| {
843 std.log.debug("failed to send share response: {}", .{err});
844 };
845 }
846};
847
848471// ============================================================================
849472// Convenience Functions
850473// ============================================================================
@@ -887,39 +510,6 @@ test "CraftAppDelegate initialization" {
887510 // Can't fully test without iOS runtime
888511}
889512
890test "JSBridge initialization" {
891 const allocator = std.testing.allocator;
892
893 var bridge = JSBridge.init(allocator);
894 defer bridge.deinit();
895
896 const handler = struct {
897 fn handle(_: []const u8, _: *JSBridge, _: []const u8) void {}
898 }.handle;
899
900 try bridge.registerHandler("test", handler);
901}
902
903test "JSBridge JSON parsing" {
904 const allocator = std.testing.allocator;
905
906 var bridge = JSBridge.init(allocator);
907 defer bridge.deinit();
908
909 // Test extractJsonString
910 const json =
911 \\{"method":"getPlatform","params":{},"callbackId":"123"}
912 ;
913
914 const method = bridge.extractJsonString(json, "method");
915 try std.testing.expect(method != null);
916 try std.testing.expectEqualStrings("getPlatform", method.?);
917
918 const callback_id = bridge.extractJsonString(json, "callbackId");
919 try std.testing.expect(callback_id != null);
920 try std.testing.expectEqualStrings("123", callback_id.?);
921}
922
923513test "SafeAreaInsets" {
924514 const insets = SafeAreaInsets{
925515 .top = 47.0,
packages/zig/src/ios_main.zigmodified+20-22
Changes to packages/zig/src/ios_main.zig
@@ -131,11 +131,15 @@ export fn craft_ios_haptic(haptic_type: c_int) callconv(.c) void {
131131 mobile.iOS.triggerHaptic(h_type);
132132}
133133
134/// Show native alert
135export fn craft_ios_show_alert(message: [*]const u8, len: usize) callconv(.c) void {
136 const msg = message[0..len];
137 mobile.iOS.showAlert(msg, true);
138}
134// `craft_ios_show_alert` used to be exported here. It forwarded to
135// `mobile.iOS.showAlert`, which presented its UIAlertController against
136// `[UIApplication sharedApplication].keyWindow` — deprecated since iOS 13 and
137// nil in any scene-based app, which is every app the templates generate. It
138// also computed an auto-dismiss delay and then discarded it, so the alert its
139// doc comment described as self-dismissing never dismissed.
140//
141// Nothing outside this file ever called it: no Swift template references any
142// `craft_ios_*` symbol.
139143
140144// ============================================================================
141145// Default HTML Content
@@ -204,20 +208,14 @@ pub fn quickStart(allocator: std.mem.Allocator, html: []const u8) !void {
204208 try ios.quickStart(allocator, html);
205209}
206210
207// ============================================================================
208// Tests
209// ============================================================================
210
211test "iOS main exports" {
212 // Just verify the exports compile correctly
213 _ = craft_ios_init;
214 _ = craft_ios_set_html;
215 _ = craft_ios_set_url;
216 _ = craft_ios_run;
217 _ = craft_ios_deinit;
218 _ = craft_ios_haptic;
219 _ = craft_ios_show_alert;
220 _ = craft_ios_set_clipboard;
221 _ = craft_ios_open_url;
222 _ = craft_ios_share;
223}
211// The C API surface used to be asserted by a `test` block here that listed
212// `craft_ios_set_clipboard`, `craft_ios_open_url`, and `craft_ios_share` —
213// three functions this file has never declared. Undeclared identifiers are
214// resolved in AstGen, which runs over the whole file regardless of whether a
215// test is being built, so those three names were three of the nine errors that
216// kept `zig build build-ios-simulator` red from the 0.17 migration onward.
217//
218// It also asserted nothing a compiler would not: `_ = craft_ios_init;` on an
219// `export fn` in the same file cannot fail. `test/ios_surface_test.zig` covers
220// the real property — that every declaration reachable from `ios.zig` and
221// `mobile.iOS` actually compiles — and it does so on the host, in seconds.
packages/zig/src/ios_template.zigdeleted+0-633
Changes to packages/zig/src/ios_template.zig
@@ -1,633 +0,0 @@
1const std = @import("std");
2const io_context = @import("io_context.zig");
3
4/// iOS Swift Template Generator
5/// Generates complete iOS app templates with Craft integration
6pub const IOSTemplate = struct {
7 allocator: std.mem.Allocator,
8 app_name: []const u8,
9 bundle_id: []const u8,
10 output_dir: []const u8,
11
12 pub fn init(allocator: std.mem.Allocator, app_name: []const u8, bundle_id: []const u8, output_dir: []const u8) IOSTemplate {
13 return .{
14 .allocator = allocator,
15 .app_name = app_name,
16 .bundle_id = bundle_id,
17 .output_dir = output_dir,
18 };
19 }
20
21 pub fn generate(self: *IOSTemplate) !void {
22 // Create directory structure
23 try self.createDirectoryStructure();
24
25 // Generate Swift files
26 try self.generateAppDelegate();
27 try self.generateSceneDelegate();
28 try self.generateViewController();
29 try self.generateCraftBridge();
30 try self.generateARKitBridge();
31 try self.generateMLKitBridge();
32 try self.generateHealthKitBridge();
33
34 // Generate configuration files
35 try self.generateInfoPlist();
36 try self.generateEntitlements();
37 try self.generatePodfile();
38
39 std.debug.print("iOS template generated successfully at: {s}\n", .{self.output_dir});
40 }
41
42 fn createDirectoryStructure(self: *IOSTemplate) !void {
43 const io = io_context.get();
44 const cwd = io_context.cwd();
45
46 const dirs = [_][]const u8{
47 self.output_dir,
48 try std.fmt.allocPrint(self.allocator, "{s}/Sources", .{self.output_dir}),
49 try std.fmt.allocPrint(self.allocator, "{s}/Sources/Bridge", .{self.output_dir}),
50 try std.fmt.allocPrint(self.allocator, "{s}/Sources/Features", .{self.output_dir}),
51 try std.fmt.allocPrint(self.allocator, "{s}/Resources", .{self.output_dir}),
52 try std.fmt.allocPrint(self.allocator, "{s}/Assets.xcassets", .{self.output_dir}),
53 };
54
55 for (dirs) |dir| {
56 cwd.createDir(io, dir, .default_dir) catch |err| {
57 if (err != error.PathAlreadyExists) return err;
58 };
59 }
60 }
61
62 fn generateAppDelegate(self: *IOSTemplate) !void {
63 const content =
64 \\import UIKit
65 \\import WebKit
66 \\
67 \\@main
68 \\class AppDelegate: UIResponder, UIApplicationDelegate {
69 \\ var window: UIWindow?
70 \\ var craftBridge: CraftBridge?
71 \\
72 \\ func application(
73 \\ _ application: UIApplication,
74 \\ didFinishLaunchingWith options: [UIApplication.LaunchOptionsKey: Any]?
75 \\ ) -> Bool {
76 \\ // Initialize Craft Bridge
77 \\ craftBridge = CraftBridge.shared
78 \\
79 \\ // Configure window
80 \\ window = UIWindow(frame: UIScreen.main.bounds)
81 \\ window?.rootViewController = ViewController()
82 \\ window?.makeKeyAndVisible()
83 \\
84 \\ return true
85 \\ }
86 \\
87 \\ func application(_ application: UIApplication,
88 \\ configurationForConnecting connectingSceneSession: UISceneSession,
89 \\ options: UIScene.ConnectionOptions) -> UISceneConfiguration {
90 \\ return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
91 \\ }
92 \\}
93 \\
94 ;
95
96 try self.writeFile("Sources/AppDelegate.swift", content);
97 }
98
99 fn generateSceneDelegate(self: *IOSTemplate) !void {
100 const content =
101 \\import UIKit
102 \\
103 \\class SceneDelegate: UIResponder, UIWindowSceneDelegate {
104 \\ var window: UIWindow?
105 \\
106 \\ func scene(_ scene: UIScene,
107 \\ willConnectTo session: UISceneSession,
108 \\ options connectionOptions: UIScene.ConnectionOptions) {
109 \\ guard let windowScene = (scene as? UIWindowScene) else { return }
110 \\
111 \\ window = UIWindow(windowScene: windowScene)
112 \\ window?.rootViewController = ViewController()
113 \\ window?.makeKeyAndVisible()
114 \\ }
115 \\
116 \\ func sceneDidDisconnect(_ scene: UIScene) {}
117 \\ func sceneDidBecomeActive(_ scene: UIScene) {}
118 \\ func sceneWillResignActive(_ scene: UIScene) {}
119 \\ func sceneWillEnterForeground(_ scene: UIScene) {}
120 \\ func sceneDidEnterBackground(_ scene: UIScene) {}
121 \\}
122 \\
123 ;
124
125 try self.writeFile("Sources/SceneDelegate.swift", content);
126 }
127
128 fn generateViewController(self: *IOSTemplate) !void {
129 const content =
130 \\import UIKit
131 \\import WebKit
132 \\
133 \\class ViewController: UIViewController {
134 \\ private var webView: WKWebView!
135 \\ private let craftBridge = CraftBridge.shared
136 \\
137 \\ override func viewDidLoad() {
138 \\ super.viewDidLoad()
139 \\
140 \\ // Configure WKWebView
141 \\ let configuration = WKWebViewConfiguration()
142 \\ configuration.allowsInlineMediaPlayback = true
143 \\ configuration.mediaTypesRequiringUserActionForPlayback = []
144 \\
145 \\ // Ensure WebGL2 + OffscreenCanvas are available for the
146 \\ // interactive map renderer. These are default-on on iOS 15+
147 \\ // but explicit opt-in keeps older OS builds consistent.
148 \\ let preferences = WKPreferences()
149 \\ if #available(iOS 14.0, *) {
150 \\ configuration.defaultWebpagePreferences.allowsContentJavaScript = true
151 \\ } else {
152 \\ preferences.javaScriptEnabled = true
153 \\ }
154 \\ configuration.preferences = preferences
155 \\ configuration.preferences.setValue(true, forKey: "offlineApplicationCacheIsEnabled")
156 \\
157 \\ // Add Craft message handler
158 \\ configuration.userContentController.add(craftBridge, name: "craft")
159 \\
160 \\ // Inject Craft bridge script
161 \\ let bridgeScript = WKUserScript(
162 \\ source: craftBridge.bridgeScript,
163 \\ injectionTime: .atDocumentStart,
164 \\ forMainFrameOnly: true
165 \\ )
166 \\ configuration.userContentController.addUserScript(bridgeScript)
167 \\
168 \\ webView = WKWebView(frame: view.bounds, configuration: configuration)
169 \\ webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
170 \\ webView.navigationDelegate = self
171 \\ view.addSubview(webView)
172 \\
173 \\ // Load initial URL
174 \\ if let url = URL(string: "http://localhost:3000") {
175 \\ webView.load(URLRequest(url: url))
176 \\ }
177 \\ }
178 \\}
179 \\
180 \\extension ViewController: WKNavigationDelegate {
181 \\ func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
182 \\ print("Page loaded successfully")
183 \\ }
184 \\
185 \\ func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
186 \\ print("Navigation failed: \(error.localizedDescription)")
187 \\ }
188 \\}
189 \\
190 ;
191
192 try self.writeFile("Sources/ViewController.swift", content);
193 }
194
195 fn generateCraftBridge(self: *IOSTemplate) !void {
196 const content =
197 \\import Foundation
198 \\import WebKit
199 \\import UIKit
200 \\
201 \\class CraftBridge: NSObject, WKScriptMessageHandler {
202 \\ static let shared = CraftBridge()
203 \\ private weak var webView: WKWebView?
204 \\
205 \\ private override init() {
206 \\ super.init()
207 \\ }
208 \\
209 \\ // Bridge script injected into WebView
210 \\ var bridgeScript: String {
211 \\ return """
212 \\ // This will be replaced with actual JS bridge from js_bridge.zig
213 \\ window.craft = window.craft || {};
214 \\ window.craft.invoke = function(method, params) {
215 \\ return new Promise((resolve, reject) => {
216 \\ const messageId = Date.now() + '_' + Math.random();
217 \\ window.webkit.messageHandlers.craft.postMessage({
218 \\ id: messageId,
219 \\ method: method,
220 \\ params: params
221 \\ });
222 \\ });
223 \\ };
224 \\ """
225 \\ }
226 \\
227 \\ // Handle messages from JavaScript
228 \\ func userContentController(_ userContentController: WKUserContentController,
229 \\ didReceive message: WKScriptMessage) {
230 \\ guard let body = message.body as? [String: Any],
231 \\ let method = body["method"] as? String,
232 \\ let messageId = body["id"] as? String else {
233 \\ return
234 \\ }
235 \\
236 \\ let params = body["params"] as? [String: Any]
237 \\
238 \\ // Route to appropriate handler
239 \\ handleMessage(method: method, params: params) { result in
240 \\ self.sendResponse(messageId: messageId, result: result)
241 \\ }
242 \\ }
243 \\
244 \\ private func handleMessage(method: String, params: [String: Any]?, completion: @escaping ([String: Any]) -> Void) {
245 \\ switch method {
246 \\ case "getPlatform":
247 \\ completion(["platform": "ios", "version": UIDevice.current.systemVersion])
248 \\
249 \\ case "showToast":
250 \\ if let message = params?["message"] as? String {
251 \\ showToast(message: message)
252 \\ completion(["success": true])
253 \\ }
254 \\
255 \\ case "haptic":
256 \\ if let type = params?["type"] as? String {
257 \\ triggerHaptic(type: type)
258 \\ completion(["success": true])
259 \\ }
260 \\
261 \\ case "requestPermission":
262 \\ if let permission = params?["permission"] as? String {
263 \\ requestPermission(permission: permission, completion: completion)
264 \\ }
265 \\
266 \\ default:
267 \\ completion(["error": "Unknown method: \(method)"])
268 \\ }
269 \\ }
270 \\
271 \\ private func sendResponse(messageId: String, result: [String: Any]) {
272 \\ let response: [String: Any] = [
273 \\ "id": messageId,
274 \\ "success": result["error"] == nil,
275 \\ "result": result
276 \\ ]
277 \\
278 \\ if let jsonData = try? JSONSerialization.data(withJSONObject: response),
279 \\ let jsonString = String(data: jsonData, encoding: .utf8) {
280 \\ let script = "window.craftHandleResponse('\(jsonString)')"
281 \\ webView?.evaluateJavaScript(script)
282 \\ }
283 \\ }
284 \\
285 \\ private func showToast(message: String) {
286 \\ // Simple alert for toast
287 \\ DispatchQueue.main.async {
288 \\ if let window = UIApplication.shared.windows.first {
289 \\ let alert = UIAlertController(title: nil, message: message, preferredStyle: .alert)
290 \\ window.rootViewController?.present(alert, animated: true)
291 \\ DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
292 \\ alert.dismiss(animated: true)
293 \\ }
294 \\ }
295 \\ }
296 \\ }
297 \\
298 \\ private func triggerHaptic(type: String) {
299 \\ let generator: UIFeedbackGenerator
300 \\
301 \\ switch type {
302 \\ case "selection":
303 \\ generator = UISelectionFeedbackGenerator()
304 \\ case "impact_light":
305 \\ generator = UIImpactFeedbackGenerator(style: .light)
306 \\ case "impact_medium":
307 \\ generator = UIImpactFeedbackGenerator(style: .medium)
308 \\ case "impact_heavy":
309 \\ generator = UIImpactFeedbackGenerator(style: .heavy)
310 \\ case "notification_success":
311 \\ let notificationGenerator = UINotificationFeedbackGenerator()
312 \\ notificationGenerator.notificationOccurred(.success)
313 \\ return
314 \\ case "notification_warning":
315 \\ let notificationGenerator = UINotificationFeedbackGenerator()
316 \\ notificationGenerator.notificationOccurred(.warning)
317 \\ return
318 \\ case "notification_error":
319 \\ let notificationGenerator = UINotificationFeedbackGenerator()
320 \\ notificationGenerator.notificationOccurred(.error)
321 \\ return
322 \\ default:
323 \\ generator = UISelectionFeedbackGenerator()
324 \\ }
325 \\
326 \\ if let impactGenerator = generator as? UIImpactFeedbackGenerator {
327 \\ impactGenerator.impactOccurred()
328 \\ } else if let selectionGenerator = generator as? UISelectionFeedbackGenerator {
329 \\ selectionGenerator.selectionChanged()
330 \\ }
331 \\ }
332 \\
333 \\ private func requestPermission(permission: String, completion: @escaping ([String: Any]) -> Void) {
334 \\ // Permission handling will be implemented by specific bridge classes
335 \\ completion(["granted": false, "message": "Not implemented"])
336 \\ }
337 \\}
338 \\
339 ;
340
341 try self.writeFile("Sources/Bridge/CraftBridge.swift", content);
342 }
343
344 fn generateARKitBridge(self: *IOSTemplate) !void {
345 const content =
346 \\import Foundation
347 \\import ARKit
348 \\
349 \\@available(iOS 11.0, *)
350 \\class ARKitBridge: NSObject {
351 \\ private var arSession: ARSession?
352 \\ private var configuration: ARConfiguration?
353 \\
354 \\ func startARSession(type: String) -> [String: Any] {
355 \\ guard ARWorldTrackingConfiguration.isSupported else {
356 \\ return ["error": "ARKit not supported"]
357 \\ }
358 \\
359 \\ arSession = ARSession()
360 \\
361 \\ switch type {
362 \\ case "world":
363 \\ configuration = ARWorldTrackingConfiguration()
364 \\ case "face":
365 \\ if ARFaceTrackingConfiguration.isSupported {
366 \\ configuration = ARFaceTrackingConfiguration()
367 \\ }
368 \\ case "image":
369 \\ configuration = ARImageTrackingConfiguration()
370 \\ default:
371 \\ configuration = ARWorldTrackingConfiguration()
372 \\ }
373 \\
374 \\ if let config = configuration {
375 \\ arSession?.run(config)
376 \\ return ["success": true]
377 \\ }
378 \\
379 \\ return ["error": "Failed to start AR session"]
380 \\ }
381 \\
382 \\ func stopARSession() {
383 \\ arSession?.pause()
384 \\ }
385 \\}
386 \\
387 ;
388
389 try self.writeFile("Sources/Features/ARKitBridge.swift", content);
390 }
391
392 fn generateMLKitBridge(self: *IOSTemplate) !void {
393 const content =
394 \\import Foundation
395 \\import Vision
396 \\import CoreML
397 \\
398 \\class MLKitBridge: NSObject {
399 \\ func detectText(in image: UIImage, completion: @escaping ([String: Any]) -> Void) {
400 \\ guard let cgImage = image.cgImage else {
401 \\ completion(["error": "Invalid image"])
402 \\ return
403 \\ }
404 \\
405 \\ let request = VNRecognizeTextRequest { request, error in
406 \\ if let error = error {
407 \\ completion(["error": error.localizedDescription])
408 \\ return
409 \\ }
410 \\
411 \\ guard let observations = request.results as? [VNRecognizedTextObservation] else {
412 \\ completion(["results": []])
413 \\ return
414 \\ }
415 \\
416 \\ let text = observations.compactMap { observation in
417 \\ observation.topCandidates(1).first?.string
418 \\ }
419 \\
420 \\ completion(["results": text])
421 \\ }
422 \\
423 \\ request.recognitionLevel = .accurate
424 \\
425 \\ let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
426 \\ try? handler.perform([request])
427 \\ }
428 \\
429 \\ func classifyImage(in image: UIImage, completion: @escaping ([String: Any]) -> Void) {
430 \\ guard let cgImage = image.cgImage else {
431 \\ completion(["error": "Invalid image"])
432 \\ return
433 \\ }
434 \\
435 \\ let request = VNClassifyImageRequest { request, error in
436 \\ if let error = error {
437 \\ completion(["error": error.localizedDescription])
438 \\ return
439 \\ }
440 \\
441 \\ guard let observations = request.results as? [VNClassificationObservation] else {
442 \\ completion(["results": []])
443 \\ return
444 \\ }
445 \\
446 \\ let classifications = observations.prefix(5).map { observation in
447 \\ ["label": observation.identifier, "confidence": observation.confidence]
448 \\ }
449 \\
450 \\ completion(["results": classifications])
451 \\ }
452 \\
453 \\ let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
454 \\ try? handler.perform([request])
455 \\ }
456 \\}
457 \\
458 ;
459
460 try self.writeFile("Sources/Features/MLKitBridge.swift", content);
461 }
462
463 fn generateHealthKitBridge(self: *IOSTemplate) !void {
464 const content =
465 \\import Foundation
466 \\import HealthKit
467 \\
468 \\class HealthKitBridge: NSObject {
469 \\ private let healthStore = HKHealthStore()
470 \\
471 \\ func requestAuthorization(completion: @escaping ([String: Any]) -> Void) {
472 \\ guard HKHealthStore.isHealthDataAvailable() else {
473 \\ completion(["error": "HealthKit not available"])
474 \\ return
475 \\ }
476 \\
477 \\ let readTypes: Set<HKObjectType> = [
478 \\ HKObjectType.quantityType(forIdentifier: .stepCount)!,
479 \\ HKObjectType.quantityType(forIdentifier: .heartRate)!,
480 \\ HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)!
481 \\ ]
482 \\
483 \\ healthStore.requestAuthorization(toShare: nil, read: readTypes) { success, error in
484 \\ if let error = error {
485 \\ completion(["error": error.localizedDescription])
486 \\ } else {
487 \\ completion(["granted": success])
488 \\ }
489 \\ }
490 \\ }
491 \\
492 \\ func getStepCount(completion: @escaping ([String: Any]) -> Void) {
493 \\ guard let stepType = HKQuantityType.quantityType(forIdentifier: .stepCount) else {
494 \\ completion(["error": "Step count not available"])
495 \\ return
496 \\ }
497 \\
498 \\ let now = Date()
499 \\ let startOfDay = Calendar.current.startOfDay(for: now)
500 \\ let predicate = HKQuery.predicateForSamples(withStart: startOfDay, end: now, options: .strictStartDate)
501 \\
502 \\ let query = HKStatisticsQuery(quantityType: stepType, quantitySamplePredicate: predicate, options: .cumulativeSum) { _, result, error in
503 \\ if let error = error {
504 \\ completion(["error": error.localizedDescription])
505 \\ return
506 \\ }
507 \\
508 \\ guard let sum = result?.sumQuantity() else {
509 \\ completion(["steps": 0])
510 \\ return
511 \\ }
512 \\
513 \\ let steps = sum.doubleValue(for: HKUnit.count())
514 \\ completion(["steps": Int(steps)])
515 \\ }
516 \\
517 \\ healthStore.execute(query)
518 \\ }
519 \\}
520 \\
521 ;
522
523 try self.writeFile("Sources/Features/HealthKitBridge.swift", content);
524 }
525
526 fn generateInfoPlist(self: *IOSTemplate) !void {
527 const content = try std.fmt.allocPrint(
528 self.allocator,
529 \\<?xml version="1.0" encoding="UTF-8"?>
530 \\<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
531 \\<plist version="1.0">
532 \\<dict>
533 \\ <key>CFBundleDevelopmentRegion</key>
534 \\ <string>$(DEVELOPMENT_LANGUAGE)</string>
535 \\ <key>CFBundleDisplayName</key>
536 \\ <string>{s}</string>
537 \\ <key>CFBundleExecutable</key>
538 \\ <string>$(EXECUTABLE_NAME)</string>
539 \\ <key>CFBundleIdentifier</key>
540 \\ <string>{s}</string>
541 \\ <key>CFBundleName</key>
542 \\ <string>$(PRODUCT_NAME)</string>
543 \\ <key>CFBundleVersion</key>
544 \\ <string>1</string>
545 \\ <key>LSRequiresIPhoneOS</key>
546 \\ <true/>
547 \\ <key>UIRequiredDeviceCapabilities</key>
548 \\ <array>
549 \\ <string>armv7</string>
550 \\ </array>
551 \\ <key>UISupportedInterfaceOrientations</key>
552 \\ <array>
553 \\ <string>UIInterfaceOrientationPortrait</string>
554 \\ <string>UIInterfaceOrientationLandscapeLeft</string>
555 \\ <string>UIInterfaceOrientationLandscapeRight</string>
556 \\ </array>
557 \\ <key>NSCameraUsageDescription</key>
558 \\ <string>This app needs camera access</string>
559 \\ <key>NSPhotoLibraryUsageDescription</key>
560 \\ <string>This app needs photo library access</string>
561 \\ <key>NSLocationWhenInUseUsageDescription</key>
562 \\ <string>This app needs location access</string>
563 \\ <key>NSHealthShareUsageDescription</key>
564 \\ <string>This app needs health data access</string>
565 \\ <key>NSHealthUpdateUsageDescription</key>
566 \\ <string>This app needs to update health data</string>
567 \\ <key>NSLocalNetworkUsageDescription</key>
568 \\ <string>This app needs local network access for development</string>
569 \\</dict>
570 \\</plist>
571 \\
572 ,
573 .{ self.app_name, self.bundle_id },
574 );
575 defer self.allocator.free(content);
576
577 try self.writeFile("Info.plist", content);
578 }
579
580 fn generateEntitlements(self: *IOSTemplate) !void {
581 const content =
582 \\<?xml version="1.0" encoding="UTF-8"?>
583 \\<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
584 \\<plist version="1.0">
585 \\<dict>
586 \\ <key>com.apple.developer.healthkit</key>
587 \\ <true/>
588 \\ <key>com.apple.developer.healthkit.access</key>
589 \\ <array/>
590 \\</dict>
591 \\</plist>
592 \\
593 ;
594
595 try self.writeFile("Entitlements.plist", content);
596 }
597
598 fn generatePodfile(self: *IOSTemplate) !void {
599 const content =
600 \\# Podfile for Craft iOS App
601 \\platform :ios, '14.0'
602 \\use_frameworks!
603 \\
604 \\target 'CraftApp' do
605 \\ # Add pods here if needed
606 \\end
607 \\
608 ;
609
610 try self.writeFile("Podfile", content);
611 }
612
613 fn writeFile(self: *IOSTemplate, relative_path: []const u8, content: []const u8) !void {
614 const full_path = try std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ self.output_dir, relative_path });
615 defer self.allocator.free(full_path);
616
617 const io = io_context.get();
618 const cwd = io_context.cwd();
619 const file = try cwd.createFile(io, full_path, .{});
620 defer file.close(io);
621
622 try file.writeStreamingAll(io, content);
623 }
624};
625
626// Test
627test "iOS template generation" {
628 const allocator = std.testing.allocator;
629 const template = IOSTemplate.init(allocator, "TestApp", "com.test.app", "test_ios_output");
630
631 // Would generate files - skipping in test
632 _ = template;
633}
packages/zig/src/js_bridge.zigdeleted+0-635
Changes to packages/zig/src/js_bridge.zig
@@ -1,635 +0,0 @@
1const std = @import("std");
2const io_context = @import("io_context.zig");
3const mobile = @import("mobile.zig");
4
5/// Unified JavaScript Bridge API
6/// Provides consistent window.craft API across iOS, Android, and Desktop
7///
8/// Usage:
9/// ```javascript
10/// // Check platform
11/// const platform = await window.craft.getPlatform();
12///
13/// // Navigate
14/// await window.craft.navigate('https://example.com');
15///
16/// // Execute native code
17/// const result = await window.craft.invoke('myMethod', { param: 'value' });
18///
19/// // Listen for events
20/// window.craft.on('ready', () => console.log('App ready'));
21/// ```
22pub const JSBridgeError = error{
23 InvalidJSON,
24 MethodNotFound,
25 InvalidParameters,
26 ExecutionFailed,
27};
28
29/// JavaScript Bridge Message
30pub const JSMessage = struct {
31 id: []const u8,
32 method: []const u8,
33 params: ?std.json.Value = null,
34 callback: ?[]const u8 = null,
35 parsed: std.json.Parsed(std.json.Value),
36
37 pub fn parse(allocator: std.mem.Allocator, json_str: []const u8) !JSMessage {
38 const parsed = try std.json.parseFromSlice(std.json.Value, allocator, json_str, .{});
39 errdefer parsed.deinit();
40
41 const root = parsed.value;
42 if (root != .object) return JSBridgeError.InvalidJSON;
43
44 const obj = root.object;
45 const id = obj.get("id") orelse return JSBridgeError.InvalidJSON;
46 const method = obj.get("method") orelse return JSBridgeError.InvalidJSON;
47 if (id != .string or method != .string) return JSBridgeError.InvalidJSON;
48 if (obj.get("callback")) |callback| {
49 if (callback != .string) return JSBridgeError.InvalidJSON;
50 }
51
52 return JSMessage{
53 .id = id.string,
54 .method = method.string,
55 .params = if (obj.get("params")) |params_val| params_val else null,
56 .callback = if (obj.get("callback")) |cb_val| cb_val.string else null,
57 .parsed = parsed,
58 };
59 }
60
61 pub fn deinit(self: *JSMessage, allocator: std.mem.Allocator) void {
62 _ = allocator;
63 self.parsed.deinit();
64 }
65};
66
67/// JavaScript Bridge Response
68pub const JSResponse = struct {
69 id: []const u8,
70 success: bool,
71 result: ?std.json.Value = null,
72 error_msg: ?[]const u8 = null,
73
74 pub fn toJSON(self: JSResponse, allocator: std.mem.Allocator) ![]u8 {
75 var string = std.ArrayList(u8).init(allocator);
76 errdefer string.deinit();
77
78 try string.appendSlice("{");
79
80 // ID
81 try string.appendSlice("\"id\":\"");
82 try string.appendSlice(self.id);
83 try string.appendSlice("\",");
84
85 // Success
86 try string.appendSlice("\"success\":");
87 try string.appendSlice(if (self.success) "true" else "false");
88
89 // Result or error
90 if (self.result) |result| {
91 try string.appendSlice(",\"result\":");
92 try std.json.stringify(result, .{}, string.writer());
93 }
94
95 if (self.error_msg) |err| {
96 try string.appendSlice(",\"error\":\"");
97 try string.appendSlice(err);
98 try string.appendSlice("\"");
99 }
100
101 try string.appendSlice("}");
102
103 return string.toOwnedSlice();
104 }
105};
106
107/// JavaScript Bridge Handler
108pub const JSBridge = struct {
109 allocator: std.mem.Allocator,
110 handlers: std.StringHashMap(Handler),
111 event_listeners: std.StringHashMap(std.ArrayList(EventCallback)),
112
113 const Handler = *const fn (allocator: std.mem.Allocator, params: ?std.json.Value) anyerror!std.json.Value;
114 const EventCallback = *const fn (data: std.json.Value) void;
115
116 pub fn init(allocator: std.mem.Allocator) JSBridge {
117 return JSBridge{
118 .allocator = allocator,
119 .handlers = std.StringHashMap(Handler).init(allocator),
120 .event_listeners = std.StringHashMap(std.ArrayList(EventCallback)).init(allocator),
121 };
122 }
123
124 pub fn deinit(self: *JSBridge) void {
125 self.handlers.deinit();
126
127 var it = self.event_listeners.iterator();
128 while (it.next()) |entry| {
129 entry.value_ptr.deinit();
130 }
131 self.event_listeners.deinit();
132 }
133
134 /// Register a method handler
135 pub fn registerMethod(self: *JSBridge, method_name: []const u8, handler: Handler) !void {
136 try self.handlers.put(method_name, handler);
137 }
138
139 /// Handle incoming JavaScript message
140 pub fn handleMessage(self: *JSBridge, json_str: []const u8) ![]u8 {
141 var message = try JSMessage.parse(self.allocator, json_str);
142 defer message.deinit(self.allocator);
143
144 // Look up handler
145 const handler = self.handlers.get(message.method) orelse {
146 const response = JSResponse{
147 .id = message.id,
148 .success = false,
149 .error_msg = "Method not found",
150 };
151 return try response.toJSON(self.allocator);
152 };
153
154 // Execute handler
155 const result = handler(self.allocator, message.params) catch |err| {
156 const err_name = @errorName(err);
157 const response = JSResponse{
158 .id = message.id,
159 .success = false,
160 .error_msg = err_name,
161 };
162 return try response.toJSON(self.allocator);
163 };
164
165 // Return success response
166 const response = JSResponse{
167 .id = message.id,
168 .success = true,
169 .result = result,
170 };
171 return try response.toJSON(self.allocator);
172 }
173
174 /// Emit event to JavaScript
175 pub fn emit(self: *JSBridge, event_name: []const u8, data: std.json.Value) ![]u8 {
176 var string = std.ArrayList(u8).init(self.allocator);
177 errdefer string.deinit();
178
179 try string.appendSlice("{\"event\":\"");
180 try string.appendSlice(event_name);
181 try string.appendSlice("\",\"data\":");
182 try std.json.stringify(data, .{}, string.writer());
183 try string.appendSlice("}");
184
185 return string.toOwnedSlice();
186 }
187};
188
189/// Built-in method handlers
190pub const BuiltInHandlers = struct {
191 /// Get platform information
192 pub fn getPlatform(allocator: std.mem.Allocator, params: ?std.json.Value) !std.json.Value {
193 _ = params;
194 const platform = mobile.Platform.current();
195
196 const platform_str = switch (platform) {
197 .ios => "ios",
198 .android => "android",
199 .unknown => "unknown",
200 };
201
202 var obj = std.json.ObjectMap.init(allocator);
203 try obj.put("platform", .{ .string = platform_str });
204 const build_opts = @import("build_options");
205 const ver = if (@hasDecl(build_opts, "version")) build_opts.version else "0.0.0";
206 try obj.put("version", .{ .string = ver });
207
208 return std.json.Value{ .object = obj };
209 }
210
211 /// Get device information
212 pub fn getDeviceInfo(allocator: std.mem.Allocator, params: ?std.json.Value) !std.json.Value {
213 _ = params;
214 var obj = std.json.ObjectMap.init(allocator);
215
216 const builtin = @import("builtin");
217 const platform = mobile.Platform.current();
218
219 try obj.put("platform", .{ .string = switch (platform) {
220 .ios => "ios",
221 .android => "android",
222 .unknown => if (builtin.os.tag == .macos) "macos" else if (builtin.os.tag == .linux) "linux" else if (builtin.os.tag == .windows) "windows" else "unknown",
223 } });
224
225 // Get actual device info from native APIs
226 if (builtin.os.tag == .macos or builtin.os.tag == .ios) {
227 // Use NSProcessInfo for macOS/iOS
228 const device_info = getMacOSDeviceInfo(allocator);
229 try obj.put("model", .{ .string = device_info.model });
230 try obj.put("os_version", .{ .string = device_info.os_version });
231 try obj.put("os_name", .{ .string = device_info.os_name });
232 try obj.put("processor_count", .{ .integer = @intCast(device_info.processor_count) });
233 } else if (builtin.os.tag == .linux) {
234 // Read from /etc/os-release for Linux
235 const linux_info = getLinuxDeviceInfo(allocator);
236 try obj.put("model", .{ .string = linux_info.model });
237 try obj.put("os_version", .{ .string = linux_info.os_version });
238 try obj.put("os_name", .{ .string = linux_info.os_name });
239 } else {
240 try obj.put("model", .{ .string = "Unknown" });
241 try obj.put("os_version", .{ .string = "Unknown" });
242 }
243
244 return std.json.Value{ .object = obj };
245 }
246
247 const MacOSDeviceInfo = struct {
248 model: []const u8,
249 os_version: []const u8,
250 os_name: []const u8,
251 processor_count: u32,
252 };
253
254 fn getMacOSDeviceInfo(allocator: std.mem.Allocator) MacOSDeviceInfo {
255 const builtin = @import("builtin");
256 if (builtin.os.tag != .macos and builtin.os.tag != .ios) {
257 return .{ .model = "Unknown", .os_version = "Unknown", .os_name = "Unknown", .processor_count = 1 };
258 }
259
260 var model: []const u8 = "Mac";
261 var os_version: []const u8 = "Unknown";
262 var os_name: []const u8 = "macOS";
263 var processor_count: u32 = 1;
264
265 // Get system info using sysctl
266 const CTL_HW = 6;
267 const HW_MODEL = 2;
268 const HW_NCPU = 3;
269
270 // Get model
271 var model_buf: [256]u8 = undefined;
272 var model_size: usize = model_buf.len;
273 var mib = [_]c_int{ CTL_HW, HW_MODEL };
274
275 const sysctl = @extern(*fn ([*]c_int, c_uint, ?*anyopaque, *usize, ?*anyopaque, usize) callconv(.c) c_int, .{ .name = "sysctl" });
276
277 if (sysctl(&mib, 2, &model_buf, &model_size, null, 0) == 0) {
278 model = allocator.dupe(u8, model_buf[0 .. model_size - 1]) catch "Mac";
279 }
280
281 // Get processor count
282 var ncpu: c_int = 1;
283 var ncpu_size: usize = @sizeOf(c_int);
284 mib = [_]c_int{ CTL_HW, HW_NCPU };
285 if (sysctl(&mib, 2, @ptrCast(&ncpu), &ncpu_size, null, 0) == 0) {
286 processor_count = @intCast(ncpu);
287 }
288
289 // Get OS version using sysctlbyname
290 var version_buf: [64]u8 = undefined;
291 var version_size: usize = version_buf.len;
292
293 const sysctlbyname = @extern(*fn ([*:0]const u8, ?*anyopaque, *usize, ?*anyopaque, usize) callconv(.c) c_int, .{ .name = "sysctlbyname" });
294
295 if (sysctlbyname("kern.osproductversion", &version_buf, &version_size, null, 0) == 0) {
296 os_version = allocator.dupe(u8, version_buf[0 .. version_size - 1]) catch "Unknown";
297 }
298
299 // Determine OS name
300 if (builtin.os.tag == .ios) {
301 os_name = "iOS";
302 }
303
304 return .{
305 .model = model,
306 .os_version = os_version,
307 .os_name = os_name,
308 .processor_count = processor_count,
309 };
310 }
311
312 const LinuxDeviceInfo = struct {
313 model: []const u8,
314 os_version: []const u8,
315 os_name: []const u8,
316 };
317
318 fn getLinuxDeviceInfo(allocator: std.mem.Allocator) LinuxDeviceInfo {
319 var model: []const u8 = "Linux PC";
320 var os_version: []const u8 = "Unknown";
321 var os_name: []const u8 = "Linux";
322
323 // Read /etc/os-release
324 const io = io_context.get();
325 const file = io_context.cwd().openFile(io, "/etc/os-release", .{}) catch {
326 return .{ .model = model, .os_version = os_version, .os_name = os_name };
327 };
328 defer file.close(io);
329
330 var buf: [4096]u8 = undefined;
331 const bytes_read = file.readPositional(io, &.{&buf}, 0) catch return .{ .model = model, .os_version = os_version, .os_name = os_name };
332 const content = buf[0..bytes_read];
333
334 var lines = std.mem.splitScalar(u8, content, '\n');
335 while (lines.next()) |line| {
336 if (std.mem.startsWith(u8, line, "PRETTY_NAME=")) {
337 const value = std.mem.trim(u8, line["PRETTY_NAME=".len..], "\"");
338 os_name = allocator.dupe(u8, value) catch "Linux";
339 } else if (std.mem.startsWith(u8, line, "VERSION_ID=")) {
340 const value = std.mem.trim(u8, line["VERSION_ID=".len..], "\"");
341 os_version = allocator.dupe(u8, value) catch "Unknown";
342 }
343 }
344
345 // Try to get hardware model from /sys/class/dmi/id/product_name
346 const model_file = io_context.cwd().openFile(io, "/sys/class/dmi/id/product_name", .{}) catch {
347 return .{ .model = model, .os_version = os_version, .os_name = os_name };
348 };
349 defer model_file.close(io);
350
351 var model_buf: [256]u8 = undefined;
352 const model_len = model_file.readPositional(io, &.{&model_buf}, 0) catch 0;
353 if (model_len > 0) {
354 model = allocator.dupe(u8, std.mem.trim(u8, model_buf[0..model_len], " \n\r\t")) catch "Linux PC";
355 }
356
357 return .{ .model = model, .os_version = os_version, .os_name = os_name };
358 }
359
360 /// Show toast/notification
361 pub fn showToast(allocator: std.mem.Allocator, params: ?std.json.Value) !std.json.Value {
362 if (params == null or params.? != .object) {
363 return JSBridgeError.InvalidParameters;
364 }
365
366 const obj = params.?.object;
367 const message = if (obj.get("message")) |msg| msg.string else return JSBridgeError.InvalidParameters;
368 const duration_str = if (obj.get("duration")) |dur| dur.string else "short";
369
370 const platform = mobile.Platform.current();
371 switch (platform) {
372 .android => {
373 // Call Android toast via mobile module
374 const toast_duration: mobile.Android.ToastDuration = if (std.mem.eql(u8, duration_str, "long"))
375 .long
376 else
377 .short;
378 // Note: Android toast requires Context, which would come from the app's main activity
379 // For now, log that toast was requested - full implementation needs Context access
380 std.debug.print("[JSBridge] Android toast requested: {s}\n", .{message});
381 _ = toast_duration;
382 },
383 .ios => {
384 // Show iOS alert/toast
385 const is_short = std.mem.eql(u8, duration_str, "short");
386 mobile.iOS.showAlert(message, is_short);
387 },
388 .unknown => {},
389 }
390
391 var result = std.json.ObjectMap.init(allocator);
392 try result.put("success", .{ .bool = true });
393
394 return std.json.Value{ .object = result };
395 }
396
397 /// Trigger haptic feedback
398 pub fn haptic(allocator: std.mem.Allocator, params: ?std.json.Value) !std.json.Value {
399 if (params == null or params.? != .object) {
400 return JSBridgeError.InvalidParameters;
401 }
402
403 const obj = params.?.object;
404 const haptic_type = if (obj.get("type")) |t| t.string else "selection";
405
406 const platform = mobile.Platform.current();
407 switch (platform) {
408 .ios => {
409 const haptic_enum: mobile.iOS.HapticType = blk: {
410 if (std.mem.eql(u8, haptic_type, "selection")) break :blk .selection;
411 if (std.mem.eql(u8, haptic_type, "impact_light")) break :blk .impact_light;
412 if (std.mem.eql(u8, haptic_type, "impact_medium")) break :blk .impact_medium;
413 if (std.mem.eql(u8, haptic_type, "impact_heavy")) break :blk .impact_heavy;
414 if (std.mem.eql(u8, haptic_type, "notification_success")) break :blk .notification_success;
415 if (std.mem.eql(u8, haptic_type, "notification_warning")) break :blk .notification_warning;
416 if (std.mem.eql(u8, haptic_type, "notification_error")) break :blk .notification_error;
417 break :blk .selection;
418 };
419 mobile.iOS.triggerHaptic(haptic_enum);
420 },
421 .android => {
422 // Call Android vibration based on haptic_type
423 const duration_ms: u64 = if (std.mem.eql(u8, haptic_type, "impact_heavy"))
424 100
425 else if (std.mem.eql(u8, haptic_type, "impact_medium"))
426 50
427 else
428 25;
429 // Note: Android vibrate requires Context - log for now
430 std.debug.print("[JSBridge] Android haptic requested: {s} ({d}ms)\n", .{ haptic_type, duration_ms });
431 },
432 .unknown => {},
433 }
434
435 var result = std.json.ObjectMap.init(allocator);
436 try result.put("success", .{ .bool = true });
437
438 return std.json.Value{ .object = result };
439 }
440
441 /// Request permission
442 pub fn requestPermission(allocator: std.mem.Allocator, params: ?std.json.Value) !std.json.Value {
443 if (params == null or params.? != .object) {
444 return JSBridgeError.InvalidParameters;
445 }
446
447 const obj = params.?.object;
448 const permission_str = if (obj.get("permission")) |p| p.string else return JSBridgeError.InvalidParameters;
449
450 // Map permission string to platform permission type
451 var granted = false;
452 var message: []const u8 = "Unknown permission";
453
454 const platform = mobile.Platform.current();
455 switch (platform) {
456 .ios => {
457 // iOS permissions are typically requested at first use
458 // For now, log and return pending state
459 std.debug.print("[JSBridge] iOS permission requested: {s}\n", .{permission_str});
460 message = "iOS permission request initiated";
461 },
462 .android => {
463 // Android runtime permissions
464 std.debug.print("[JSBridge] Android permission requested: {s}\n", .{permission_str});
465 message = "Android permission request initiated";
466 },
467 .unknown => {
468 message = "Unknown platform";
469 },
470 }
471
472 var result = std.json.ObjectMap.init(allocator);
473 try result.put("granted", .{ .bool = granted });
474 try result.put("message", .{ .string = message });
475
476 return std.json.Value{ .object = result };
477 }
478};
479
480/// Generate JavaScript bridge initialization code
481pub fn generateBridgeScript(allocator: std.mem.Allocator) ![]u8 {
482 const script =
483 \\(function() {
484 \\ // Create craft namespace
485 \\ window.craft = window.craft || {};
486 \\
487 \\ // Message ID counter
488 \\ let messageId = 0;
489 \\ const callbacks = new Map();
490 \\ const eventListeners = new Map();
491 \\
492 \\ // Send message to native layer
493 \\ function sendMessage(method, params) {
494 \\ return new Promise((resolve, reject) => {
495 \\ const id = `msg_${messageId++}`;
496 \\ callbacks.set(id, { resolve, reject });
497 \\
498 \\ const message = JSON.stringify({
499 \\ id,
500 \\ method,
501 \\ params
502 \\ });
503 \\
504 \\ // Platform-specific message sending
505 \\ if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.craft) {
506 \\ // iOS
507 \\ window.webkit.messageHandlers.craft.postMessage(message);
508 \\ } else if (window.Android && window.Android.postMessage) {
509 \\ // Android
510 \\ window.Android.postMessage(message);
511 \\ } else if (window.chrome && window.chrome.webview) {
512 \\ // Windows WebView2
513 \\ window.chrome.webview.postMessage(message);
514 \\ } else {
515 \\ // Desktop/Other
516 \\ console.warn('No native bridge found, message:', message);
517 \\ reject(new Error('Native bridge not available'));
518 \\ }
519 \\ });
520 \\ }
521 \\
522 \\ // Handle response from native
523 \\ window.craftHandleResponse = function(responseJson) {
524 \\ const response = JSON.parse(responseJson);
525 \\
526 \\ if (response.event) {
527 \\ // Event emission
528 \\ const listeners = eventListeners.get(response.event) || [];
529 \\ listeners.forEach(listener => listener(response.data));
530 \\ return;
531 \\ }
532 \\
533 \\ const callback = callbacks.get(response.id);
534 \\ if (!callback) return;
535 \\
536 \\ callbacks.delete(response.id);
537 \\
538 \\ if (response.success) {
539 \\ callback.resolve(response.result);
540 \\ } else {
541 \\ callback.reject(new Error(response.error || 'Unknown error'));
542 \\ }
543 \\ };
544 \\
545 \\ // Public API
546 \\ window.craft.invoke = sendMessage;
547 \\
548 \\ window.craft.getPlatform = () => sendMessage('getPlatform', {});
549 \\
550 \\ window.craft.getDeviceInfo = () => sendMessage('getDeviceInfo', {});
551 \\
552 \\ window.craft.showToast = (message, duration = 'short') => {
553 \\ return sendMessage('showToast', { message, duration });
554 \\ };
555 \\
556 \\ window.craft.haptic = (type = 'selection') => {
557 \\ return sendMessage('haptic', { type });
558 \\ };
559 \\
560 \\ window.craft.requestPermission = (permission) => {
561 \\ return sendMessage('requestPermission', { permission });
562 \\ };
563 \\
564 \\ window.craft.on = (event, listener) => {
565 \\ if (!eventListeners.has(event)) {
566 \\ eventListeners.set(event, []);
567 \\ }
568 \\ eventListeners.get(event).push(listener);
569 \\ };
570 \\
571 \\ window.craft.off = (event, listener) => {
572 \\ if (!eventListeners.has(event)) return;
573 \\ const listeners = eventListeners.get(event);
574 \\ const index = listeners.indexOf(listener);
575 \\ if (index > -1) {
576 \\ listeners.splice(index, 1);
577 \\ }
578 \\ };
579 \\
580 \\ window.craft.emit = (event, data) => {
581 \\ const listeners = eventListeners.get(event) || [];
582 \\ listeners.forEach(listener => listener(data));
583 \\ };
584 \\
585 \\ // Dispatch ready event
586 \\ window.dispatchEvent(new CustomEvent('craftReady'));
587 \\ window.craft.emit('ready', {});
588 \\
589 \\ console.log('Craft bridge initialized');
590 \\})();
591 ;
592
593 return try allocator.dupe(u8, script);
594}
595
596// Tests
597test "JSMessage parse" {
598 const allocator = std.testing.allocator;
599
600 const json = "{\"id\":\"msg_1\",\"method\":\"getPlatform\",\"params\":{}}";
601 var message = try JSMessage.parse(allocator, json);
602 defer message.deinit(allocator);
603
604 try std.testing.expectEqualStrings("msg_1", message.id);
605 try std.testing.expectEqualStrings("getPlatform", message.method);
606}
607
608test "JSResponse toJSON" {
609 const allocator = std.testing.allocator;
610
611 const response = JSResponse{
612 .id = "msg_1",
613 .success = true,
614 .result = std.json.Value{ .bool = true },
615 };
616
617 const json = try response.toJSON(allocator);
618 defer allocator.free(json);
619
620 try std.testing.expect(std.mem.indexOf(u8, json, "\"success\":true") != null);
621}
622
623test "JSBridge handler" {
624 const allocator = std.testing.allocator;
625 var bridge = JSBridge.init(allocator);
626 defer bridge.deinit();
627
628 try bridge.registerMethod("getPlatform", BuiltInHandlers.getPlatform);
629
630 const request = "{\"id\":\"msg_1\",\"method\":\"getPlatform\",\"params\":{}}";
631 const response = try bridge.handleMessage(request);
632 defer allocator.free(response);
633
634 try std.testing.expect(std.mem.indexOf(u8, response, "\"success\":true") != null);
635}
packages/zig/src/mobile.zigmodified+63-344
Changes to packages/zig/src/mobile.zig
@@ -1,5 +1,6 @@
11const std = @import("std");
22const objc_runtime = @import("objc_runtime.zig");
3const compat = @import("compat.zig");
34
45/// Mobile Platform Support
56/// Provides iOS and Android native integration
@@ -265,7 +266,7 @@ pub const NativeObjectManager = struct {
265266 .ptr = ptr,
266267 .size = size,
267268 .type_name = type_name,
268 .allocation_time = std.time.timestamp(),
269 .allocation_time = compat.timestamp(),
269270 };
270271
271272 try self.tracked_objects.put(addr, info);
@@ -322,7 +323,7 @@ pub const NativeObjectManager = struct {
322323
323324 std.debug.print("Memory Leak Report:\n", .{});
324325 while (it.next()) |entry| {
325 const age = std.time.timestamp() - entry.value.*.allocation_time;
326 const age = compat.timestamp() - entry.value.*.allocation_time;
326327 std.debug.print(" Leaked {s} at 0x{x} (size: {d} bytes, age: {d}s)\n", .{
327328 entry.value.*.type_name,
328329 entry.key_ptr.*,
@@ -469,11 +470,21 @@ pub const iOS = struct {
469470 const allocated = objc.msgSendId(WKWebViewClass, sel_alloc);
470471 const Fn = *const fn (objc.id, objc.SEL, objc.CGRect, objc.id) callconv(.c) objc.id;
471472 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
472 const webview = func(allocated, sel_initWithFrame, frame, configObj);
473 // `objc.id` is `?*anyopaque`, so this is optional and a failed
474 // `initWithFrame:configuration:` comes back as null. Unwrap once, here,
475 // rather than `@ptrCast` the optional away further down — a cast cannot
476 // discard optionality, and pretending otherwise is how a nil webview
477 // would have reached callers as a live pointer.
478 const webview = func(allocated, sel_initWithFrame, frame, configObj) orelse
479 return error.WebViewCreationFailed;
473480
474 // Track the webview in memory manager
481 // Track the webview in memory manager.
482 //
483 // The size reported here is `@sizeOf(WKWebView)` as the runtime knows
484 // it, not `@sizeOf(@TypeOf(webview))` — the latter is the width of a
485 // pointer, which made every WKWebView in the accounting cost 8 bytes.
475486 if (getGlobalObjectManager()) |manager| {
476 try manager.trackObject(webview, @sizeOf(@TypeOf(webview)), "WKWebView");
487 try manager.trackObject(webview, objc.classInstanceSize(WKWebViewClass), "WKWebView");
477488 }
478489
479490 // Associate allocator with webview for cleanup
@@ -567,82 +578,35 @@ pub const iOS = struct {
567578 // Create NSString from script
568579 const ns_script = try objc.createNSString(script, allocator.*);
569580
570 // Create completion handler block for JavaScript evaluation
571581 const sel_evaluateJavaScript = objc.sel_registerName("evaluateJavaScript:completionHandler:") orelse return error.SelectorNotFound;
572582
573 // Block structure for completion handler
574 // typedef void (^CompletionHandler)(id result, NSError *error);
575 const BlockDescriptor = extern struct {
576 reserved: c_ulong,
577 size: c_ulong,
578 };
579
580 const Block = extern struct {
581 isa: ?*anyopaque,
582 flags: c_int,
583 reserved: c_int,
584 invoke: ?*const fn (*@This(), ?objc.id, ?objc.id) callconv(.c) void,
585 descriptor: *const BlockDescriptor,
586 callback: ?*const fn (?[]const u8, ?[]const u8) void,
587 };
588
589 // Block invoke function that calls our Zig callback
590 const block_invoke = struct {
591 fn invoke(block: *Block, result: ?objc.id, err: ?objc.id) callconv(.c) void {
592 var result_str: ?[]const u8 = null;
593 var error_str: ?[]const u8 = null;
594
595 // Extract result string if present
596 if (result) |res| {
597 const desc = @import("objc_runtime.zig").objc.objc_msgSend;
598 const desc_fn: *const fn (objc.id, objc.SEL) callconv(.c) objc.id = @ptrCast(&desc);
599 const description = desc_fn(res, objc.sel_registerName("description").?);
600 if (description != null) {
601 const utf8_fn: *const fn (objc.id, objc.SEL) callconv(.c) [*:0]const u8 = @ptrCast(&desc);
602 const utf8 = utf8_fn(description, objc.sel_registerName("UTF8String").?);
603 result_str = std.mem.span(utf8);
604 }
605 }
606
607 // Extract error string if present
608 if (err) |e| {
609 const desc = @import("objc_runtime.zig").objc.objc_msgSend;
610 const desc_fn: *const fn (objc.id, objc.SEL) callconv(.c) objc.id = @ptrCast(&desc);
611 const description = desc_fn(e, objc.sel_registerName("localizedDescription").?);
612 if (description != null) {
613 const utf8_fn: *const fn (objc.id, objc.SEL) callconv(.c) [*:0]const u8 = @ptrCast(&desc);
614 const utf8 = utf8_fn(description, objc.sel_registerName("UTF8String").?);
615 error_str = std.mem.span(utf8);
616 }
617 }
618
619 // Call the user's callback
620 if (block.callback) |cb| {
621 cb(result_str, error_str);
622 }
623 }
624 }.invoke;
625
626 // Static descriptor (must persist)
627 const descriptor = BlockDescriptor{
628 .reserved = 0,
629 .size = @sizeOf(Block),
630 };
631
632 // Create block on stack (valid for duration of call)
633 var block = Block{
634 .isa = @extern(*anyopaque, .{ .name = "_NSConcreteStackBlock" }),
635 .flags = 0,
636 .reserved = 0,
637 .invoke = block_invoke,
638 .descriptor = &descriptor,
639 .callback = callback,
640 };
641
642 // Call evaluateJavaScript with our block
643 const Fn = *const fn (*anyopaque, objc.SEL, objc.id, *Block) callconv(.c) void;
583 // A completion handler is not wired up yet, and asking for one is an
584 // error rather than a silent drop.
585 //
586 // The block that used to live here did not work and could not have.
587 // It was built on the stack and handed to an *asynchronous* API — the
588 // comment beside it read "valid for duration of call", which is not
589 // the property an async callee needs. `_Block_copy` copies the block
590 // body but keeps the descriptor *pointer*, and that descriptor was
591 // also a function local, so both were dead before WebKit ever invoked
592 // them. Its `invoke` signature took `?objc.id`, which is `??*anyopaque`
593 // and illegal under `callconv(.c)`; and the `callback` field it stored
594 // had a different signature from this function's own parameter, so
595 // even the assignment was a type error. None of that was ever noticed
596 // because nothing reachable from the iOS exports called this function —
597 // which is precisely what `test/ios_surface_test.zig` now prevents.
598 //
599 // Doing it correctly means a module-level block with static storage
600 // (see `bridge_permissions.zig:131-164` for the shape that works) plus
601 // a pending-request table so the reply can find its caller. That lands
602 // with the dispatcher, not here.
603 if (callback != null) return error.CompletionHandlerNotImplemented;
604
605 // Passing nil for `completionHandler:` is legal and is what a
606 // fire-and-forget evaluation wants.
607 const Fn = *const fn (*anyopaque, objc.SEL, objc.id, ?*anyopaque) callconv(.c) void;
644608 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
645 func(webview_ptr, sel_evaluateJavaScript, ns_script, &block);
609 func(webview_ptr, sel_evaluateJavaScript, ns_script, null);
646610 }
647611
648612 /// Handle Deep Links
@@ -663,78 +627,6 @@ pub const iOS = struct {
663627 reminders,
664628 };
665629
666 /// Check current permission status
667 pub fn checkPermissionStatus(permission: Permission) !PermissionStatus {
668 if (!@import("builtin").target.os.tag.isDarwin()) {
669 return error.UnsupportedPlatform;
670 }
671
672 switch (permission) {
673 .camera, .microphone => {
674 const AVCaptureDeviceClass = objc.objc_getClass("AVCaptureDevice") orelse return error.ClassNotFound;
675 const sel_authorizationStatus = objc.sel_registerName("authorizationStatusForMediaType:") orelse return error.SelectorNotFound;
676
677 // AVMediaTypeVideo or AVMediaTypeAudio
678 const mediaType = if (permission == .camera) "vide" else "soun";
679 const mediaTypeStr = objc.objc_getClass("AVMediaTypeVideo") orelse {
680 // Fallback - create NSString for media type
681 const allocator = std.heap.page_allocator;
682 const ns_media = try objc.createNSString(mediaType, allocator);
683 const Fn = *const fn (objc.Class, objc.SEL, objc.id) callconv(.c) i64;
684 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
685 const status = func(AVCaptureDeviceClass, sel_authorizationStatus, ns_media);
686 return statusFromAVAuthorizationStatus(status);
687 };
688
689 const Fn = *const fn (objc.Class, objc.SEL, objc.id) callconv(.c) i64;
690 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
691 const status = func(AVCaptureDeviceClass, sel_authorizationStatus, mediaTypeStr);
692 return statusFromAVAuthorizationStatus(status);
693 },
694 .location => {
695 const CLLocationManagerClass = objc.objc_getClass("CLLocationManager") orelse return error.ClassNotFound;
696 const sel_authorizationStatus = objc.sel_registerName("authorizationStatus") orelse return error.SelectorNotFound;
697
698 const Fn = *const fn (objc.Class, objc.SEL) callconv(.c) i32;
699 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
700 const status = func(CLLocationManagerClass, sel_authorizationStatus);
701 return statusFromCLAuthorizationStatus(status);
702 },
703 .photos => {
704 const PHPhotoLibraryClass = objc.objc_getClass("PHPhotoLibrary") orelse return error.ClassNotFound;
705 const sel_authorizationStatus = objc.sel_registerName("authorizationStatus") orelse return error.SelectorNotFound;
706
707 const Fn = *const fn (objc.Class, objc.SEL) callconv(.c) i64;
708 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
709 const status = func(PHPhotoLibraryClass, sel_authorizationStatus);
710 return statusFromPHAuthorizationStatus(status);
711 },
712 .notifications => {
713 // Notifications require async check - return unknown for sync check
714 return .not_determined;
715 },
716 .contacts => {
717 const CNContactStoreClass = objc.objc_getClass("CNContactStore") orelse return error.ClassNotFound;
718 const sel_authorizationStatus = objc.sel_registerName("authorizationStatusForEntityType:") orelse return error.SelectorNotFound;
719
720 const Fn = *const fn (objc.Class, objc.SEL, i64) callconv(.c) i64;
721 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
722 const status = func(CNContactStoreClass, sel_authorizationStatus, 0); // CNEntityTypeContacts = 0
723 return statusFromCNAuthorizationStatus(status);
724 },
725 .calendar, .reminders => {
726 const EKEventStoreClass = objc.objc_getClass("EKEventStore") orelse return error.ClassNotFound;
727 const sel_authorizationStatus = objc.sel_registerName("authorizationStatusForEntityType:") orelse return error.SelectorNotFound;
728
729 const entity_type: i64 = if (permission == .calendar) 0 else 1; // EKEntityTypeEvent = 0, EKEntityTypeReminder = 1
730 const Fn = *const fn (objc.Class, objc.SEL, i64) callconv(.c) i64;
731 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
732 const status = func(EKEventStoreClass, sel_authorizationStatus, entity_type);
733 return statusFromEKAuthorizationStatus(status);
734 },
735 }
736 }
737
738630 pub const PermissionStatus = enum {
739631 not_determined,
740632 restricted,
@@ -743,145 +635,27 @@ pub const iOS = struct {
743635 limited, // For photos
744636 };
745637
746 fn statusFromAVAuthorizationStatus(status: i64) PermissionStatus {
747 return switch (status) {
748 0 => .not_determined, // AVAuthorizationStatusNotDetermined
749 1 => .restricted, // AVAuthorizationStatusRestricted
750 2 => .denied, // AVAuthorizationStatusDenied
751 3 => .authorized, // AVAuthorizationStatusAuthorized
752 else => .not_determined,
753 };
754 }
755
756 fn statusFromCLAuthorizationStatus(status: i32) PermissionStatus {
757 return switch (status) {
758 0 => .not_determined, // kCLAuthorizationStatusNotDetermined
759 1 => .restricted, // kCLAuthorizationStatusRestricted
760 2 => .denied, // kCLAuthorizationStatusDenied
761 3, 4 => .authorized, // kCLAuthorizationStatusAuthorizedAlways/WhenInUse
762 else => .not_determined,
763 };
764 }
765
766 fn statusFromPHAuthorizationStatus(status: i64) PermissionStatus {
767 return switch (status) {
768 0 => .not_determined,
769 1 => .restricted,
770 2 => .denied,
771 3 => .authorized,
772 4 => .limited, // PHAuthorizationStatusLimited (iOS 14+)
773 else => .not_determined,
774 };
775 }
776
777 fn statusFromCNAuthorizationStatus(status: i64) PermissionStatus {
778 return switch (status) {
779 0 => .not_determined,
780 1 => .restricted,
781 2 => .denied,
782 3 => .authorized,
783 else => .not_determined,
784 };
785 }
786
787 fn statusFromEKAuthorizationStatus(status: i64) PermissionStatus {
788 return switch (status) {
789 0 => .not_determined,
790 1 => .restricted,
791 2 => .denied,
792 3 => .authorized,
793 else => .not_determined,
794 };
795 }
796
797 pub fn requestPermission(permission: Permission, callback: *const fn (bool) void) !void {
798 if (!@import("builtin").target.os.tag.isDarwin()) {
799 return error.UnsupportedPlatform;
800 }
801
802 // Store callback for later invocation (would need proper callback management)
803 _ = callback;
804
805 // Different permission types require different iOS APIs
806 switch (permission) {
807 .camera, .microphone => {
808 const AVCaptureDeviceClass = objc.objc_getClass("AVCaptureDevice") orelse return error.ClassNotFound;
809 const sel_requestAccessForMediaType = objc.sel_registerName("requestAccessForMediaType:completionHandler:") orelse return error.SelectorNotFound;
810
811 // Create media type string
812 const allocator = std.heap.page_allocator;
813 const mediaType = if (permission == .camera) "vide" else "soun";
814 const ns_media = try objc.createNSString(mediaType, allocator);
815
816 // Request access (completion handler would need block creation)
817 const Fn = *const fn (objc.Class, objc.SEL, objc.id, ?*anyopaque) callconv(.c) void;
818 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
819 func(AVCaptureDeviceClass, sel_requestAccessForMediaType, ns_media, null);
820 },
821 .location => {
822 const CLLocationManagerClass = objc.objc_getClass("CLLocationManager") orelse return error.ClassNotFound;
823 const sel_alloc = objc.sel_registerName("alloc") orelse return error.SelectorNotFound;
824 const sel_init = objc.sel_registerName("init") orelse return error.SelectorNotFound;
825 const sel_requestWhenInUseAuthorization = objc.sel_registerName("requestWhenInUseAuthorization") orelse return error.SelectorNotFound;
826
827 // Create location manager and request authorization
828 const allocated = objc.msgSendId(CLLocationManagerClass, sel_alloc);
829 const manager = objc.msgSendId(allocated, sel_init);
830 objc.msgSend(manager, sel_requestWhenInUseAuthorization);
831 },
832 .photos => {
833 const PHPhotoLibraryClass = objc.objc_getClass("PHPhotoLibrary") orelse return error.ClassNotFound;
834 const sel_requestAuthorization = objc.sel_registerName("requestAuthorization:") orelse return error.SelectorNotFound;
835
836 // Request photo library access (completion handler would need block creation)
837 const Fn = *const fn (objc.Class, objc.SEL, ?*anyopaque) callconv(.c) void;
838 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
839 func(PHPhotoLibraryClass, sel_requestAuthorization, null);
840 },
841 .notifications => {
842 const UNUserNotificationCenterClass = objc.objc_getClass("UNUserNotificationCenter") orelse return error.ClassNotFound;
843 const sel_currentNotificationCenter = objc.sel_registerName("currentNotificationCenter") orelse return error.SelectorNotFound;
844 const sel_requestAuthorizationWithOptions = objc.sel_registerName("requestAuthorizationWithOptions:completionHandler:") orelse return error.SelectorNotFound;
845
846 // Get notification center
847 const center = objc.msgSendId(UNUserNotificationCenterClass, sel_currentNotificationCenter);
848
849 // Request authorization with alert, badge, sound (7 = alert | badge | sound)
850 const Fn = *const fn (objc.id, objc.SEL, u64, ?*anyopaque) callconv(.c) void;
851 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
852 func(center, sel_requestAuthorizationWithOptions, 7, null);
853 },
854 .contacts => {
855 const CNContactStoreClass = objc.objc_getClass("CNContactStore") orelse return error.ClassNotFound;
856 const sel_alloc = objc.sel_registerName("alloc") orelse return error.SelectorNotFound;
857 const sel_init = objc.sel_registerName("init") orelse return error.SelectorNotFound;
858 const sel_requestAccessForEntityType = objc.sel_registerName("requestAccessForEntityType:completionHandler:") orelse return error.SelectorNotFound;
859
860 // Create contact store and request access
861 const allocated = objc.msgSendId(CNContactStoreClass, sel_alloc);
862 const store = objc.msgSendId(allocated, sel_init);
863
864 const Fn = *const fn (objc.id, objc.SEL, i64, ?*anyopaque) callconv(.c) void;
865 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
866 func(store, sel_requestAccessForEntityType, 0, null); // CNEntityTypeContacts = 0
867 },
868 .calendar, .reminders => {
869 const EKEventStoreClass = objc.objc_getClass("EKEventStore") orelse return error.ClassNotFound;
870 const sel_alloc = objc.sel_registerName("alloc") orelse return error.SelectorNotFound;
871 const sel_init = objc.sel_registerName("init") orelse return error.SelectorNotFound;
872 const sel_requestAccessToEntityType = objc.sel_registerName("requestAccessToEntityType:completion:") orelse return error.SelectorNotFound;
873
874 // Create event store and request access
875 const allocated = objc.msgSendId(EKEventStoreClass, sel_alloc);
876 const store = objc.msgSendId(allocated, sel_init);
877
878 const entity_type: i64 = if (permission == .calendar) 0 else 1;
879 const Fn = *const fn (objc.id, objc.SEL, i64, ?*anyopaque) callconv(.c) void;
880 const func: Fn = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
881 func(store, sel_requestAccessToEntityType, entity_type, null);
882 },
883 }
884 }
638 // `checkPermissionStatus`, its five `statusFrom*AuthorizationStatus`
639 // mappers, `requestPermission`, and `showAlert` used to sit between these
640 // two enums. The types stay because they are the vocabulary; the functions
641 // went because each was broken in a way no test could have caught, since
642 // nothing ever called them:
643 //
644 // - `requestPermission` took a `callback` and immediately did
645 // `_ = callback;`, then passed null as the completion handler to all
646 // five system calls. Permissions were write-only: the answer was never
647 // delivered to anyone, and Apple documents a null completion for
648 // `requestAccessForMediaType:` as undefined behaviour.
649 // - `checkPermissionStatus` returned `.not_determined` for notifications
650 // unconditionally, whatever the system actually held.
651 // - `showAlert` presented against `keyWindow`, deprecated since iOS 13
652 // and nil in any scene-based app — which is every app the templates
653 // generate. It also computed an auto-dismiss delay and discarded it,
654 // so the alert its own doc comment called self-dismissing never was.
655 //
656 // They return in the permissions phase, replies correlated by the
657 // envelope's request id through a pending-request table rather than by a
658 // callback pointer that nothing invokes.
885659
886660 /// Haptic Feedback
887661 pub const HapticType = enum {
@@ -967,61 +741,6 @@ pub const iOS = struct {
967741 }
968742 }
969743
970 /// Show iOS Alert/Toast
971 /// Uses UIAlertController for simple toast-like alerts
972 pub fn showAlert(message: []const u8, duration_short: bool) void {
973 if (!@import("builtin").target.os.tag.isDarwin()) {
974 return;
975 }
976
977 // Get UIAlertController class
978 const UIAlertControllerClass = objc.objc_getClass("UIAlertController") orelse return;
979
980 // Create alert title NSString (nil for toast-like appearance)
981 const NSStringClass = objc.objc_getClass("NSString") orelse return;
982 const sel_stringWithUTF8String = objc.sel_registerName("stringWithUTF8String:") orelse return;
983
984 // Create message string
985 const allocator = std.heap.page_allocator;
986 const msg_z = @import("memory.zig").dupeZ(allocator, u8, message) catch return;
987 defer allocator.free(msg_z);
988
989 const Fn1 = *const fn (objc.id, objc.SEL, [*:0]const u8) callconv(.c) objc.id;
990 const stringFn: Fn1 = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
991 const messageStr = stringFn(NSStringClass, sel_stringWithUTF8String, msg_z.ptr);
992
993 // Create UIAlertController with style Alert (1)
994 const sel_alertWithTitle = objc.sel_registerName("alertControllerWithTitle:message:preferredStyle:") orelse return;
995 const Fn2 = *const fn (objc.id, objc.SEL, ?objc.id, objc.id, i64) callconv(.c) objc.id;
996 const alertFn: Fn2 = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
997 const alert = alertFn(UIAlertControllerClass, sel_alertWithTitle, null, messageStr, 1); // UIAlertControllerStyleAlert = 1
998
999 // Get the key window and root view controller
1000 const UIApplicationClass = objc.objc_getClass("UIApplication") orelse return;
1001 const sel_sharedApplication = objc.sel_registerName("sharedApplication") orelse return;
1002 const app = objc.msgSendId(UIApplicationClass, sel_sharedApplication);
1003
1004 const sel_keyWindow = objc.sel_registerName("keyWindow") orelse return;
1005 const window = objc.msgSendId(app, sel_keyWindow);
1006 if (window == null) return;
1007
1008 const sel_rootViewController = objc.sel_registerName("rootViewController") orelse return;
1009 const rootVC = objc.msgSendId(window, sel_rootViewController);
1010 if (rootVC == null) return;
1011
1012 // Present the alert
1013 const sel_presentViewController = objc.sel_registerName("presentViewController:animated:completion:") orelse return;
1014 const Fn3 = *const fn (objc.id, objc.SEL, objc.id, bool, ?objc.id) callconv(.c) void;
1015 const presentFn: Fn3 = @ptrCast(&@import("objc_runtime.zig").objc.objc_msgSend);
1016 presentFn(rootVC, sel_presentViewController, alert, true, null);
1017
1018 // Auto-dismiss after delay using dispatch_after
1019 const delay_seconds: f64 = if (duration_short) 2.0 else 3.5;
1020 _ = delay_seconds;
1021
1022 // For simplicity, just present the alert - user can tap away
1023 // In production, would use dispatch_after to dismiss automatically
1024 }
1025744};
1026745
1027746/// Android Native Integration
packages/zig/src/objc_runtime.zigmodified+23-2
Changes to packages/zig/src/objc_runtime.zig
@@ -15,6 +15,7 @@ pub const objc = if (is_darwin) struct {
1515 pub extern "c" fn class_addMethod(cls: ?*anyopaque, name: ?*anyopaque, imp: *const anyopaque, types: [*:0]const u8) bool;
1616 pub extern "c" fn object_getClass(obj: ?*anyopaque) ?*anyopaque;
1717 pub extern "c" fn class_createInstance(cls: ?*anyopaque, extraBytes: usize) ?*anyopaque;
18 pub extern "c" fn class_getInstanceSize(cls: ?*anyopaque) usize;
1819 pub extern "c" fn objc_setAssociatedObject(obj: ?*anyopaque, key: ?*const anyopaque, value: ?*anyopaque, policy: c_uint) void;
1920 pub extern "c" fn objc_getAssociatedObject(obj: ?*anyopaque, key: ?*const anyopaque) ?*anyopaque;
2021 pub extern "c" fn objc_removeAssociatedObjects(obj: ?*anyopaque) void;
@@ -149,6 +150,26 @@ pub const objc = if (is_darwin) struct {
149150 return msgSendId1(NSURLClass, sel, ns_string);
150151 }
151152
153 /// How many bytes an instance of `class` occupies, as the runtime reports
154 /// it. Useful for memory accounting, where `@sizeOf` on a Zig `opaque{}`
155 /// handle would report zero and `@sizeOf(@TypeOf(ptr))` the width of a
156 /// pointer.
157 pub fn classInstanceSize(class: Class) usize {
158 return class_getInstanceSize(@ptrCast(class));
159 }
160
161 /// Allocate an instance without initialising it.
162 ///
163 /// Separate from `allocInit` because a caller that has its own designated
164 /// initialiser — `initWithFrame:`, `initWithFrame:configuration:` — must
165 /// not have `init` sent first. `ios.zig` needs exactly this half, and
166 /// `mobile.zig` open-coded it rather than reach for a helper that did too
167 /// much.
168 pub fn alloc(class: Class) !id {
169 const sel_alloc = sel_registerName("alloc") orelse return error.SelectorNotFound;
170 return msgSendId(class, sel_alloc);
171 }
172
152173 /// Helper to alloc and init an object
153174 pub fn allocInit(class: Class) !id {
154175 const sel_alloc = sel_registerName("alloc") orelse return error.SelectorNotFound;
@@ -179,7 +200,7 @@ pub const objc = if (is_darwin) struct {
179200
180201// Tests
181202test "NSString creation" {
182 if (!@import("builtin").target.isDarwin()) return error.SkipZigTest;
203 if (!@import("builtin").target.os.tag.isDarwin()) return error.SkipZigTest;
183204
184205 const allocator = std.testing.allocator;
185206 const ns_string = try objc.createNSString("Hello, World!", allocator);
@@ -190,7 +211,7 @@ test "NSString creation" {
190211}
191212
192213test "NSURL creation" {
193 if (!@import("builtin").target.isDarwin()) return error.SkipZigTest;
214 if (!@import("builtin").target.os.tag.isDarwin()) return error.SkipZigTest;
194215
195216 const allocator = std.testing.allocator;
196217 const ns_url = try objc.createNSURL("https://example.com", allocator);
packages/zig/test/ios_surface_test.zigadded+86-0
Changes to packages/zig/test/ios_surface_test.zig
@@ -0,0 +1,86 @@
1const std = @import("std");
2const ios = @import("../src/ios.zig");
3
4// `std.testing.refAllDeclsRecursive` is gone in 0.17 — only the shallow
5// `refAllDecls` survives, and shallow is not enough here. Everything that
6// matters on the iOS surface lives one level down, inside `CraftAppDelegate`,
7// so a top-level-only sweep would walk straight past the code that broke.
8//
9// `decl_names` reports only public declarations, which is what keeps this from
10// recursing forever on the `const Self = @This();` that most of these structs
11// carry.
12fn refAllDeclsRecursive(comptime T: type) void {
13 if (!@import("builtin").is_test) return;
14 inline for (comptime std.meta.declarations(T)) |decl_name| {
15 if (@TypeOf(@field(T, decl_name)) == type) {
16 switch (@typeInfo(@field(T, decl_name))) {
17 .@"struct", .@"enum", .@"union", .@"opaque" => refAllDeclsRecursive(@field(T, decl_name)),
18 else => {},
19 }
20 }
21 _ = &@field(T, decl_name);
22 }
23}
24
25// iOS compiled for nobody, for three months, and the test suite stayed green.
26//
27// The reason is worth stating, because it is the whole point of this file.
28// Zig analyses function bodies lazily: a declaration nothing references is
29// never checked. `test/mobile_test.zig` touches enums and struct literals —
30// `HapticType.selection`, an `AppConfig{...}` — and never calls a function
31// that reaches the Objective-C runtime. So `zig build test` passed while
32// `zig build build-ios-simulator` failed with nine errors, and neither
33// result contradicted the other.
34//
35// `refAllDeclsRecursive` forces analysis of every declaration reachable from
36// the root. That turns "does iOS compile" into a host build that takes
37// seconds, instead of a cross-compilation nobody runs locally.
38//
39// Cross-compiling remains the source of truth — this cannot catch a target
40// specific ABI problem, and two of the nine original errors were exactly
41// that. It catches the other seven, and it catches them in the loop you are
42// already running.
43test "every declaration reachable from ios.zig compiles" {
44 refAllDeclsRecursive(ios);
45}
46
47// `CraftAppDelegate.run` is the startup path, and every private helper that
48// survives into the real one is reachable only through it. Referencing the
49// type explicitly means a helper cannot be quietly orphaned — dropped from
50// `run` and left to rot uncompiled — without this failing.
51test "the app delegate and its startup helpers compile" {
52 refAllDeclsRecursive(ios.CraftAppDelegate);
53}
54
55// Not a smoke test — an assertion about honesty.
56//
57// `run()` cannot start an iOS app yet: UIKit owns the run loop and only hands
58// it over through `UIApplicationMain`, which this file does not yet call. The
59// previous version spun a bare `NSRunLoop` and returned no error, so a caller
60// could not tell "running" apart from "did nothing".
61//
62// What this pins is only that: **it must not report success.** The specific
63// error is deliberately not asserted, because which one comes back depends on
64// where the host gives out. Running on macOS, `createWindow` fails first —
65// `objc_getClass("UIScreen")` is null, since UIScreen is UIKit and this is
66// AppKit's platform — so the error is `ClassNotFound`, not the
67// `RunLoopNotImplemented` at the end of the function. Pinning the exact tag
68// would be pinning the host, not the property.
69//
70// When `UIApplicationMain` lands, this test should be revisited rather than
71// deleted: the property it protects — that a startup path which did not start
72// anything says so — is the one that failed here for three months.
73test "run never reports success while it cannot start an app" {
74 if (!@import("builtin").target.os.tag.isDarwin()) return error.SkipZigTest;
75
76 var app = ios.CraftAppDelegate.init(std.testing.allocator, .{
77 .name = "Surface Test",
78 .initial_content = .{ .html = "<h1>hi</h1>" },
79 });
80
81 if (app.run()) |_| {
82 return error.RunClaimedSuccessWithoutStartingAnApp;
83 } else |_| {
84 // Any error is correct. Silence is not.
85 }
86}