craft-native 0.0.89 → 0.0.91

package/dist/android/templates/CraftBridge.kt.template

@@ -18,12 +18,17 @@ import android.net.NetworkCapabilities
 import android.net.NetworkRequest
 import android.net.Uri
 import android.os.Build
+import com.craft.runtime.CraftNative
+import com.craft.runtime.CraftLocationRecordingStore
+import com.craft.runtime.LocationRecordingService
 import android.os.Bundle
+import android.os.Handler
 import android.os.Looper
 import android.os.VibrationEffect
 import android.os.Vibrator
 import android.os.VibratorManager
 import android.provider.MediaStore
+import android.provider.OpenableColumns
 import android.provider.Settings
 import android.speech.RecognitionListener
 import android.speech.RecognizerIntent
@@ -34,7 +39,6 @@ import android.webkit.WebView
 import androidx.biometric.BiometricManager
 import androidx.biometric.BiometricPrompt
 import androidx.core.app.ActivityCompat
-import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.ContextCompat
 import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.Lifecycle
@@ -48,6 +52,8 @@ import com.google.android.gms.location.LocationRequest
 import com.google.android.gms.location.LocationResult
 import com.google.android.gms.location.LocationServices
 import com.google.android.gms.location.Priority
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
 import com.google.android.play.core.review.ReviewManagerFactory
 {{FIREBASE_IMPORT}}
 import android.content.ContentResolver
@@ -98,19 +104,130 @@ import java.io.File
 import java.util.concurrent.TimeUnit
 import java.util.UUID
 
+internal object CraftPermissionPolicy {
+    data class Request(
+        val groupIndex: Int,
+        val permissions: Array<String>
+    )
+
+    private fun permissionGroups(name: String, sdkInt: Int): List<List<String>>? = when (name) {
+        "camera" -> listOf(listOf(Manifest.permission.CAMERA))
+        "microphone" -> listOf(listOf(Manifest.permission.RECORD_AUDIO))
+        "photos" -> listOf(listOf(
+            if (sdkInt >= Build.VERSION_CODES.TIRAMISU) {
+                Manifest.permission.READ_MEDIA_IMAGES
+            } else {
+                Manifest.permission.READ_EXTERNAL_STORAGE
+            }
+        ))
+        // Android presents precise and approximate location as one choice. A
+        // coarse grant is usable foreground location access even when the
+        // corresponding fine result is denied.
+        "location" -> listOf(listOf(
+            Manifest.permission.ACCESS_FINE_LOCATION,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        ))
+        "locationAlways" -> if (sdkInt >= Build.VERSION_CODES.Q) {
+            listOf(
+                listOf(
+                    Manifest.permission.ACCESS_FINE_LOCATION,
+                    Manifest.permission.ACCESS_COARSE_LOCATION
+                ),
+                listOf(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+            )
+        } else {
+            listOf(listOf(
+                Manifest.permission.ACCESS_FINE_LOCATION,
+                Manifest.permission.ACCESS_COARSE_LOCATION
+            ))
+        }
+        "notifications" -> if (sdkInt >= Build.VERSION_CODES.TIRAMISU) {
+            listOf(listOf(Manifest.permission.POST_NOTIFICATIONS))
+        } else {
+            emptyList()
+        }
+        "contacts" -> listOf(listOf(Manifest.permission.READ_CONTACTS))
+        "calendar" -> listOf(listOf(Manifest.permission.READ_CALENDAR))
+        "bluetooth" -> if (sdkInt >= Build.VERSION_CODES.S) {
+            listOf(listOf(Manifest.permission.BLUETOOTH_SCAN))
+        } else {
+            emptyList()
+        }
+        "motion" -> if (sdkInt >= Build.VERSION_CODES.Q) {
+            listOf(listOf(Manifest.permission.ACTIVITY_RECOGNITION))
+        } else {
+            emptyList()
+        }
+        else -> null
+    }
+
+    fun requiredPermissions(name: String, sdkInt: Int): Array<String>? =
+        permissionGroups(name, sdkInt)?.flatten()?.distinct()?.toTypedArray()
+
+    fun status(name: String, sdkInt: Int, isGranted: (String) -> Boolean): String {
+        val groups = permissionGroups(name, sdkInt) ?: return "undetermined"
+        return if (groups.all { group -> group.any(isGranted) }) "granted" else "denied"
+    }
+
+    fun nextRequest(
+        name: String,
+        sdkInt: Int,
+        startingAt: Int,
+        isGranted: (String) -> Boolean
+    ): Request? {
+        val groups = permissionGroups(name, sdkInt) ?: return null
+        val groupIndex = (startingAt until groups.size).firstOrNull { index ->
+            groups[index].none(isGranted)
+        } ?: return null
+        return Request(groupIndex, groups[groupIndex].toTypedArray())
+    }
+
+    fun groupIsGranted(
+        name: String,
+        sdkInt: Int,
+        groupIndex: Int,
+        isGranted: (String) -> Boolean
+    ): Boolean = permissionGroups(name, sdkInt)
+        ?.getOrNull(groupIndex)
+        ?.any(isGranted) == true
+
+    fun foregroundLocationIsGranted(isGranted: (String) -> Boolean): Boolean =
+        isGranted(Manifest.permission.ACCESS_FINE_LOCATION) ||
+            isGranted(Manifest.permission.ACCESS_COARSE_LOCATION)
+}
+
+private data class PendingPermissionRequest(
+    val callbackId: Int,
+    val permission: String,
+    val groupIndex: Int
+)
+
 class CraftBridge(
     private val activity: Activity,
     private val webView: WebView,
     private val healthConnect: CraftHealthConnect
 ) {
+    @Volatile
+    private var closed = false
+    private var nativeDeepLinks = CraftNative.resetDeepLinks()
     private var speechRecognizer: SpeechRecognizer? = null
+    private var biometricPrompt: BiometricPrompt? = null
     private var isListening = false
     private val mainExecutor: Executor = ContextCompat.getMainExecutor(activity)
+    @Volatile
+    private var bridgeReady = false
+    private val pendingEvents = mutableListOf<Pair<String, Map<String, Any>>>()
 
     // Location tracking
     private var fusedLocationClient: FusedLocationProviderClient? = null
-    private var locationCallback: LocationCallback? = null
+    private val locationCallbacks = mutableMapOf<Int, LocationCallback>()
+    private val oneShotLocationCallbacks = mutableSetOf<LocationCallback>()
+    private val oneShotLocationHandler = Handler(Looper.getMainLooper())
+    private val oneShotLocationTimeouts = mutableMapOf<LocationCallback, Runnable>()
+    private val currentPositionSequence = java.util.concurrent.atomic.AtomicLong(0)
     private var watchId = 0
+    private val pendingPermissionRequests = mutableMapOf<Int, PendingPermissionRequest>()
+    private var nextPermissionRequestCode = PERMISSION_REQUEST_START
 
     // Network monitoring
     private var networkCallback: ConnectivityManager.NetworkCallback? = null
@@ -124,8 +241,9 @@ class CraftBridge(
     // Keep awake
     private var isKeepingAwake = false
 
-    // Billing client for in-app purchases
-    private var billingClient: BillingClient? = null
+    // Billing clients for in-app purchases
+    private var productBillingClient: BillingClient? = null
+    private var restoreBillingClient: BillingClient? = null
 
     // Notification channel ID
     private val notificationChannelId = "craft_notifications"
@@ -165,8 +283,33 @@ class CraftBridge(
         )
     }
 
+    /**
+     * Quote a value for interpolation into JavaScript.
+     *
+     * The result carries its own quotes, so write `f($payload)` — leaving the
+     * surrounding `'...'` in place would quote it twice.
+     *
+     * Without this, a value containing an apostrophe ends the JS string early, the
+     * script fails to parse, and `evaluateJavascript` runs nothing at all — so a
+     * hand-built promise with no timeout never settles.
+     *
+     * `Any?` rather than `String?`, because these call sites replaced string
+     * interpolation and interpolation accepts anything: `contactId` is the `Long`
+     * from `ContentUris.parseId`, `downloadId` the `Long` from
+     * `DownloadManager.enqueue`, and `errString` the `CharSequence` a
+     * `BiometricPrompt` error arrives as. `Any?.toString()` is exactly what `$x`
+     * did, null included — it renders as the string "null", the way it always has.
+     */
+    private fun jsQuote(value: Any?): String = JSONObject.quote(value.toString())
+
     fun injectBridge() {
+        // Before the script, so a native callback arriving while the page is
+        // still loading has somewhere to go rather than being counted as
+        // dropped.
+        installNativeDeliverer()
+
         val script = """
+{{PROMISE_RUNTIME}}
             window.craft = {
                 platform: 'android',
                 capabilities: {
@@ -181,7 +324,7 @@ class CraftBridge(
                     backgroundLocation: {{ENABLE_BACKGROUND_LOCATION}},
                     clipboard: false,
                     deviceInfo: true,
-                    appBadge: {{ENABLE_PUSH}},
+                    appBadge: false,
                     networkStatus: true,
                     appReview: true,
                     flashlight: {{ENABLE_CAMERA}} && ${hasFlashlight()},
@@ -229,34 +372,26 @@ class CraftBridge(
 
                 // Camera
                 openCamera: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftCameraResolve = resolve;
-                        window._craftCameraReject = reject;
+                    return window.__craftPromise('camera', '_craftCameraResolve', '_craftCameraReject', function() {
                         CraftAndroid.openCamera();
                     });
                 },
                 pickImage: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftGalleryResolve = resolve;
-                        window._craftGalleryReject = reject;
+                    return window.__craftPromise('gallery', '_craftGalleryResolve', '_craftGalleryReject', function() {
                         CraftAndroid.pickImage();
                     });
                 },
 
                 // Biometric auth
                 authenticate: function(reason) {
-                    return new Promise(function(resolve, reject) {
-                        window._craftBiometricResolve = resolve;
-                        window._craftBiometricReject = reject;
+                    return window.__craftPromise('biometric', '_craftBiometricResolve', '_craftBiometricReject', function() {
                         CraftAndroid.authenticate(reason || 'Authenticate to continue');
                     });
                 },
 
                 // Push notifications
                 registerPush: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftPushResolve = resolve;
-                        window._craftPushReject = reject;
+                    return window.__craftPromise('push registration', '_craftPushResolve', '_craftPushReject', function() {
                         CraftAndroid.registerPush();
                     });
                 },
@@ -276,11 +411,14 @@ class CraftBridge(
 
                 // Geolocation
                 getCurrentPosition: function(options) {
-                    return new Promise(function(resolve, reject) {
-                        window._craftLocationResolve = resolve;
-                        window._craftLocationReject = reject;
-                        CraftAndroid.getCurrentPosition(JSON.stringify(options || {}));
-                    });
+                    return window.__craftPromise(
+                        'location',
+                        '_craftLocationResolve',
+                        '_craftLocationReject',
+                        function() { CraftAndroid.getCurrentPosition(JSON.stringify(options || {})); },
+                        15000,
+                        {code: 2, message: 'Location request timed out; Google Play Services or a location provider may be unavailable'}
+                    );
                 },
                 watchPosition: function(callback, options) {
                     var watchId = CraftAndroid.watchPosition(JSON.stringify(options || {}));
@@ -312,11 +450,11 @@ class CraftBridge(
                 },
 
                 // App Badge
-                setBadge: function(count) {
-                    CraftAndroid.setBadge(count);
+                setBadge: function() {
+                    throw new Error('App badges are unavailable on Android');
                 },
                 clearBadge: function() {
-                    CraftAndroid.clearBadge();
+                    throw new Error('App badges are unavailable on Android');
                 },
 
                 // Network Status
@@ -334,9 +472,7 @@ class CraftBridge(
 
                 // App Review
                 requestReview: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftReviewResolve = resolve;
-                        window._craftReviewReject = reject;
+                    return window.__craftPromise('app review', '_craftReviewResolve', '_craftReviewReject', function() {
                         CraftAndroid.requestReview();
                     });
                 },
@@ -375,16 +511,12 @@ class CraftBridge(
                 // Contacts
                 contacts: {
                     getAll: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftContactsResolve = resolve;
-                            window._craftContactsReject = reject;
+                        return window.__craftPromise('contacts read', '_craftContactsResolve', '_craftContactsReject', function() {
                             CraftAndroid.getContacts();
                         });
                     },
                     add: function(contact) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftAddContactResolve = resolve;
-                            window._craftAddContactReject = reject;
+                        return window.__craftPromise('contact write', '_craftAddContactResolve', '_craftAddContactReject', function() {
                             CraftAndroid.addContact(JSON.stringify(contact));
                         });
                     }
@@ -393,23 +525,17 @@ class CraftBridge(
                 // Calendar
                 calendar: {
                     getEvents: function(startDate, endDate) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftCalendarResolve = resolve;
-                            window._craftCalendarReject = reject;
+                        return window.__craftPromise('calendar read', '_craftCalendarResolve', '_craftCalendarReject', function() {
                             CraftAndroid.getCalendarEvents(startDate || 0, endDate || 0);
                         });
                     },
                     createEvent: function(event) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftCreateEventResolve = resolve;
-                            window._craftCreateEventReject = reject;
+                        return window.__craftPromise('calendar create', '_craftCreateEventResolve', '_craftCreateEventReject', function() {
                             CraftAndroid.createCalendarEvent(JSON.stringify(event));
                         });
                     },
                     deleteEvent: function(eventId) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftDeleteEventResolve = resolve;
-                            window._craftDeleteEventReject = reject;
+                        return window.__craftPromise('calendar delete', '_craftDeleteEventResolve', '_craftDeleteEventReject', function() {
                             CraftAndroid.deleteCalendarEvent(eventId);
                         });
                     }
@@ -418,9 +544,7 @@ class CraftBridge(
                 // Local Notifications
                 notifications: {
                     schedule: function(notification) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftNotifResolve = resolve;
-                            window._craftNotifReject = reject;
+                        return window.__craftPromise('notification schedule', '_craftNotifResolve', '_craftNotifReject', function() {
                             CraftAndroid.scheduleNotification(JSON.stringify(notification));
                         });
                     },
@@ -435,23 +559,17 @@ class CraftBridge(
                 // In-App Purchase
                 iap: {
                     getProducts: function(productIds) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftProductsResolve = resolve;
-                            window._craftProductsReject = reject;
+                        return window.__craftPromise('products', '_craftProductsResolve', '_craftProductsReject', function() {
                             CraftAndroid.getProducts(JSON.stringify(productIds));
                         });
                     },
                     purchase: function(productId) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftPurchaseResolve = resolve;
-                            window._craftPurchaseReject = reject;
+                        return window.__craftPromise('purchase', '_craftPurchaseResolve', '_craftPurchaseReject', function() {
                             CraftAndroid.purchase(productId);
                         });
                     },
                     restore: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftRestoreResolve = resolve;
-                            window._craftRestoreReject = reject;
+                        return window.__craftPromise('purchase restore', '_craftRestoreResolve', '_craftRestoreReject', function() {
                             CraftAndroid.restorePurchases();
                         });
                     }
@@ -477,68 +595,52 @@ class CraftBridge(
 
                 // QR/Barcode Scanner
                 scanQRCode: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftQRResolve = resolve;
-                        window._craftQRReject = reject;
+                    return window.__craftPromise('QR scan', '_craftQRResolve', '_craftQRReject', function() {
                         CraftAndroid.scanQRCode();
                     });
                 },
 
                 // File Picker
                 pickFile: function(types) {
-                    return new Promise(function(resolve, reject) {
-                        window._craftFileResolve = resolve;
-                        window._craftFileReject = reject;
+                    return window.__craftPromise('file picker', '_craftFileResolve', '_craftFileReject', function() {
                         CraftAndroid.pickFile(JSON.stringify(types || []));
                     });
                 },
 
                 // File Download
                 downloadFile: function(url, filename) {
-                    return new Promise(function(resolve, reject) {
-                        window._craftDownloadResolve = resolve;
-                        window._craftDownloadReject = reject;
+                    return window.__craftPromise('file download', '_craftDownloadResolve', '_craftDownloadReject', function() {
                         CraftAndroid.downloadFile(url, filename);
                     });
                 },
                 saveFile: function(data, filename) {
-                    return new Promise(function(resolve, reject) {
-                        window._craftSaveResolve = resolve;
-                        window._craftSaveReject = reject;
+                    return window.__craftPromise('file save', '_craftSaveResolve', '_craftSaveReject', function() {
                         CraftAndroid.saveFile(data, filename);
                     });
                 },
 
                 // Google Sign In
                 signInWithGoogle: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftGoogleResolve = resolve;
-                        window._craftGoogleReject = reject;
+                    return window.__craftPromise('Google sign in', '_craftGoogleResolve', '_craftGoogleReject', function() {
                         CraftAndroid.signInWithGoogle();
                     });
                 },
 
                 // Audio Recording
                 startAudioRecording: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftAudioResolve = resolve;
-                        window._craftAudioReject = reject;
+                    return window.__craftPromise('audio start', '_craftAudioResolve', '_craftAudioReject', function() {
                         CraftAndroid.startAudioRecording();
                     });
                 },
                 stopAudioRecording: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftAudioStopResolve = resolve;
-                        window._craftAudioStopReject = reject;
+                    return window.__craftPromise('audio stop', '_craftAudioStopResolve', '_craftAudioStopReject', function() {
                         CraftAndroid.stopAudioRecording();
                     });
                 },
 
                 // Video Recording
                 startVideoRecording: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftVideoResolve = resolve;
-                        window._craftVideoReject = reject;
+                    return window.__craftPromise('video recording', '_craftVideoResolve', '_craftVideoReject', function() {
                         CraftAndroid.startVideoRecording();
                     });
                 },
@@ -557,16 +659,12 @@ class CraftBridge(
                 // Local Database
                 db: {
                     execute: function(sql, params) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftDbExecResolve = resolve;
-                            window._craftDbExecReject = reject;
+                        return window.__craftPromise('database execute', '_craftDbExecResolve', '_craftDbExecReject', function() {
                             CraftAndroid.dbExecute(sql, JSON.stringify(params || []));
                         });
                     },
                     query: function(sql, params) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftDbQueryResolve = resolve;
-                            window._craftDbQueryReject = reject;
+                        return window.__craftPromise('database query', '_craftDbQueryResolve', '_craftDbQueryReject', function() {
                             CraftAndroid.dbQuery(sql, JSON.stringify(params || []));
                         });
                     }
@@ -575,9 +673,7 @@ class CraftBridge(
                 // Bluetooth
                 bluetooth: {
                     startScan: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftBleResolve = resolve;
-                            window._craftBleReject = reject;
+                        return window.__craftPromise('Bluetooth scan', '_craftBleResolve', '_craftBleReject', function() {
                             CraftAndroid.startBluetoothScan();
                         });
                     },
@@ -591,9 +687,7 @@ class CraftBridge(
 
                 // NFC
                 scanNFC: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftNfcResolve = resolve;
-                        window._craftNfcReject = reject;
+                    return window.__craftPromise('NFC scan', '_craftNfcResolve', '_craftNfcReject', function() {
                         CraftAndroid.scanNFC();
                     });
                 },
@@ -601,34 +695,91 @@ class CraftBridge(
                 // Fitness / Health
                 health: {
                     requestAuthorization: function(types) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftFitnessAuthResolve = resolve;
-                            window._craftFitnessAuthReject = reject;
+                        return window.__craftPromise('health authorization', '_craftFitnessAuthResolve', '_craftFitnessAuthReject', function() {
                             CraftAndroid.requestFitnessAuthorization(JSON.stringify(types || []));
                         });
                     },
                     getData: function(type, options) {
                         options = options || {};
-                        return new Promise(function(resolve, reject) {
-                            window._craftFitnessDataResolve = resolve;
-                            window._craftFitnessDataReject = reject;
+                        return window.__craftPromise('health read', '_craftFitnessDataResolve', '_craftFitnessDataReject', function() {
                             CraftAndroid.getFitnessData(type, options.startDate || 0, options.endDate || 0);
                         });
                     },
                     saveWorkout: function(workout) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftFitnessSaveResolve = resolve;
-                            window._craftFitnessSaveReject = reject;
+                        return window.__craftPromise('health write', '_craftFitnessSaveResolve', '_craftFitnessSaveReject', function() {
                             CraftAndroid.saveHealthWorkout(JSON.stringify(workout || {}));
                         });
                     }
                 },
 
+                // Flat SDK compatibility methods. Delegate to the namespaced
+                // bridge where Android implements the capability, and reject
+                // explicitly for APIs that are intentionally iOS-only.
+                getContacts: function() {
+                    return window.craft.contacts.getAll();
+                },
+                addContact: function(contact) {
+                    return window.craft.contacts.add(contact);
+                },
+                getCalendarEvents: function(startDate, endDate) {
+                    return window.craft.calendar.getEvents(startDate, endDate);
+                },
+                createCalendarEvent: function(event) {
+                    return window.craft.calendar.createEvent(event);
+                },
+                deleteCalendarEvent: function(eventId) {
+                    return window.craft.calendar.deleteEvent(eventId);
+                },
+                scheduleNotification: function(notification) {
+                    return window.craft.notifications.schedule(notification);
+                },
+                cancelNotification: function(id) {
+                    return Promise.resolve().then(function() { return window.craft.notifications.cancel(id); });
+                },
+                cancelAllNotifications: function() {
+                    return Promise.resolve().then(function() { return window.craft.notifications.cancelAll(); });
+                },
+                getPendingNotifications: function() {
+                    return Promise.reject(new Error('Pending notification queries are unavailable on Android'));
+                },
+                getProducts: function(productIds) {
+                    return window.craft.iap.getProducts(productIds);
+                },
+                purchase: function(productId) {
+                    return window.craft.iap.purchase(productId);
+                },
+                restorePurchases: function() {
+                    return window.craft.iap.restore();
+                },
+                signInWithApple: function() {
+                    return Promise.reject(new Error('Sign in with Apple is unavailable on Android'));
+                },
+                startBluetoothScan: function() {
+                    return window.craft.bluetooth.startScan();
+                },
+                stopBluetoothScan: function() {
+                    return Promise.resolve().then(function() { return window.craft.bluetooth.stopScan(); });
+                },
+                requestHealthAuthorization: function() {
+                    return Promise.reject(new Error('HealthKit is unavailable on Android'));
+                },
+                getHealthData: function() {
+                    return Promise.reject(new Error('HealthKit is unavailable on Android'));
+                },
+                requestFitnessAuthorization: function(types) {
+                    return window.craft.health.requestAuthorization(types || [
+                        'steps', 'heartRate', 'activeEnergy', 'distance', 'workouts'
+                    ]);
+                },
+                getFitnessData: function(type, startDate, endDate) {
+                    var start = startDate instanceof Date ? startDate.getTime() : startDate;
+                    var end = endDate instanceof Date ? endDate.getTime() : endDate;
+                    return window.craft.health.getData(type, {startDate: start, endDate: end});
+                },
+
                 // Screen Capture
                 takeScreenshot: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftScreenshotResolve = resolve;
-                        window._craftScreenshotReject = reject;
+                    return window.__craftPromise('screenshot', '_craftScreenshotResolve', '_craftScreenshotReject', function() {
                         CraftAndroid.takeScreenshot();
                     });
                 },
@@ -636,17 +787,13 @@ class CraftBridge(
                 // Background Tasks
                 backgroundTask: {
                     register: function(taskId) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftBgTaskResolve = resolve;
-                            window._craftBgTaskReject = reject;
+                        return window.__craftPromise('background task', '_craftBgTaskResolve', '_craftBgTaskReject', function() {
                             CraftAndroid.registerBackgroundTask(taskId);
                         });
                     },
                     schedule: function(taskId, options) {
                         options = options || {};
-                        return new Promise(function(resolve, reject) {
-                            window._craftBgTaskResolve = resolve;
-                            window._craftBgTaskReject = reject;
+                        return window.__craftPromise('background task', '_craftBgTaskResolve', '_craftBgTaskReject', function() {
                             CraftAndroid.scheduleBackgroundTask(
                                 taskId,
                                 options.delay || 900,
@@ -656,16 +803,12 @@ class CraftBridge(
                         });
                     },
                     cancel: function(taskId) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftBgTaskResolve = resolve;
-                            window._craftBgTaskReject = reject;
+                        return window.__craftPromise('background task', '_craftBgTaskResolve', '_craftBgTaskReject', function() {
                             CraftAndroid.cancelBackgroundTask(taskId);
                         });
                     },
                     cancelAll: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftBgTaskResolve = resolve;
-                            window._craftBgTaskReject = reject;
+                        return window.__craftPromise('background task', '_craftBgTaskResolve', '_craftBgTaskReject', function() {
                             CraftAndroid.cancelAllBackgroundTasks();
                         });
                     }
@@ -673,16 +816,12 @@ class CraftBridge(
 
                 // PDF Viewer
                 openPDF: function(source, page) {
-                    return new Promise(function(resolve, reject) {
-                        window._craftPDFResolve = resolve;
-                        window._craftPDFReject = reject;
+                    return window.__craftPromise('PDF', '_craftPDFResolve', '_craftPDFReject', function() {
                         CraftAndroid.openPDF(source, page || 0);
                     });
                 },
                 closePDF: function() {
-                    return new Promise(function(resolve, reject) {
-                        window._craftPDFResolve = resolve;
-                        window._craftPDFReject = reject;
+                    return window.__craftPromise('PDF', '_craftPDFResolve', '_craftPDFReject', function() {
                         CraftAndroid.closePDF();
                     });
                 },
@@ -690,9 +829,7 @@ class CraftBridge(
                 // Contacts Picker
                 pickContact: function(options) {
                     options = options || {};
-                    return new Promise(function(resolve, reject) {
-                        window._craftPickContactResolve = resolve;
-                        window._craftPickContactReject = reject;
+                    return window.__craftPromise('contact picker', '_craftPickContactResolve', '_craftPickContactReject', function() {
                         CraftAndroid.pickContact(options.multiple || false);
                     });
                 },
@@ -700,16 +837,12 @@ class CraftBridge(
                 // App Shortcuts
                 shortcuts: {
                     set: function(shortcuts) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftShortcutsResolve = resolve;
-                            window._craftShortcutsReject = reject;
+                        return window.__craftPromise('shortcuts', '_craftShortcutsResolve', '_craftShortcutsReject', function() {
                             CraftAndroid.setShortcuts(JSON.stringify(shortcuts));
                         });
                     },
                     clear: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftShortcutsResolve = resolve;
-                            window._craftShortcutsReject = reject;
+                        return window.__craftPromise('shortcuts', '_craftShortcutsResolve', '_craftShortcutsReject', function() {
                             CraftAndroid.clearShortcuts();
                         });
                     },
@@ -721,23 +854,17 @@ class CraftBridge(
                 // Shared Preferences (Android equivalent of Keychain Sharing)
                 sharedKeychain: {
                     set: function(key, value, group) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftSharedKeychainResolve = resolve;
-                            window._craftSharedKeychainReject = reject;
+                        return window.__craftPromise('shared keychain', '_craftSharedKeychainResolve', '_craftSharedKeychainReject', function() {
                             CraftAndroid.setSharedItem(key, value, group || '');
                         });
                     },
                     get: function(key, group) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftSharedKeychainResolve = resolve;
-                            window._craftSharedKeychainReject = reject;
+                        return window.__craftPromise('shared keychain', '_craftSharedKeychainResolve', '_craftSharedKeychainReject', function() {
                             CraftAndroid.getSharedItem(key, group || '');
                         });
                     },
                     remove: function(key, group) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftSharedKeychainResolve = resolve;
-                            window._craftSharedKeychainReject = reject;
+                        return window.__craftPromise('shared keychain', '_craftSharedKeychainResolve', '_craftSharedKeychainReject', function() {
                             CraftAndroid.removeSharedItem(key, group || '');
                         });
                     }
@@ -746,30 +873,22 @@ class CraftBridge(
                 // Local Auth Persistence
                 authPersistence: {
                     enable: function(duration) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftAuthPersistResolve = resolve;
-                            window._craftAuthPersistReject = reject;
+                        return window.__craftPromise('auth persistence', '_craftAuthPersistResolve', '_craftAuthPersistReject', function() {
                             CraftAndroid.setAuthPersistence(true, duration || 300);
                         });
                     },
                     disable: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftAuthPersistResolve = resolve;
-                            window._craftAuthPersistReject = reject;
+                        return window.__craftPromise('auth persistence', '_craftAuthPersistResolve', '_craftAuthPersistReject', function() {
                             CraftAndroid.setAuthPersistence(false, 0);
                         });
                     },
                     check: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftAuthPersistResolve = resolve;
-                            window._craftAuthPersistReject = reject;
+                        return window.__craftPromise('auth persistence', '_craftAuthPersistResolve', '_craftAuthPersistReject', function() {
                             CraftAndroid.checkAuthPersistence();
                         });
                     },
                     clear: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftAuthPersistResolve = resolve;
-                            window._craftAuthPersistReject = reject;
+                        return window.__craftPromise('auth persistence', '_craftAuthPersistResolve', '_craftAuthPersistReject', function() {
                             CraftAndroid.clearAuthPersistence();
                         });
                     }
@@ -778,76 +897,101 @@ class CraftBridge(
                 // AR (ARCore) - Note: Full ARCore requires native Activity integration
                 ar: {
                     start: function(options) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftARResolve = resolve;
-                            window._craftARReject = reject;
+                        return window.__craftPromise('AR', '_craftARResolve', '_craftARReject', function() {
                             CraftAndroid.startAR(JSON.stringify(options || {}));
                         });
                     },
                     stop: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftARResolve = resolve;
-                            window._craftARReject = reject;
+                        return window.__craftPromise('AR', '_craftARResolve', '_craftARReject', function() {
                             CraftAndroid.stopAR();
                         });
                     },
                     placeObject: function(model, position) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftARResolve = resolve;
-                            window._craftARReject = reject;
+                        return window.__craftPromise('AR', '_craftARResolve', '_craftARReject', function() {
                             CraftAndroid.placeARObject(model, JSON.stringify(position || {}));
                         });
                     },
                     removeObject: function(objectId) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftARResolve = resolve;
-                            window._craftARReject = reject;
+                        return window.__craftPromise('AR', '_craftARResolve', '_craftARReject', function() {
                             CraftAndroid.removeARObject(objectId);
                         });
                     },
                     getPlanes: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftARResolve = resolve;
-                            window._craftARReject = reject;
+                        return window.__craftPromise('AR', '_craftARResolve', '_craftARReject', function() {
                             CraftAndroid.getARPlanes();
                         });
                     },
                     onPlaneDetected: function(callback) {
-                        window.addEventListener('craftARPlane', function(e) { callback(e.detail); });
+                        throw new Error('craft.ar.onPlaneDetected is unavailable because ARCore requires native Activity integration');
                     }
                 },
 
                 // ML (ML Kit)
                 ml: {
                     classifyImage: function(imageBase64) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftMLResolve = resolve;
-                            window._craftMLReject = reject;
+                        return window.__craftPromise('ML', '_craftMLResolve', '_craftMLReject', function() {
                             CraftAndroid.classifyImage(imageBase64);
                         });
                     },
                     detectObjects: function(imageBase64) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftMLResolve = resolve;
-                            window._craftMLReject = reject;
+                        return window.__craftPromise('ML', '_craftMLResolve', '_craftMLReject', function() {
                             CraftAndroid.detectObjects(imageBase64);
                         });
                     },
                     recognizeText: function(imageBase64) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftMLResolve = resolve;
-                            window._craftMLReject = reject;
+                        return window.__craftPromise('ML', '_craftMLResolve', '_craftMLReject', function() {
                             CraftAndroid.recognizeText(imageBase64);
                         });
                     }
                 },
 
+                // Android home-screen widgets
+                widgets: {
+                    updateWidget: function(widgetId, data) {
+                        var payload = data === undefined ? (widgetId || {}) : Object.assign({}, data || {}, {widgetId: widgetId});
+                        return window.__craftPromise('widgets', '_craftWidgetResolve', '_craftWidgetReject', function() {
+                            CraftAndroid.updateWidget(JSON.stringify(payload));
+                        });
+                    },
+                    updateAllWidgets: function(widgetClass, data) {
+                        var payload = Object.assign({}, data || {}, {widgetClass: widgetClass});
+                        return window.__craftPromise('widgets', '_craftWidgetResolve', '_craftWidgetReject', function() {
+                            CraftAndroid.updateWidget(JSON.stringify(payload));
+                        });
+                    },
+                    reload: function() {
+                        return window.__craftPromise('widgets', '_craftWidgetResolve', '_craftWidgetReject', function() {
+                            CraftAndroid.reloadWidgets();
+                        });
+                    },
+                    getActiveWidgets: function() { return Promise.resolve([]); },
+                    requestPin: function() { return Promise.resolve(false); },
+                    isSupported: function() { return Promise.resolve(false); }
+                },
+
+                // Wear OS companion connectivity
+                watch: {
+                    send: function(message) {
+                        return window.__craftPromise('watch', '_craftWatchResolve', '_craftWatchReject', function() {
+                            CraftAndroid.sendToWatch(JSON.stringify(message));
+                        });
+                    },
+                    updateContext: function(context) {
+                        return window.__craftPromise('watch', '_craftWatchResolve', '_craftWatchReject', function() {
+                            CraftAndroid.updateWatchContext(JSON.stringify(context));
+                        });
+                    },
+                    isReachable: function() {
+                        return Promise.resolve().then(function() {
+                            return {reachable: CraftAndroid.isWatchReachable()};
+                        });
+                    }
+                },
+
                 // Deep Links
                 deepLinks: {
                     getInitialURL: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftDeepLinkResolve = resolve;
-                            window._craftDeepLinkReject = reject;
+                        return window.__craftPromise('initial URL', '_craftDeepLinkResolve', '_craftDeepLinkReject', function() {
                             CraftAndroid.getInitialURL();
                         });
                     },
@@ -932,38 +1076,28 @@ class CraftBridge(
                 ota: {
                     _config: null,
                     _status: 'idle',
-                    _progressCallbacks: [],
-                    _statusCallbacks: [],
 
                     configure: function(options) {
                         this._config = options;
                         CraftAndroid.otaConfigure(JSON.stringify(options));
                     },
                     checkForUpdate: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftOTACheckResolve = resolve;
-                            window._craftOTACheckReject = reject;
+                        return window.__craftPromise('OTA check', '_craftOTACheckResolve', '_craftOTACheckReject', function() {
                             CraftAndroid.otaCheckForUpdate();
                         });
                     },
                     downloadUpdate: function(options) {
-                        return new Promise(function(resolve, reject) {
-                            window._craftOTADownloadResolve = resolve;
-                            window._craftOTADownloadReject = reject;
+                        return window.__craftPromise('OTA download', '_craftOTADownloadResolve', '_craftOTADownloadReject', function() {
                             CraftAndroid.otaDownloadUpdate(JSON.stringify(options || {}));
                         });
                     },
                     applyUpdate: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftOTAApplyResolve = resolve;
-                            window._craftOTAApplyReject = reject;
+                        return window.__craftPromise('OTA apply', '_craftOTAApplyResolve', '_craftOTAApplyReject', function() {
                             CraftAndroid.otaApplyUpdate();
                         });
                     },
                     rollback: function() {
-                        return new Promise(function(resolve, reject) {
-                            window._craftOTARollbackResolve = resolve;
-                            window._craftOTARollbackReject = reject;
+                        return window.__craftPromise('OTA rollback', '_craftOTARollbackResolve', '_craftOTARollbackReject', function() {
                             CraftAndroid.otaRollback();
                         });
                     },
@@ -973,12 +1107,10 @@ class CraftBridge(
                         catch(e) { return { version: '1.0.0', buildNumber: 1, hash: '', isOriginal: true, installedAt: '' }; }
                     },
                     onProgress: function(callback) {
-                        this._progressCallbacks.push(callback);
-                        window.addEventListener('craftOTAProgress', function(e) { callback(e.detail); });
+                        throw new Error('craft.ota.onProgress is not implemented on this platform');
                     },
                     onStatusChange: function(callback) {
-                        this._statusCallbacks.push(callback);
-                        window.addEventListener('craftOTAStatus', function(e) { callback(e.detail.status); });
+                        throw new Error('craft.ota.onStatusChange is not implemented on this platform');
                     }
                 },
 
@@ -1222,14 +1354,14 @@ class CraftBridge(
                 var legacySecureStore = craft.secureStore;
                 craft.contractVersion = '1.0.0';
                 craft.device = {
-                    getInfo: function() { return Promise.resolve(craft.getDeviceInfo()); },
+                    getInfo: function() { return Promise.resolve().then(function() { return craft.getDeviceInfo(); }); },
                     getCapabilities: function() { return Promise.resolve(Object.assign({}, craft.capabilities)); }
                 };
                 craft.haptics = {
-                    impact: function(style) { craft.haptic(style || 'medium'); return Promise.resolve(); },
-                    notification: function(type) { craft.haptic(type === 'error' ? 'heavy' : 'light'); return Promise.resolve(); },
-                    selection: function() { craft.haptic('selection'); return Promise.resolve(); },
-                    vibrate: function(pattern) { craft.vibrate(pattern || []); return Promise.resolve(); }
+                    impact: function(style) { return Promise.resolve().then(function() { craft.haptic(style || 'medium'); }); },
+                    notification: function(type) { return Promise.resolve().then(function() { craft.haptic(type === 'error' ? 'heavy' : 'light'); }); },
+                    selection: function() { return Promise.resolve().then(function() { craft.haptic('selection'); }); },
+                    vibrate: function(pattern) { return Promise.resolve().then(function() { craft.vibrate(pattern || []); }); }
                 };
                 craft.camera = {
                     takePicture: function() { return legacyOpenCamera().then(normalizePhoto); },
@@ -1243,26 +1375,77 @@ class CraftBridge(
                     authenticate: function(reason) { return legacyAuthenticate(reason); }
                 };
                 craft.secureStorage = {
-                    set: function(key, value) { return Promise.resolve(legacySecureStore.set(key, value)).then(function() {}); },
-                    get: function(key) { return Promise.resolve(legacySecureStore.get(key)); },
-                    delete: function(key) { return Promise.resolve(legacySecureStore.remove(key)).then(function() {}); },
-                    clear: function() { return Promise.resolve(CraftAndroid.secureClear()).then(function() {}); }
+                    set: function(key, value) { return Promise.resolve().then(function() { legacySecureStore.set(key, value); }); },
+                    get: function(key) { return Promise.resolve().then(function() { return legacySecureStore.get(key); }); },
+                    delete: function(key) { return Promise.resolve().then(function() { legacySecureStore.remove(key); }); },
+                    clear: function() { return Promise.resolve().then(function() { CraftAndroid.secureClear(); }); }
+                };
+                var permissionRequestSequence = 0;
+                var permissionRequests = Object.create(null);
+                var permissionRuntimeClosed = false;
+                window.__craftPermissionResult = function(id, status) {
+                    if (permissionRuntimeClosed) return;
+                    var pending = permissionRequests[id];
+                    if (!pending) return;
+                    delete permissionRequests[id];
+                    clearTimeout(pending.timeout);
+                    pending.resolve(status || 'undetermined');
+                };
+                window.__craftRejectPermissionRequests = function(message) {
+                    permissionRuntimeClosed = true;
+                    Object.keys(permissionRequests).forEach(function(id) {
+                        var pending = permissionRequests[id];
+                        delete permissionRequests[id];
+                        clearTimeout(pending.timeout);
+                        pending.reject(new Error(message || 'Android bridge closed'));
+                    });
+                };
+                craft.permissions = {
+                    check: function(permission) {
+                        return Promise.resolve().then(function() { return CraftAndroid.checkPermission(String(permission)); });
+                    },
+                    request: function(permission) {
+                        if (permissionRuntimeClosed) {
+                            return Promise.reject(new Error('Android bridge is closed'));
+                        }
+                        return new Promise(function(resolve, reject) {
+                            permissionRequestSequence += 1;
+                            var id = permissionRequestSequence;
+                            var timeout = setTimeout(function() {
+                                delete permissionRequests[id];
+                                reject(new Error('Craft permission request timed out'));
+                            }, 30000);
+                            permissionRequests[id] = {resolve: resolve, timeout: timeout};
+                            try {
+                                CraftAndroid.requestPermission(String(permission), id);
+                            } catch (error) {
+                                clearTimeout(timeout);
+                                delete permissionRequests[id];
+                                reject(error);
+                            }
+                        });
+                    },
+                    openSettings: function() {
+                        return Promise.resolve().then(function() { CraftAndroid.openPermissionSettings(); });
+                    }
                 };
                 craft.location = {
                     getCurrentPosition: craft.getCurrentPosition,
                     watchPosition: craft.watchPosition,
                     clearWatch: craft.clearWatch,
-                    startRecording: function(options) { return Promise.resolve(JSON.parse(CraftAndroid.startLocationRecording(JSON.stringify(options || {})))); },
-                    pauseRecording: function() { return Promise.resolve(JSON.parse(CraftAndroid.pauseLocationRecording())); },
-                    resumeRecording: function() { return Promise.resolve(JSON.parse(CraftAndroid.resumeLocationRecording())); },
-                    stopRecording: function() { return Promise.resolve(JSON.parse(CraftAndroid.stopLocationRecording())); },
-                    getRecordingState: function() { return Promise.resolve(JSON.parse(CraftAndroid.getLocationRecordingState())); },
-                    readRecording: function() { return Promise.resolve(JSON.parse(CraftAndroid.readLocationRecording())); }
+                    startRecording: function(options) { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.startLocationRecording(JSON.stringify(options || {}))); }); },
+                    pauseRecording: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.pauseLocationRecording()); }); },
+                    resumeRecording: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.resumeLocationRecording()); }); },
+                    stopRecording: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.stopLocationRecording()); }); },
+                    getRecordingState: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.getLocationRecordingState()); }); },
+                    readRecording: function() { return Promise.resolve().then(function() { return JSON.parse(CraftAndroid.readLocationRecording()); }); }
                 };
                 var shareApi = function(text, title) { return legacyShare(text, title); };
                 shareApi.share = function(options) {
                     options = options || {};
-                    return Promise.resolve(legacyShare([options.text, options.url].filter(Boolean).join(' '), options.title || ''));
+                    return Promise.resolve().then(function() {
+                        return legacyShare([options.text, options.url].filter(Boolean).join(' '), options.title || '');
+                    });
                 };
                 craft.share = shareApi;
                 craft.lifecycle = {
@@ -1287,14 +1470,27 @@ class CraftBridge(
         """.trimIndent()
 
         activity.runOnUiThread {
-            webView.evaluateJavascript(script, null)
+            if (closed) return@runOnUiThread
+            webView.evaluateJavascript(script) {
+                if (closed) return@evaluateJavascript
+                bridgeReady = true
+                val events = pendingEvents.toList()
+                pendingEvents.clear()
+                events.forEach { (name, data) -> sendEvent(name, data) }
+            }
         }
     }
 
+    fun markBridgeLoading() {
+        bridgeReady = false
+    }
+
     // ==================== Haptics ====================
 
     @JavascriptInterface
     fun haptic(style: String) {
+        if (CraftNative.haptic(activity, style)) return
+
         val vibrator = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             val vibratorManager = activity.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
             vibratorManager.defaultVibrator
@@ -1325,15 +1521,18 @@ class CraftBridge(
 
     @JavascriptInterface
     fun startListening() {
+        if (CraftNative.startListening(activity)) return
+
         if (!SpeechRecognizer.isRecognitionAvailable(activity)) {
             sendEvent("craftSpeechError", mapOf("error" to "Speech recognition not available"))
             return
         }
 
         activity.runOnUiThread {
+            if (closed) return@runOnUiThread
             if (ContextCompat.checkSelfPermission(activity, Manifest.permission.RECORD_AUDIO)
                 != PackageManager.PERMISSION_GRANTED) {
-                ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.RECORD_AUDIO), 100)
+                requestPermissionsBestEffort(arrayOf(Manifest.permission.RECORD_AUDIO), 100)
                 return@runOnUiThread
             }
 
@@ -1399,6 +1598,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun stopListening() {
+        if (CraftNative.stopListening(activity)) return
+
         activity.runOnUiThread {
             speechRecognizer?.stopListening()
             speechRecognizer?.destroy()
@@ -1411,6 +1612,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun share(text: String, title: String) {
+        if (CraftNative.share(activity, text, title)) return
+
         val intent = Intent(Intent.ACTION_SEND).apply {
             type = "text/plain"
             putExtra(Intent.EXTRA_TEXT, text)
@@ -1427,45 +1630,150 @@ class CraftBridge(
     fun openCamera() {
         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA)
             != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.CAMERA), 101)
+            rejectMediaPromise("_craftCamera", "Camera permission is required; retry after granting it")
+            requestPermissionsBestEffort(arrayOf(Manifest.permission.CAMERA), 101)
             return
         }
 
-        val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
-        activity.startActivityForResult(intent, REQUEST_CAMERA)
+        // The Activity result still returns to handleImageResult below; Zig
+        // only launches it, using the same request code that routes it here.
+        if (CraftNative.openCamera(activity)) return
+
+        try {
+            val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
+            activity.startActivityForResult(intent, REQUEST_CAMERA)
+        } catch (error: Exception) {
+            rejectMediaPromise("_craftCamera", error.message ?: "Camera could not be opened")
+        }
     }
 
     @JavascriptInterface
     fun pickImage() {
-        val intent = Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI)
-        activity.startActivityForResult(intent, REQUEST_GALLERY)
+        if (CraftNative.pickImage(activity)) return
+
+        try {
+            val intent = Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI)
+            activity.startActivityForResult(intent, REQUEST_GALLERY)
+        } catch (error: Exception) {
+            rejectMediaPromise("_craftGallery", error.message ?: "Image picker could not be opened")
+        }
     }
 
     fun handleImageResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        if (closed) return
+        val promise = if (requestCode == REQUEST_CAMERA) "_craftCamera" else "_craftGallery"
         if (resultCode != Activity.RESULT_OK) {
-            val event = if (requestCode == REQUEST_CAMERA) "_craftCameraReject" else "_craftGalleryReject"
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window.$event && window.$event('Cancelled')", null)
-            }
+            rejectMediaPromise(promise, "Cancelled")
             return
         }
 
-        val imageUri: String? = when (requestCode) {
-            REQUEST_CAMERA -> {
-                // For camera, we get a bitmap thumbnail
-                val bitmap = data?.extras?.get("data") as? Bitmap
-                bitmap?.let { "data:image/png;base64,${bitmapToBase64(it)}" }
+        if (requestCode == REQUEST_CAMERA) {
+            val bitmap = data?.extras?.get("data") as? Bitmap
+            if (bitmap == null) {
+                rejectMediaPromise(promise, "Camera returned no image")
+            } else {
+                resolveMediaPromise(promise, "data:image/png;base64,${bitmapToBase64(bitmap)}")
             }
-            REQUEST_GALLERY -> {
-                data?.data?.toString()
+            return
+        }
+
+        val uri = data?.data
+        if (uri == null) {
+            rejectMediaPromise(promise, "Gallery returned no image")
+            return
+        }
+
+        Thread {
+            try {
+                val bytes = activity.contentResolver.openInputStream(uri)?.use { it.readBytes() }
+                    ?: throw IllegalStateException("Selected image could not be opened")
+                val mimeType = activity.contentResolver.getType(uri) ?: "image/jpeg"
+                val encoded = Base64.encodeToString(bytes, Base64.NO_WRAP)
+                resolveMediaPromise(promise, "data:$mimeType;base64,$encoded")
+            } catch (e: Exception) {
+                rejectMediaPromise(promise, e.message ?: "Selected image could not be read")
             }
-            else -> null
+        }.start()
+    }
+
+    private fun resolveMediaPromise(promise: String, value: String) {
+        evaluatePromiseJavascript(
+            "window.${promise}Resolve && window.${promise}Resolve(${jsQuote(value)})"
+        )
+    }
+
+    private fun rejectMediaPromise(promise: String, message: String) {
+        evaluatePromiseJavascript(
+            "window.${promise}Reject && window.${promise}Reject(${jsQuote(message)})"
+        )
+    }
+
+    private fun handleFilePickerResult(resultCode: Int, data: Intent?) {
+        if (closed) return
+        val uri = data?.data
+        if (resultCode != Activity.RESULT_OK || uri == null) {
+            rejectFilePicker("Cancelled")
+            return
         }
 
-        val event = if (requestCode == REQUEST_CAMERA) "_craftCameraResolve" else "_craftGalleryResolve"
-        activity.runOnUiThread {
-            webView.evaluateJavascript("window.$event && window.$event('$imageUri')", null)
+        Thread {
+            try {
+                val bytes = activity.contentResolver.openInputStream(uri)?.use { it.readBytes() }
+                    ?: throw IllegalStateException("Selected file could not be opened")
+                var name = uri.lastPathSegment ?: "file"
+                activity.contentResolver.query(uri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)?.use { cursor ->
+                    if (cursor.moveToFirst()) {
+                        name = cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME))
+                    }
+                }
+                val result = JSONObject().apply {
+                    put("name", name)
+                    put("data", Base64.encodeToString(bytes, Base64.NO_WRAP))
+                    put("mimeType", activity.contentResolver.getType(uri) ?: "application/octet-stream")
+                }
+                evaluatePromiseJavascript("window._craftFileResolve && window._craftFileResolve($result)")
+            } catch (e: Exception) {
+                rejectFilePicker(e.message ?: "Selected file could not be read")
+            }
+        }.start()
+    }
+
+    private fun rejectFilePicker(message: String) {
+        evaluatePromiseJavascript(
+            "window._craftFileReject && window._craftFileReject(${jsQuote(message)})"
+        )
+    }
+
+    private fun handleVideoResult(resultCode: Int, data: Intent?) {
+        if (closed) return
+        val uri = data?.data
+        if (resultCode != Activity.RESULT_OK) {
+            evaluatePromiseJavascript("window._craftVideoReject && window._craftVideoReject('Cancelled')")
+            return
+        }
+        if (uri == null) {
+            evaluatePromiseJavascript(
+                "window._craftVideoReject && window._craftVideoReject('Video capture returned no file')"
+            )
+            return
         }
+
+        Thread {
+            try {
+                val bytes = activity.contentResolver.openInputStream(uri)?.use { it.readBytes() }
+                    ?: throw IllegalStateException("Recorded video could not be opened")
+                val mimeType = activity.contentResolver.getType(uri) ?: "video/mp4"
+                val encoded = Base64.encodeToString(bytes, Base64.NO_WRAP)
+                val result = "data:$mimeType;base64,$encoded"
+                evaluatePromiseJavascript(
+                    "window._craftVideoResolve && window._craftVideoResolve(${jsQuote(result)})"
+                )
+            } catch (e: Exception) {
+                evaluatePromiseJavascript(
+                    "window._craftVideoReject && window._craftVideoReject(${jsQuote(e.message ?: "Recorded video could not be read")})"
+                )
+            }
+        }.start()
     }
 
     private fun bitmapToBase64(bitmap: Bitmap): String {
@@ -1484,49 +1792,65 @@ class CraftBridge(
 
     @JavascriptInterface
     fun authenticate(reason: String) {
+        // The prompt and its Java callback live in CraftNative; every result
+        // comes back through Zig, which settles the existing page promise.
+        if (CraftNative.authenticate(activity, reason)) return
+
+        val settled = java.util.concurrent.atomic.AtomicBoolean(false)
+
+        fun resolveBiometricRequest() {
+            if (!settled.compareAndSet(false, true) || closed) return
+            biometricPrompt = null
+            evaluatePromiseJavascript("window._craftBiometricResolve && window._craftBiometricResolve(true)")
+        }
+
+        fun rejectBiometricRequest(message: String) {
+            if (!settled.compareAndSet(false, true) || closed) return
+            biometricPrompt = null
+            evaluatePromiseJavascript(
+                "window._craftBiometricReject && window._craftBiometricReject(${jsQuote(message)})"
+            )
+        }
+
         if (activity !is FragmentActivity) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBiometricReject && window._craftBiometricReject('Activity not supported')",
-                    null
-                )
-            }
+            rejectBiometricRequest("Activity not supported")
             return
         }
 
         activity.runOnUiThread {
-            val promptInfo = BiometricPrompt.PromptInfo.Builder()
-                .setTitle("Authenticate")
-                .setSubtitle(reason)
-                .setNegativeButtonText("Cancel")
-                .setAllowedAuthenticators(BiometricManager.Authenticators.BIOMETRIC_STRONG)
-                .build()
-
-            val biometricPrompt = BiometricPrompt(
-                activity as FragmentActivity,
-                mainExecutor,
-                object : BiometricPrompt.AuthenticationCallback() {
-                    override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
-                        webView.evaluateJavascript(
-                            "window._craftBiometricResolve && window._craftBiometricResolve(true)",
-                            null
-                        )
-                    }
+            if (closed) return@runOnUiThread
+            try {
+                val promptInfo = BiometricPrompt.PromptInfo.Builder()
+                    .setTitle("Authenticate")
+                    .setSubtitle(reason)
+                    .setNegativeButtonText("Cancel")
+                    .setAllowedAuthenticators(BiometricManager.Authenticators.BIOMETRIC_STRONG)
+                    .build()
+
+                runCatching { biometricPrompt?.cancelAuthentication() }
+                val prompt = BiometricPrompt(
+                    activity as FragmentActivity,
+                    mainExecutor,
+                    object : BiometricPrompt.AuthenticationCallback() {
+                        override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
+                            resolveBiometricRequest()
+                        }
 
-                    override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
-                        webView.evaluateJavascript(
-                            "window._craftBiometricReject && window._craftBiometricReject('$errString')",
-                            null
-                        )
-                    }
+                        override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
+                            rejectBiometricRequest(errString.toString())
+                        }
 
-                    override fun onAuthenticationFailed() {
-                        // Don't reject yet - user can retry
+                        override fun onAuthenticationFailed() {
+                            // Don't reject yet - user can retry
+                        }
                     }
-                }
-            )
+                )
 
-            biometricPrompt.authenticate(promptInfo)
+                biometricPrompt = prompt
+                prompt.authenticate(promptInfo)
+            } catch (error: Exception) {
+                rejectBiometricRequest(error.message ?: "Biometric authentication failed")
+            }
         }
     }
 
@@ -1541,6 +1865,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun secureSet(key: String, value: String): Boolean {
+        if (CraftNative.secureSet(securePrefs, key, value)) return true
+
         return try {
             securePrefs.edit().putString(key, value).apply()
             true
@@ -1551,6 +1877,14 @@ class CraftBridge(
 
     @JavascriptInterface
     fun secureGet(key: String): String? {
+        // Three answers, not two: Declined falls through, NotFound is a real
+        // null, Found is a real value that may be the empty string.
+        when (val read = CraftNative.secureGet(securePrefs, key)) {
+            is CraftNative.SecureRead.Found -> return read.value
+            CraftNative.SecureRead.NotFound -> return null
+            CraftNative.SecureRead.Declined -> Unit
+        }
+
         return try {
             securePrefs.getString(key, null)
         } catch (e: Exception) {
@@ -1560,6 +1894,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun secureRemove(key: String): Boolean {
+        if (CraftNative.secureRemove(securePrefs, key)) return true
+
         return try {
             securePrefs.edit().remove(key).apply()
             true
@@ -1570,6 +1906,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun secureClear(): Boolean {
+        if (CraftNative.secureClear(securePrefs)) return true
+
         return try {
             securePrefs.edit().clear().apply()
             true
@@ -1582,104 +1920,271 @@ class CraftBridge(
 
     @JavascriptInterface
     fun log(message: String) {
+        if (CraftNative.log(message)) return
         android.util.Log.d("CraftBridge", message)
     }
 
     // ==================== Geolocation ====================
 
-    @JavascriptInterface
-    fun getCurrentPosition(optionsJson: String) {
-        if (ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION)
-            != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(
-                activity,
-                arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION),
-                REQUEST_LOCATION
-            )
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftLocationReject && window._craftLocationReject({code: 1, message: 'Permission denied'})",
-                    null
-                )
-            }
-            return
-        }
-
-        fusedLocationClient = LocationServices.getFusedLocationProviderClient(activity)
-        fusedLocationClient?.lastLocation?.addOnSuccessListener { location: Location? ->
-            if (location != null) {
-                val json = JSONObject().apply {
-                    put("latitude", location.latitude)
-                    put("longitude", location.longitude)
-                    put("accuracy", location.accuracy)
-                    put("altitude", location.altitude)
-                    put("speed", location.speed)
-                    put("heading", location.bearing)
-                    put("timestamp", location.time)
-                }
-                activity.runOnUiThread {
-                    webView.evaluateJavascript(
-                        "window._craftLocationResolve && window._craftLocationResolve($json)",
-                        null
-                    )
-                }
-            } else {
-                // Request fresh location if last location is null
-                requestFreshLocation()
-            }
-        }?.addOnFailureListener { e ->
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftLocationReject && window._craftLocationReject({code: 2, message: '${e.message}'})",
-                    null
-                )
-            }
-        }
+    private fun nativePermissionStatus(name: String): String {
+        return CraftPermissionPolicy.status(name, Build.VERSION.SDK_INT, ::isPermissionGranted)
     }
 
-    private fun requestFreshLocation() {
-        if (ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
-            return
-        }
+    private fun isPermissionGranted(permission: String): Boolean =
+        ContextCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED
 
-        val locationRequest = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 1000)
-            .setWaitForAccurateLocation(false)
-            .setMinUpdateIntervalMillis(500)
-            .setMaxUpdateDelayMillis(1000)
-            .setMaxUpdates(1)
-            .build()
+    private fun hasForegroundLocationPermission(): Boolean =
+        CraftPermissionPolicy.foregroundLocationIsGranted(::isPermissionGranted)
 
-        val callback = object : LocationCallback() {
-            override fun onLocationResult(result: LocationResult) {
-                fusedLocationClient?.removeLocationUpdates(this)
-                val location = result.lastLocation
-                if (location != null) {
-                    val json = JSONObject().apply {
-                        put("latitude", location.latitude)
-                        put("longitude", location.longitude)
-                        put("accuracy", location.accuracy)
-                        put("altitude", location.altitude)
-                        put("speed", location.speed)
-                        put("heading", location.bearing)
-                        put("timestamp", location.time)
-                    }
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftLocationResolve && window._craftLocationResolve($json)",
-                            null
-                        )
-                    }
-                }
-            }
+    private fun claimPermissionRequestCode(): Int? {
+        var requestCode = nextPermissionRequestCode
+        while (pendingPermissionRequests.containsKey(requestCode)) {
+            requestCode += 1
+            if (requestCode > PERMISSION_REQUEST_END) requestCode = PERMISSION_REQUEST_START
+            if (requestCode == nextPermissionRequestCode) return null
+        }
+        nextPermissionRequestCode = if (requestCode == PERMISSION_REQUEST_END) {
+            PERMISSION_REQUEST_START
+        } else {
+            requestCode + 1
         }
+        return requestCode
+    }
 
-        fusedLocationClient?.requestLocationUpdates(locationRequest, callback, Looper.getMainLooper())
+    private fun enqueuePermissionRequest(
+        permission: String,
+        callbackId: Int,
+        startingAt: Int
+    ): Boolean {
+        val request = CraftPermissionPolicy.nextRequest(
+            permission,
+            Build.VERSION.SDK_INT,
+            startingAt,
+            ::isPermissionGranted
+        ) ?: return false
+        val requestCode = claimPermissionRequestCode() ?: return false
+        pendingPermissionRequests[requestCode] = PendingPermissionRequest(
+            callbackId,
+            permission,
+            request.groupIndex
+        )
+        return try {
+            ActivityCompat.requestPermissions(activity, request.permissions, requestCode)
+            true
+        } catch (error: Exception) {
+            pendingPermissionRequests.remove(requestCode)
+            false
+        }
     }
 
     @JavascriptInterface
-    fun watchPosition(optionsJson: String): Int {
-        if (ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION)
-            != PackageManager.PERMISSION_GRANTED) {
+    fun checkPermission(permission: String): String = nativePermissionStatus(permission)
+
+    @JavascriptInterface
+    fun requestPermission(permission: String, callbackId: Int) {
+        activity.runOnUiThread {
+            if (closed) return@runOnUiThread
+            val status = nativePermissionStatus(permission)
+            if (status == "granted" || !enqueuePermissionRequest(permission, callbackId, 0)) {
+                deliverPermissionResult(callbackId, status)
+            }
+        }
+    }
+
+    @JavascriptInterface
+    fun openPermissionSettings() {
+        activity.runOnUiThread {
+            val intent = Intent(
+                Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+                Uri.fromParts("package", activity.packageName, null)
+            )
+            activity.startActivity(intent)
+        }
+    }
+
+    fun onRequestPermissionsResult(requestCode: Int): Boolean {
+        if (closed) return requestCode in PERMISSION_REQUEST_START..PERMISSION_REQUEST_END
+        val pending = pendingPermissionRequests.remove(requestCode) ?: return false
+        // Re-read package state instead of interpreting the parallel callback
+        // arrays. In particular, an approximate-location choice returns a
+        // denied fine result and a granted coarse result, which is still a
+        // granted `location` permission in Craft's contract.
+        val status = nativePermissionStatus(pending.permission)
+        val completedGroup = CraftPermissionPolicy.groupIsGranted(
+            pending.permission,
+            Build.VERSION.SDK_INT,
+            pending.groupIndex,
+            ::isPermissionGranted
+        )
+        if (status != "granted" && completedGroup && enqueuePermissionRequest(
+                pending.permission,
+                pending.callbackId,
+                pending.groupIndex + 1
+            )) return true
+
+        deliverPermissionResult(pending.callbackId, status)
+        return true
+    }
+
+    private fun deliverPermissionResult(callbackId: Int, status: String) {
+        if (closed) return
+        activity.runOnUiThread {
+            if (closed) return@runOnUiThread
+            webView.evaluateJavascript(
+                "window.__craftPermissionResult && window.__craftPermissionResult($callbackId, ${jsQuote(status)})",
+                null
+            )
+        }
+    }
+
+    @JavascriptInterface
+    fun getCurrentPosition(optionsJson: String) {
+        // The task listeners and the fresh-location callback are
+        // CraftNative's, because they are Java interfaces. fusedLocationClient
+        // below is independent from the callbacks owned by watchPosition, so
+        // a one-shot lookup cannot overwrite or clear a continuous watch.
+        val requestId = currentPositionSequence.incrementAndGet()
+        oneShotLocationCallbacks.forEach { callback ->
+            runCatching { fusedLocationClient?.removeLocationUpdates(callback) }
+        }
+        oneShotLocationCallbacks.clear()
+        oneShotLocationTimeouts.values.forEach { timeout ->
+            oneShotLocationHandler.removeCallbacks(timeout)
+        }
+        oneShotLocationTimeouts.clear()
+
+        if (CraftNative.getCurrentPosition(activity)) return
+
+        val settled = java.util.concurrent.atomic.AtomicBoolean(false)
+
+        fun resolveLocationRequest(location: Location) {
+            if (requestId != currentPositionSequence.get()) return
+            if (!settled.compareAndSet(false, true) || closed) return
+            val json = JSONObject().apply {
+                put("latitude", location.latitude)
+                put("longitude", location.longitude)
+                put("accuracy", location.accuracy)
+                put("altitude", location.altitude)
+                put("speed", location.speed)
+                put("heading", location.bearing)
+                put("timestamp", location.time)
+            }
+            evaluatePromiseJavascript(
+                "window._craftLocationResolve && window._craftLocationResolve($json)"
+            )
+        }
+
+        fun rejectLocationRequest(message: String, code: Int = 2) {
+            if (requestId != currentPositionSequence.get()) return
+            if (!settled.compareAndSet(false, true) || closed) return
+            rejectLocation(message, code)
+        }
+
+        if (!hasForegroundLocationPermission()) {
+            rejectLocationRequest("Permission denied", 1)
+            requestPermissionsBestEffort(
+                arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION),
+                REQUEST_LOCATION
+            )
+            return
+        }
+
+        if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(activity) != ConnectionResult.SUCCESS) {
+            rejectLocationRequest("Google Play Services is unavailable")
+            return
+        }
+
+        try {
+            val client = LocationServices.getFusedLocationProviderClient(activity)
+            fusedLocationClient = client
+            client.lastLocation.addOnSuccessListener { location: Location? ->
+                if (requestId != currentPositionSequence.get()) return@addOnSuccessListener
+                if (location != null) {
+                    resolveLocationRequest(location)
+                } else {
+                    requestFreshLocation(
+                        client,
+                        requestId,
+                        ::resolveLocationRequest,
+                        { message -> rejectLocationRequest(message) }
+                    )
+                }
+            }.addOnFailureListener { error -> rejectLocationRequest(error.message ?: "Location lookup failed") }
+        } catch (error: Exception) {
+            rejectLocationRequest(error.message ?: "Location lookup failed")
+        }
+    }
+
+    private fun requestFreshLocation(
+        client: FusedLocationProviderClient,
+        requestId: Long,
+        resolve: (Location) -> Unit,
+        reject: (String) -> Unit
+    ) {
+        if (!hasForegroundLocationPermission()) {
+            reject("Location permission was revoked")
+            return
+        }
+
+        val locationRequest = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 1000)
+            .setWaitForAccurateLocation(false)
+            .setMinUpdateIntervalMillis(500)
+            .setMaxUpdateDelayMillis(1000)
+            .setMaxUpdates(1)
+            .build()
+
+        val callback = object : LocationCallback() {
+            override fun onLocationResult(result: LocationResult) {
+                clearOneShotLocationCallback(client, this)
+                if (requestId != currentPositionSequence.get()) return
+                result.lastLocation?.let(resolve)
+                    ?: reject("Location provider returned no position")
+            }
+        }
+
+        oneShotLocationCallbacks.add(callback)
+        val timeout = Runnable {
+            if (!oneShotLocationCallbacks.contains(callback)) return@Runnable
+            clearOneShotLocationCallback(client, callback)
+            reject("Location request timed out; provider returned no position")
+        }
+        oneShotLocationTimeouts[callback] = timeout
+        oneShotLocationHandler.postDelayed(timeout, LOCATION_REQUEST_TIMEOUT_MS)
+        try {
+            client.requestLocationUpdates(locationRequest, callback, Looper.getMainLooper())
+                .addOnFailureListener { error ->
+                    clearOneShotLocationCallback(client, callback)
+                    reject(error.message ?: "Location request failed")
+                }
+        } catch (error: Exception) {
+            clearOneShotLocationCallback(client, callback)
+            reject(error.message ?: "Location request failed")
+        }
+    }
+
+    private fun clearOneShotLocationCallback(
+        client: FusedLocationProviderClient,
+        callback: LocationCallback
+    ) {
+        runCatching { client.removeLocationUpdates(callback) }
+        oneShotLocationCallbacks.remove(callback)
+        oneShotLocationTimeouts.remove(callback)?.let { timeout ->
+            oneShotLocationHandler.removeCallbacks(timeout)
+        }
+    }
+
+    private fun rejectLocation(message: String, code: Int = 2) {
+        evaluatePromiseJavascript(
+            "window._craftLocationReject && window._craftLocationReject({code: $code, message: ${jsQuote(message)}})"
+        )
+    }
+
+    @JavascriptInterface
+    fun watchPosition(optionsJson: String): Int {
+        if (!hasForegroundLocationPermission()) {
+            return -1
+        }
+        if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(activity) != ConnectionResult.SUCCESS) {
             return -1
         }
 
@@ -1690,7 +2195,7 @@ class CraftBridge(
             .setMinUpdateIntervalMillis(2000)
             .build()
 
-        locationCallback = object : LocationCallback() {
+        val callback = object : LocationCallback() {
             override fun onLocationResult(result: LocationResult) {
                 val location = result.lastLocation ?: return
                 val json = JSONObject().apply {
@@ -1702,17 +2207,15 @@ class CraftBridge(
                     put("heading", location.bearing)
                     put("timestamp", location.time)
                 }
-                activity.runOnUiThread {
-                    webView.evaluateJavascript(
-                        "window._craftLocationWatch_$currentWatchId && window._craftLocationWatch_$currentWatchId($json)",
-                        null
-                    )
-                }
+                evaluateJavascriptUnlessClosed(
+                    "window._craftLocationWatch_$currentWatchId && window._craftLocationWatch_$currentWatchId($json)"
+                )
             }
         }
 
-        if (ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
-            fusedLocationClient?.requestLocationUpdates(locationRequest, locationCallback!!, Looper.getMainLooper())
+        if (hasForegroundLocationPermission()) {
+            fusedLocationClient?.requestLocationUpdates(locationRequest, callback, Looper.getMainLooper())
+            locationCallbacks[currentWatchId] = callback
         }
 
         return currentWatchId
@@ -1720,15 +2223,18 @@ class CraftBridge(
 
     @JavascriptInterface
     fun clearWatch(watchId: Int) {
-        locationCallback?.let {
+        locationCallbacks.remove(watchId)?.let {
             fusedLocationClient?.removeLocationUpdates(it)
         }
-        locationCallback = null
     }
 
     @JavascriptInterface
     fun startLocationRecording(optionsJson: String): String {
-        if (ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+        // Null is "Zig declined". A permission-denied answer is not null — it
+        // is a state object saying so, and returning it here is the answer.
+        CraftNative.startLocationRecording(activity)?.let { return it }
+
+        if (!hasForegroundLocationPermission()) {
             return JSONObject().apply {
                 put("id", JSONObject.NULL)
                 put("active", false)
@@ -1748,12 +2254,16 @@ class CraftBridge(
 
     @JavascriptInterface
     fun pauseLocationRecording(): String {
+        CraftNative.pauseLocationRecording(activity)?.let { return it }
+
         CraftLocationRecordingStore.setPaused(activity, true)
         return CraftLocationRecordingStore.state(activity).toString()
     }
 
     @JavascriptInterface
     fun resumeLocationRecording(): String {
+        CraftNative.resumeLocationRecording(activity)?.let { return it }
+
         CraftLocationRecordingStore.setPaused(activity, false)
         if (CraftLocationRecordingStore.isActive(activity)) {
             ContextCompat.startForegroundService(
@@ -1766,6 +2276,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun stopLocationRecording(): String {
+        CraftNative.stopLocationRecording(activity)?.let { return it }
+
         CraftLocationRecordingStore.stop(activity)
         val result = CraftLocationRecordingStore.state(activity, includeLocations = true).toString()
         activity.stopService(Intent(activity, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_STOP))
@@ -1773,15 +2285,29 @@ class CraftBridge(
     }
 
     @JavascriptInterface
-    fun getLocationRecordingState(): String = CraftLocationRecordingStore.state(activity).toString()
+    fun getLocationRecordingState(): String {
+        // Null is "Zig declined", not "no recording" — an absent recording is
+        // a state object saying so, and returning it here is the answer.
+        CraftNative.getLocationRecordingState(activity)?.let { return it }
+
+        return CraftLocationRecordingStore.state(activity).toString()
+    }
 
     @JavascriptInterface
-    fun readLocationRecording(): String = CraftLocationRecordingStore.locations(activity).toString()
+    fun readLocationRecording(): String {
+        CraftNative.readLocationRecording(activity)?.let { return it }
+
+        return CraftLocationRecordingStore.locations(activity).toString()
+    }
 
     // ==================== Clipboard ====================
 
     @JavascriptInterface
     fun clipboardRead(): String {
+        // Null is "Zig declined", not "empty" — an empty clipboard comes back
+        // as "" and returns here rather than falling through to be read twice.
+        CraftNative.clipboardRead(activity)?.let { return it }
+
         val clipboard = activity.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
         val clip = clipboard.primaryClip
         return if (clip != null && clip.itemCount > 0) {
@@ -1793,6 +2319,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun clipboardWrite(text: String): Boolean {
+        if (CraftNative.clipboardWrite(activity, text)) return true
+
         return try {
             val clipboard = activity.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
             val clip = ClipData.newPlainText("Craft", text)
@@ -1807,6 +2335,11 @@ class CraftBridge(
 
     @JavascriptInterface
     fun getDeviceInfo(): String {
+        // The Zig runtime first, the body below when it declines. Null means
+        // this build does not serve the action natively — a shim-only app, or
+        // one whose libcraft.so failed to bind — and is not an error.
+        CraftNative.getDeviceInfo(activity)?.let { return it }
+
         val metrics = DisplayMetrics()
         @Suppress("DEPRECATION")
         activity.windowManager.defaultDisplay.getMetrics(metrics)
@@ -1837,32 +2370,12 @@ class CraftBridge(
         }.toString()
     }
 
-    // ==================== App Badge ====================
-
-    @JavascriptInterface
-    fun setBadge(count: Int) {
-        // Android doesn't have native badge support, but we can use notification channels
-        // This is a simplified implementation - for full support, use ShortcutBadger library
-        try {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                val notificationManager = NotificationManagerCompat.from(activity)
-                // Badge is typically shown via notification count
-                // Full implementation would require creating a notification
-            }
-        } catch (e: Exception) {
-            log("Badge not supported: ${e.message}")
-        }
-    }
-
-    @JavascriptInterface
-    fun clearBadge() {
-        setBadge(0)
-    }
-
     // ==================== Network Status ====================
 
     @JavascriptInterface
     fun getNetworkStatus(): String {
+        CraftNative.getNetworkStatus(activity)?.let { return it }
+
         val connectivityManager = activity.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
         val network = connectivityManager.activeNetwork
         val capabilities = connectivityManager.getNetworkCapabilities(network)
@@ -1885,9 +2398,16 @@ class CraftBridge(
 
     @JavascriptInterface
     fun startNetworkMonitoring() {
+        // The callback object is CraftNative's, because JNI cannot subclass
+        // an abstract Java class — what Zig owns is what happens when it
+        // fires. Returning here keeps this file's networkCallback null, which
+        // is why stopNetworkMonitoring has to reach the same way.
+        if (CraftNative.startNetworkMonitoring(activity)) return
+        if (networkCallback != null) return
+
         val connectivityManager = activity.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
 
-        networkCallback = object : ConnectivityManager.NetworkCallback() {
+        val callback = object : ConnectivityManager.NetworkCallback() {
             override fun onAvailable(network: Network) {
                 sendNetworkChange()
             }
@@ -1905,11 +2425,14 @@ class CraftBridge(
             .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
             .build()
 
-        connectivityManager.registerNetworkCallback(request, networkCallback!!)
+        connectivityManager.registerNetworkCallback(request, callback)
+        networkCallback = callback
     }
 
     @JavascriptInterface
     fun stopNetworkMonitoring() {
+        if (CraftNative.stopNetworkMonitoring(activity)) return
+
         val connectivityManager = activity.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
         networkCallback?.let {
             connectivityManager.unregisterNetworkCallback(it)
@@ -1919,42 +2442,49 @@ class CraftBridge(
 
     private fun sendNetworkChange() {
         val status = getNetworkStatus()
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftNetworkChangeCallback && window._craftNetworkChangeCallback($status)",
-                null
-            )
-        }
+        evaluateJavascriptUnlessClosed(
+            "window._craftNetworkChangeCallback && window._craftNetworkChangeCallback($status)"
+        )
     }
 
     // ==================== App Review ====================
 
     @JavascriptInterface
     fun requestReview() {
-        val reviewManager = ReviewManagerFactory.create(activity)
-        val request = reviewManager.requestReviewFlow()
-
-        request.addOnCompleteListener { task ->
-            if (task.isSuccessful) {
-                val reviewInfo = task.result
-                val flow = reviewManager.launchReviewFlow(activity, reviewInfo)
-                flow.addOnCompleteListener {
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftReviewResolve && window._craftReviewResolve(true)",
-                            null
-                        )
+        if (CraftNative.requestReview(activity)) return
+
+        val settled = java.util.concurrent.atomic.AtomicBoolean(false)
+
+        fun resolveReviewRequest() {
+            if (!settled.compareAndSet(false, true) || closed) return
+            evaluatePromiseJavascript("window._craftReviewResolve && window._craftReviewResolve(true)")
+        }
+
+        fun rejectReviewRequest(message: String) {
+            if (!settled.compareAndSet(false, true) || closed) return
+            evaluatePromiseJavascript(
+                "window._craftReviewReject && window._craftReviewReject(${jsQuote(message)})"
+            )
+        }
+
+        try {
+            val reviewManager = ReviewManagerFactory.create(activity)
+            val request = reviewManager.requestReviewFlow()
+
+            request.addOnCompleteListener { task ->
+                if (task.isSuccessful) {
+                    try {
+                        reviewManager.launchReviewFlow(activity, task.result)
+                            .addOnCompleteListener { resolveReviewRequest() }
+                    } catch (error: Exception) {
+                        rejectReviewRequest(error.message ?: "Review flow failed")
                     }
-                }
-            } else {
-                activity.runOnUiThread {
-                    val message = JSONObject.quote(task.exception?.message ?: "Review flow failed")
-                    webView.evaluateJavascript(
-                        "window._craftReviewReject && window._craftReviewReject($message)",
-                        null
-                    )
+                } else {
+                    rejectReviewRequest(task.exception?.message ?: "Review flow failed")
                 }
             }
+        } catch (error: Exception) {
+            rejectReviewRequest(error.message ?: "Review flow failed")
         }
     }
 
@@ -1985,6 +2515,8 @@ class CraftBridge(
             }
         } catch (e: CameraAccessException) {
             false
+        } catch (e: SecurityException) {
+            false
         }
     }
 
@@ -1998,6 +2530,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun openURL(url: String): Boolean {
+        if (CraftNative.openURL(activity, url)) return true
+
         return try {
             val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
             activity.startActivity(intent)
@@ -2011,6 +2545,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun vibrate(patternJson: String) {
+        if (CraftNative.vibrate(activity, patternJson)) return
+
         val vibrator = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             val vibratorManager = activity.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
             vibratorManager.defaultVibrator
@@ -2039,11 +2575,21 @@ class CraftBridge(
 
     @JavascriptInterface
     fun getAppState(): String {
+        // Null is "Zig declined". Otherwise this is the state Zig's observer
+        // has been maintaining, and currentAppState below is the one this
+        // file's observer maintains — whichever of the two is running.
+        CraftNative.getAppState()?.let { return it }
+
         return currentAppState
     }
 
     @JavascriptInterface
     fun startAppStateMonitoring() {
+        // The observer object is CraftNative's, and so is the state it
+        // maintains — which is why getAppState below has to reach the same
+        // way. All three move together or none of them can.
+        if (CraftNative.startAppStateMonitoring(activity)) return
+
         activity.runOnUiThread {
             ProcessLifecycleOwner.get().lifecycle.addObserver(appStateObserver)
         }
@@ -2051,6 +2597,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun stopAppStateMonitoring() {
+        if (CraftNative.stopAppStateMonitoring(activity)) return
+
         activity.runOnUiThread {
             ProcessLifecycleOwner.get().lifecycle.removeObserver(appStateObserver)
         }
@@ -2066,12 +2614,9 @@ class CraftBridge(
 
         if (newState != currentAppState) {
             currentAppState = newState
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftAppStateCallback && window._craftAppStateCallback('$currentAppState')",
-                    null
-                )
-            }
+            evaluateJavascriptUnlessClosed(
+                "window._craftAppStateCallback && window._craftAppStateCallback(${jsQuote(currentAppState)})"
+            )
             sendEvent("craftAppStateChange", mapOf("state" to currentAppState))
         }
     }
@@ -2080,83 +2625,99 @@ class CraftBridge(
 
     @JavascriptInterface
     fun getContacts() {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.getContacts(activity)) return
+
         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.READ_CONTACTS)
             != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.READ_CONTACTS), REQUEST_CONTACTS)
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftContactsReject && window._craftContactsReject('Permission denied')", null)
-            }
+            evaluatePromiseJavascript("window._craftContactsReject && window._craftContactsReject('Permission denied')")
+            requestPermissionsBestEffort(arrayOf(Manifest.permission.READ_CONTACTS), REQUEST_CONTACTS)
+            return
+        }
+
+        val contacts = try {
+            loadContacts()
+        } catch (error: Exception) {
+            evaluatePromiseJavascript(
+                "window._craftContactsReject && window._craftContactsReject(${jsQuote(error.message ?: "Contacts could not be read")})"
+            )
             return
         }
 
-        val contacts = JSONArray()
+        evaluatePromiseJavascript("window._craftContactsResolve && window._craftContactsResolve($contacts)")
+    }
+
+    private fun loadContacts(): JSONArray {
+        val contactRows = mutableListOf<Pair<String?, String?>>()
         val cursor: Cursor? = activity.contentResolver.query(
             ContactsContract.Contacts.CONTENT_URI,
-            null, null, null, ContactsContract.Contacts.DISPLAY_NAME + " ASC"
+            arrayOf(
+                ContactsContract.Contacts._ID,
+                ContactsContract.Contacts.DISPLAY_NAME
+            ),
+            null, null, ContactsContract.Contacts.DISPLAY_NAME + " ASC"
         )
 
         cursor?.use {
+            val idIndex = it.getColumnIndexOrThrow(ContactsContract.Contacts._ID)
+            val nameIndex = it.getColumnIndexOrThrow(ContactsContract.Contacts.DISPLAY_NAME)
             while (it.moveToNext()) {
-                val id = it.getString(it.getColumnIndexOrThrow(ContactsContract.Contacts._ID))
-                val name = it.getString(it.getColumnIndexOrThrow(ContactsContract.Contacts.DISPLAY_NAME))
-
-                val contact = JSONObject().apply {
-                    put("id", id)
-                    put("displayName", name ?: "")
-                    put("phoneNumbers", getContactPhones(id))
-                    put("emailAddresses", getContactEmails(id))
-                }
-                contacts.put(contact)
+                contactRows.add(it.getString(idIndex) to it.getString(nameIndex))
             }
         }
 
-        activity.runOnUiThread {
-            webView.evaluateJavascript("window._craftContactsResolve && window._craftContactsResolve($contacts)", null)
-        }
-    }
-
-    private fun getContactPhones(contactId: String): JSONArray {
-        val phones = JSONArray()
-        val cursor = activity.contentResolver.query(
+        val phoneNumbers = getContactValues(
             ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
-            null,
-            ContactsContract.CommonDataKinds.Phone.CONTACT_ID + " = ?",
-            arrayOf(contactId), null
+            ContactsContract.CommonDataKinds.Phone.CONTACT_ID,
+            ContactsContract.CommonDataKinds.Phone.NUMBER
         )
-        cursor?.use {
-            while (it.moveToNext()) {
-                val phone = it.getString(it.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.NUMBER))
-                phones.put(phone)
+        val emailAddresses = getContactValues(
+            ContactsContract.CommonDataKinds.Email.CONTENT_URI,
+            ContactsContract.CommonDataKinds.Email.CONTACT_ID,
+            ContactsContract.CommonDataKinds.Email.ADDRESS
+        )
+
+        return JSONArray().apply {
+            contactRows.forEach { (id, name) ->
+                put(JSONObject().apply {
+                    put("id", id)
+                    put("displayName", name ?: "")
+                    put("phoneNumbers", id?.let { phoneNumbers[it] } ?: JSONArray())
+                    put("emailAddresses", id?.let { emailAddresses[it] } ?: JSONArray())
+                })
             }
         }
-        return phones
     }
 
-    private fun getContactEmails(contactId: String): JSONArray {
-        val emails = JSONArray()
+    private fun getContactValues(contentUri: Uri, contactIdColumn: String, valueColumn: String): Map<String, JSONArray> {
+        val values = mutableMapOf<String, JSONArray>()
         val cursor = activity.contentResolver.query(
-            ContactsContract.CommonDataKinds.Email.CONTENT_URI,
-            null,
-            ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = ?",
-            arrayOf(contactId), null
+            contentUri,
+            arrayOf(contactIdColumn, valueColumn),
+            null, null, null
         )
         cursor?.use {
+            val contactIdIndex = it.getColumnIndexOrThrow(contactIdColumn)
+            val valueIndex = it.getColumnIndexOrThrow(valueColumn)
             while (it.moveToNext()) {
-                val email = it.getString(it.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Email.ADDRESS))
-                emails.put(email)
+                val contactId = it.getString(contactIdIndex) ?: continue
+                values.getOrPut(contactId) { JSONArray() }.put(it.getString(valueIndex))
             }
         }
-        return emails
+        return values
     }
 
     @JavascriptInterface
     fun addContact(contactJson: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.addContact(activity, contactJson)) return
+
         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.WRITE_CONTACTS)
             != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.WRITE_CONTACTS), REQUEST_CONTACTS)
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftAddContactReject && window._craftAddContactReject('Permission denied')", null)
-            }
+            evaluatePromiseJavascript("window._craftAddContactReject && window._craftAddContactReject('Permission denied')")
+            requestPermissionsBestEffort(arrayOf(Manifest.permission.WRITE_CONTACTS), REQUEST_CONTACTS)
             return
         }
 
@@ -2204,13 +2765,13 @@ class CraftBridge(
             val results = activity.contentResolver.applyBatch(ContactsContract.AUTHORITY, ops)
             val contactId = ContentUris.parseId(results[0].uri!!)
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftAddContactResolve && window._craftAddContactResolve('$contactId')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftAddContactResolve && window._craftAddContactResolve(${jsQuote(contactId)})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftAddContactReject && window._craftAddContactReject('${e.message}')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftAddContactReject && window._craftAddContactReject(${jsQuote(e.message ?: "Contact could not be added")})"
+            )
         }
     }
 
@@ -2218,65 +2779,73 @@ class CraftBridge(
 
     @JavascriptInterface
     fun getCalendarEvents(startDateMs: Long, endDateMs: Long) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.getCalendarEvents(activity, startDateMs, endDateMs)) return
+
         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.READ_CALENDAR)
             != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.READ_CALENDAR), REQUEST_CALENDAR)
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftCalendarReject && window._craftCalendarReject('Permission denied')", null)
-            }
+            evaluatePromiseJavascript("window._craftCalendarReject && window._craftCalendarReject('Permission denied')")
+            requestPermissionsBestEffort(arrayOf(Manifest.permission.READ_CALENDAR), REQUEST_CALENDAR)
             return
         }
 
-        val events = JSONArray()
-        val startTime = if (startDateMs > 0) startDateMs else System.currentTimeMillis()
-        val endTime = if (endDateMs > 0) endDateMs else startTime + (30L * 24 * 60 * 60 * 1000) // 30 days
+        try {
+            val events = JSONArray()
+            val startTime = if (startDateMs > 0) startDateMs else System.currentTimeMillis()
+            val endTime = if (endDateMs > 0) endDateMs else startTime + (30L * 24 * 60 * 60 * 1000) // 30 days
 
-        val projection = arrayOf(
-            CalendarContract.Events._ID,
-            CalendarContract.Events.TITLE,
-            CalendarContract.Events.DESCRIPTION,
-            CalendarContract.Events.DTSTART,
-            CalendarContract.Events.DTEND,
-            CalendarContract.Events.EVENT_LOCATION,
-            CalendarContract.Events.ALL_DAY
-        )
+            val projection = arrayOf(
+                CalendarContract.Events._ID,
+                CalendarContract.Events.TITLE,
+                CalendarContract.Events.DESCRIPTION,
+                CalendarContract.Events.DTSTART,
+                CalendarContract.Events.DTEND,
+                CalendarContract.Events.EVENT_LOCATION,
+                CalendarContract.Events.ALL_DAY
+            )
 
-        val selection = "(${CalendarContract.Events.DTSTART} >= ?) AND (${CalendarContract.Events.DTSTART} <= ?)"
-        val selectionArgs = arrayOf(startTime.toString(), endTime.toString())
+            val selection = "(${CalendarContract.Events.DTSTART} >= ?) AND (${CalendarContract.Events.DTSTART} <= ?)"
+            val selectionArgs = arrayOf(startTime.toString(), endTime.toString())
 
-        val cursor = activity.contentResolver.query(
-            CalendarContract.Events.CONTENT_URI,
-            projection, selection, selectionArgs, CalendarContract.Events.DTSTART + " ASC"
-        )
+            val cursor = activity.contentResolver.query(
+                CalendarContract.Events.CONTENT_URI,
+                projection, selection, selectionArgs, CalendarContract.Events.DTSTART + " ASC"
+            )
 
-        cursor?.use {
-            while (it.moveToNext()) {
-                val event = JSONObject().apply {
-                    put("id", it.getString(0))
-                    put("title", it.getString(1) ?: "")
-                    put("notes", it.getString(2) ?: "")
-                    put("startDate", it.getLong(3))
-                    put("endDate", it.getLong(4))
-                    put("location", it.getString(5) ?: "")
-                    put("isAllDay", it.getInt(6) == 1)
+            cursor?.use {
+                while (it.moveToNext()) {
+                    val event = JSONObject().apply {
+                        put("id", it.getString(0))
+                        put("title", it.getString(1) ?: "")
+                        put("notes", it.getString(2) ?: "")
+                        put("startDate", it.getLong(3))
+                        put("endDate", it.getLong(4))
+                        put("location", it.getString(5) ?: "")
+                        put("isAllDay", it.getInt(6) == 1)
+                    }
+                    events.put(event)
                 }
-                events.put(event)
             }
-        }
 
-        activity.runOnUiThread {
-            webView.evaluateJavascript("window._craftCalendarResolve && window._craftCalendarResolve($events)", null)
+            evaluatePromiseJavascript("window._craftCalendarResolve && window._craftCalendarResolve($events)")
+        } catch (e: Exception) {
+            evaluatePromiseJavascript(
+                "window._craftCalendarReject && window._craftCalendarReject(${jsQuote(e.message ?: "Calendar events could not be read")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun createCalendarEvent(eventJson: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.createCalendarEvent(activity, eventJson)) return
+
         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.WRITE_CALENDAR)
             != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.WRITE_CALENDAR), REQUEST_CALENDAR)
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftCreateEventReject && window._craftCreateEventReject('Permission denied')", null)
-            }
+            evaluatePromiseJavascript("window._craftCreateEventReject && window._craftCreateEventReject('Permission denied')")
+            requestPermissionsBestEffort(arrayOf(Manifest.permission.WRITE_CALENDAR), REQUEST_CALENDAR)
             return
         }
 
@@ -2296,28 +2865,30 @@ class CraftBridge(
             val uri = activity.contentResolver.insert(CalendarContract.Events.CONTENT_URI, values)
             val eventId = uri?.lastPathSegment ?: ""
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftCreateEventResolve && window._craftCreateEventResolve('$eventId')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftCreateEventResolve && window._craftCreateEventResolve(${jsQuote(eventId)})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftCreateEventReject && window._craftCreateEventReject('${e.message}')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftCreateEventReject && window._craftCreateEventReject(${jsQuote(e.message ?: "Calendar event could not be created")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun deleteCalendarEvent(eventId: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.deleteCalendarEvent(activity, eventId)) return
+
         try {
             val uri = ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId.toLong())
             activity.contentResolver.delete(uri, null, null)
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftDeleteEventResolve && window._craftDeleteEventResolve(true)", null)
-            }
+            evaluatePromiseJavascript("window._craftDeleteEventResolve && window._craftDeleteEventResolve(true)")
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftDeleteEventReject && window._craftDeleteEventReject('${e.message}')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftDeleteEventReject && window._craftDeleteEventReject(${jsQuote(e.message ?: "Calendar event could not be deleted")})"
+            )
         }
     }
 
@@ -2325,6 +2896,11 @@ class CraftBridge(
 
     @JavascriptInterface
     fun scheduleNotification(notificationJson: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice. It declines a delayed
+        // notification before doing any of the work below.
+        if (CraftNative.scheduleNotification(activity, notificationJson)) return
+
         try {
             val notif = JSONObject(notificationJson)
             val title = notif.optString("title", "")
@@ -2352,13 +2928,13 @@ class CraftBridge(
                 notificationManager.notify(id.hashCode(), builder.build())
             }
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftNotifResolve && window._craftNotifResolve('$id')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftNotifResolve && window._craftNotifResolve(${jsQuote(id)})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftNotifReject && window._craftNotifReject('${e.message}')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftNotifReject && window._craftNotifReject(${jsQuote(e.message ?: "Notification could not be scheduled")})"
+            )
         }
     }
 
@@ -2377,12 +2953,16 @@ class CraftBridge(
 
     @JavascriptInterface
     fun cancelNotification(id: String) {
+        if (CraftNative.cancelNotification(activity, id)) return
+
         val notificationManager = activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(id.hashCode())
     }
 
     @JavascriptInterface
     fun cancelAllNotifications() {
+        if (CraftNative.cancelAllNotifications(activity)) return
+
         val notificationManager = activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancelAll()
     }
@@ -2391,6 +2971,20 @@ class CraftBridge(
 
     @JavascriptInterface
     fun getProducts(productIdsJson: String) {
+        if (CraftNative.getProducts(activity, productIdsJson)) return
+
+        val settled = java.util.concurrent.atomic.AtomicBoolean(false)
+
+        fun resolveProductRequest(products: JSONArray) {
+            if (!settled.compareAndSet(false, true) || closed) return
+            evaluatePromiseJavascript("window._craftProductsResolve && window._craftProductsResolve($products)")
+        }
+
+        fun rejectProductRequest(message: String) {
+            if (!settled.compareAndSet(false, true) || closed) return
+            rejectProducts(message)
+        }
+
         try {
             val productIds = JSONArray(productIdsJson)
             val productList = mutableListOf<String>()
@@ -2398,12 +2992,14 @@ class CraftBridge(
                 productList.add(productIds.getString(i))
             }
 
-            billingClient = BillingClient.newBuilder(activity)
+            runCatching { productBillingClient?.endConnection() }
+            val client = BillingClient.newBuilder(activity)
                 .setListener { _, _ -> }
                 .enablePendingPurchases()
                 .build()
+            productBillingClient = client
 
-            billingClient?.startConnection(object : BillingClientStateListener {
+            client.startConnection(object : BillingClientStateListener {
                 override fun onBillingSetupFinished(billingResult: BillingResult) {
                     if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
                         val params = QueryProductDetailsParams.newBuilder()
@@ -2415,96 +3011,166 @@ class CraftBridge(
                             })
                             .build()
 
-                        billingClient?.queryProductDetailsAsync(params) { result, productDetailsList ->
-                            if (result.responseCode == BillingClient.BillingResponseCode.OK) {
-                                val products = JSONArray()
-                                productDetailsList.forEach { details ->
-                                    products.put(JSONObject().apply {
-                                        put("id", details.productId)
-                                        put("displayName", details.name)
-                                        put("description", details.description)
-                                        put("price", details.oneTimePurchaseOfferDetails?.formattedPrice ?: "")
-                                    })
-                                }
-                                activity.runOnUiThread {
-                                    webView.evaluateJavascript("window._craftProductsResolve && window._craftProductsResolve($products)", null)
-                                }
-                            } else {
-                                activity.runOnUiThread {
-                                    webView.evaluateJavascript("window._craftProductsReject && window._craftProductsReject('Query failed')", null)
+                        try {
+                            client.queryProductDetailsAsync(params) { result, productDetailsList ->
+                                if (result.responseCode == BillingClient.BillingResponseCode.OK) {
+                                    val products = JSONArray()
+                                    productDetailsList.forEach { details ->
+                                        products.put(JSONObject().apply {
+                                            put("id", details.productId)
+                                            put("title", details.name)
+                                            put("displayName", details.name)
+                                            put("description", details.description)
+                                            put("price", details.oneTimePurchaseOfferDetails?.formattedPrice ?: "")
+                                        })
+                                    }
+                                    resolveProductRequest(products)
+                                } else {
+                                    rejectProductRequest("Product query failed: ${result.debugMessage}")
                                 }
                             }
+                        } catch (error: Exception) {
+                            rejectProductRequest(error.message ?: "Product query failed")
                         }
+                    } else {
+                        rejectProductRequest("Billing setup failed: ${billingResult.debugMessage}")
                     }
                 }
 
                 override fun onBillingServiceDisconnected() {
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript("window._craftProductsReject && window._craftProductsReject('Billing disconnected')", null)
-                    }
+                    rejectProductRequest("Billing disconnected")
                 }
             })
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftProductsReject && window._craftProductsReject('${e.message}')", null)
-            }
+            rejectProductRequest(e.message ?: "Product query failed")
         }
     }
 
+    private fun rejectProducts(message: String) {
+        evaluatePromiseJavascript(
+            "window._craftProductsReject && window._craftProductsReject(${jsQuote(message)})"
+        )
+    }
+
     @JavascriptInterface
     fun purchase(productId: String) {
         // Simplified - real implementation would query product details first
-        activity.runOnUiThread {
-            webView.evaluateJavascript("window._craftPurchaseReject && window._craftPurchaseReject('Purchase flow not fully implemented')", null)
-        }
+        evaluatePromiseJavascript(
+            "window._craftPurchaseReject && window._craftPurchaseReject('Purchase flow not fully implemented')"
+        )
     }
 
     @JavascriptInterface
     fun restorePurchases() {
-        billingClient?.queryPurchasesAsync(
-            QueryPurchasesParams.newBuilder().setProductType(BillingClient.ProductType.INAPP).build()
-        ) { result, purchases ->
-            if (result.responseCode == BillingClient.BillingResponseCode.OK) {
-                val restored = JSONArray()
-                purchases.forEach { purchase ->
-                    restored.put(JSONObject().apply {
-                        put("productId", purchase.products.firstOrNull())
-                        put("orderId", purchase.orderId)
-                    })
-                }
-                activity.runOnUiThread {
-                    webView.evaluateJavascript("window._craftRestoreResolve && window._craftRestoreResolve($restored)", null)
-                }
-            } else {
-                activity.runOnUiThread {
-                    webView.evaluateJavascript("window._craftRestoreReject && window._craftRestoreReject('Restore failed')", null)
-                }
-            }
-        }
-    }
+        if (CraftNative.restorePurchases(activity)) return
 
-    // ==================== Keep Awake ====================
+        val settled = java.util.concurrent.atomic.AtomicBoolean(false)
 
-    @JavascriptInterface
-    fun setKeepAwake(enabled: Boolean): Boolean {
-        activity.runOnUiThread {
-            if (enabled) {
-                activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-            } else {
-                activity.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-            }
-            isKeepingAwake = enabled
+        fun resolveRestoreRequest(restored: JSONArray) {
+            if (!settled.compareAndSet(false, true) || closed) return
+            evaluatePromiseJavascript("window._craftRestoreResolve && window._craftRestoreResolve($restored)")
         }
-        return true
-    }
 
-    // ==================== Orientation Lock ====================
+        fun rejectRestoreRequest(message: String) {
+            if (!settled.compareAndSet(false, true) || closed) return
+            rejectRestore(message)
+        }
 
-    @JavascriptInterface
-    fun lockOrientation(orientation: String): Boolean {
-        activity.runOnUiThread {
-            activity.requestedOrientation = when (orientation) {
-                "portrait" -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+        val connectedClient = restoreBillingClient
+        if (connectedClient != null && connectedClient.isReady) {
+            queryRestoredPurchases(connectedClient, ::resolveRestoreRequest, ::rejectRestoreRequest)
+            return
+        }
+
+        try {
+            val client = connectedClient ?: BillingClient.newBuilder(activity)
+                .setListener { _, _ -> }
+                .enablePendingPurchases()
+                .build()
+                .also { restoreBillingClient = it }
+
+            client.startConnection(object : BillingClientStateListener {
+                override fun onBillingSetupFinished(billingResult: BillingResult) {
+                    if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
+                        queryRestoredPurchases(client, ::resolveRestoreRequest, ::rejectRestoreRequest)
+                    } else {
+                        rejectRestoreRequest("Billing setup failed: ${billingResult.debugMessage}")
+                    }
+                }
+
+                override fun onBillingServiceDisconnected() {
+                    rejectRestoreRequest("Billing disconnected")
+                }
+            })
+        } catch (error: Exception) {
+            rejectRestoreRequest(error.message ?: "Billing connection failed")
+        }
+    }
+
+    private fun queryRestoredPurchases(
+        client: BillingClient,
+        resolve: (JSONArray) -> Unit,
+        reject: (String) -> Unit
+    ) {
+        try {
+            client.queryPurchasesAsync(
+                QueryPurchasesParams.newBuilder().setProductType(BillingClient.ProductType.INAPP).build()
+            ) { result, purchases ->
+                if (result.responseCode == BillingClient.BillingResponseCode.OK) {
+                    val restored = JSONArray()
+                    purchases.forEach { purchase ->
+                        restored.put(JSONObject().apply {
+                            put("productId", purchase.products.firstOrNull())
+                            put("orderId", purchase.orderId)
+                        })
+                    }
+                    resolve(restored)
+                } else {
+                    reject("Restore failed: ${result.debugMessage}")
+                }
+            }
+        } catch (error: Exception) {
+            reject(error.message ?: "Restore failed")
+        }
+    }
+
+    private fun rejectRestore(message: String) {
+        evaluatePromiseJavascript(
+            "window._craftRestoreReject && window._craftRestoreReject(${jsQuote(message)})"
+        )
+    }
+
+    // ==================== Keep Awake ====================
+
+    @JavascriptInterface
+    fun setKeepAwake(enabled: Boolean): Boolean {
+        // Zig queues the same window call on the same looper. isKeepingAwake
+        // below is written here and read nowhere, so the Kotlin body not
+        // running leaves nothing stale — unlike the flashlight pair.
+        if (CraftNative.setKeepAwake(activity, enabled)) return true
+
+        activity.runOnUiThread {
+            if (enabled) {
+                activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+            } else {
+                activity.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+            }
+            isKeepingAwake = enabled
+        }
+        return true
+    }
+
+    // ==================== Orientation Lock ====================
+
+    @JavascriptInterface
+    fun lockOrientation(orientation: String): Boolean {
+        // Zig queues the same work on the same looper, through a Runnable
+        // this file's holder owns — see CraftNative.runOnMain.
+        if (CraftNative.lockOrientation(activity, orientation)) return true
+
+        activity.runOnUiThread {
+            activity.requestedOrientation = when (orientation) {
+                "portrait" -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
                 "landscape" -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
                 "landscapeLeft" -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
                 "landscapeRight" -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
@@ -2516,6 +3182,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun unlockOrientation(): Boolean {
+        if (CraftNative.unlockOrientation(activity)) return true
+
         activity.runOnUiThread {
             activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
         }
@@ -2539,29 +3207,51 @@ class CraftBridge(
     @JavascriptInterface
     fun scanQRCode() {
         // Uses ML Kit barcode scanning - requires camera permission
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftQRReject && window._craftQRReject('QR scanning requires camera integration - use native camera intent')",
-                null
-            )
-        }
+        evaluatePromiseJavascript(
+            "window._craftQRReject && window._craftQRReject('QR scanning requires camera integration - use native camera intent')"
+        )
     }
 
     // ==================== File Picker ====================
 
     @JavascriptInterface
     fun pickFile(typesJson: String) {
-        val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
-            addCategory(Intent.CATEGORY_OPENABLE)
-            type = "*/*"
+        val requestedTypes = try {
+            val values = JSONArray(typesJson)
+            (0 until values.length()).map { index -> values.getString(index) }.also { types ->
+                require(types.all { MIME_TYPE.matches(it) }) { "Invalid file-picker MIME type" }
+            }
+        } catch (error: Exception) {
+            rejectFilePicker(error.message ?: "File-picker types are invalid")
+            return
+        }
+        // The native launcher has no MIME-type argument. It remains the fast
+        // path for an unrestricted picker; filtered requests stay here so the
+        // contract the page asked for reaches Android's document provider.
+        if (requestedTypes.isEmpty() && CraftNative.pickFile(activity)) return
+
+        try {
+            val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
+                addCategory(Intent.CATEGORY_OPENABLE)
+                type = if (requestedTypes.size == 1) requestedTypes[0] else "*/*"
+                if (requestedTypes.size > 1) {
+                    putExtra(Intent.EXTRA_MIME_TYPES, requestedTypes.toTypedArray())
+                }
+            }
+            activity.startActivityForResult(intent, REQUEST_FILE_PICKER)
+        } catch (error: Exception) {
+            rejectFilePicker(error.message ?: "File picker could not be opened")
         }
-        activity.startActivityForResult(intent, REQUEST_FILE_PICKER)
     }
 
     // ==================== File Download ====================
 
     @JavascriptInterface
     fun downloadFile(url: String, filename: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.downloadFile(activity, url, filename)) return
+
         try {
             val request = DownloadManager.Request(Uri.parse(url)).apply {
                 setTitle(filename)
@@ -2573,24 +3263,22 @@ class CraftBridge(
             val downloadManager = activity.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
             val downloadId = downloadManager.enqueue(request)
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftDownloadResolve && window._craftDownloadResolve('$downloadId')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftDownloadResolve && window._craftDownloadResolve(${jsQuote(downloadId)})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftDownloadReject && window._craftDownloadReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftDownloadReject && window._craftDownloadReject(${jsQuote(e.message ?: "Download could not be started")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun saveFile(data: String, filename: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.saveFile(activity, data, filename)) return
+
         try {
             val documentsDir = activity.getExternalFilesDir(android.os.Environment.DIRECTORY_DOCUMENTS)
             val file = File(documentsDir, filename)
@@ -2598,53 +3286,50 @@ class CraftBridge(
             if (data.startsWith("data:")) {
                 // Base64 data URL
                 val parts = data.split(",")
-                if (parts.size == 2) {
-                    val bytes = Base64.decode(parts[1], Base64.DEFAULT)
-                    file.writeBytes(bytes)
+                if (parts.size != 2) {
+                    rejectSaveFile("Malformed data URL")
+                    return
                 }
+                val bytes = Base64.decode(parts[1], Base64.DEFAULT)
+                file.writeBytes(bytes)
             } else {
                 file.writeText(data)
             }
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftSaveResolve && window._craftSaveResolve('${file.absolutePath}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftSaveResolve && window._craftSaveResolve(${jsQuote(file.absolutePath)})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftSaveReject && window._craftSaveReject('${e.message}')",
-                    null
-                )
-            }
+            rejectSaveFile(e.message)
         }
     }
 
+    private fun rejectSaveFile(message: String?) {
+        evaluatePromiseJavascript(
+            "window._craftSaveReject && window._craftSaveReject(${jsQuote(message ?: "File save failed")})"
+        )
+    }
+
     // ==================== Google Sign In ====================
 
     @JavascriptInterface
     fun signInWithGoogle() {
         // Google Sign In requires configuration in build.gradle
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftGoogleReject && window._craftGoogleReject('Google Sign In requires app configuration')",
-                null
-            )
-        }
+        evaluatePromiseJavascript(
+            "window._craftGoogleReject && window._craftGoogleReject('Google Sign In requires app configuration')"
+        )
     }
 
     // ==================== Audio Recording ====================
 
     @JavascriptInterface
     fun startAudioRecording() {
+        if (CraftNative.startAudioRecording(activity)) return
+
         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.RECORD_AUDIO)
             != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.RECORD_AUDIO), REQUEST_AUDIO)
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftAudioReject && window._craftAudioReject('Permission denied')", null)
-            }
+            evaluatePromiseJavascript("window._craftAudioReject && window._craftAudioReject('Permission denied')")
+            requestPermissionsBestEffort(arrayOf(Manifest.permission.RECORD_AUDIO), REQUEST_AUDIO)
             return
         }
 
@@ -2668,18 +3353,18 @@ class CraftBridge(
                 start()
             }
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftAudioResolve && window._craftAudioResolve(true)", null)
-            }
+            evaluatePromiseJavascript("window._craftAudioResolve && window._craftAudioResolve(true)")
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftAudioReject && window._craftAudioReject('${e.message}')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftAudioReject && window._craftAudioReject(${jsQuote(e.message ?: "Audio recording could not start")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun stopAudioRecording() {
+        if (CraftNative.stopAudioRecording(activity)) return
+
         try {
             mediaRecorder?.stop()
             mediaRecorder?.release()
@@ -2688,18 +3373,18 @@ class CraftBridge(
             audioFile?.let { file ->
                 val bytes = file.readBytes()
                 val base64 = "data:audio/m4a;base64," + Base64.encodeToString(bytes, Base64.NO_WRAP)
-                activity.runOnUiThread {
-                    webView.evaluateJavascript("window._craftAudioStopResolve && window._craftAudioStopResolve('$base64')", null)
-                }
+                evaluatePromiseJavascript(
+                    "window._craftAudioStopResolve && window._craftAudioStopResolve(${jsQuote(base64)})"
+                )
             } ?: run {
-                activity.runOnUiThread {
-                    webView.evaluateJavascript("window._craftAudioStopReject && window._craftAudioStopReject('No recording')", null)
-                }
+                evaluatePromiseJavascript(
+                    "window._craftAudioStopReject && window._craftAudioStopReject('No recording')"
+                )
             }
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftAudioStopReject && window._craftAudioStopReject('${e.message}')", null)
-            }
+            evaluatePromiseJavascript(
+                "window._craftAudioStopReject && window._craftAudioStopReject(${jsQuote(e.message ?: "Audio recording could not stop")})"
+            )
         }
     }
 
@@ -2707,16 +3392,29 @@ class CraftBridge(
 
     @JavascriptInterface
     fun startVideoRecording() {
-        val intent = Intent(MediaStore.ACTION_VIDEO_CAPTURE).apply {
-            putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1)
+        if (CraftNative.startVideoRecording(activity)) return
+
+        try {
+            val intent = Intent(MediaStore.ACTION_VIDEO_CAPTURE).apply {
+                putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1)
+            }
+            activity.startActivityForResult(intent, REQUEST_VIDEO)
+        } catch (error: Exception) {
+            evaluatePromiseJavascript(
+                "window._craftVideoReject && window._craftVideoReject(${jsQuote(error.message ?: "Video capture could not be opened")})"
+            )
         }
-        activity.startActivityForResult(intent, REQUEST_VIDEO)
     }
 
     // ==================== Motion Sensors ====================
 
     @JavascriptInterface
     fun startMotionUpdates(intervalMs: Int): Boolean {
+        // The SensorEventListener object is CraftNative's, and so is the
+        // last-value bookkeeping — which is why stopMotionUpdates has to reach
+        // the same way, or its own fields stay null and nothing unregisters.
+        if (CraftNative.startMotionUpdates(activity, intervalMs)) return true
+
         sensorManager = activity.getSystemService(Context.SENSOR_SERVICE) as SensorManager
         accelerometer = sensorManager?.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
         gyroscope = sensorManager?.getDefaultSensor(Sensor.TYPE_GYROSCOPE)
@@ -2758,6 +3456,8 @@ class CraftBridge(
 
     @JavascriptInterface
     fun stopMotionUpdates() {
+        if (CraftNative.stopMotionUpdates(activity)) return
+
         sensorListener?.let { sensorManager?.unregisterListener(it) }
         sensorListener = null
     }
@@ -2771,24 +3471,29 @@ class CraftBridge(
                 database = activity.openOrCreateDatabase("craft.db", Context.MODE_PRIVATE, null)
             }
 
+            // After the open, so Zig borrows this connection rather than
+            // starting a second one against the same file. Zig answers through
+            // the reply channel, so returning is what stops the promise being
+            // settled twice.
+            database?.let { if (CraftNative.dbExecute(it, sql, paramsJson)) return }
+
             val params = JSONArray(paramsJson)
             val args = Array(params.length()) { params.getString(it) }
 
-            database?.execSQL(sql, args)
-
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftDbExecResolve && window._craftDbExecResolve({rowsAffected: 1})",
-                    null
-                )
+            val rowsAffected = database!!.compileStatement(sql).use { statement ->
+                args.forEachIndexed { index, value ->
+                    statement.bindString(index + 1, value)
+                }
+                statement.executeUpdateDelete()
             }
+
+            evaluatePromiseJavascript(
+                "window._craftDbExecResolve && window._craftDbExecResolve({rowsAffected: $rowsAffected})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftDbExecReject && window._craftDbExecReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftDbExecReject && window._craftDbExecReject(${jsQuote(e.message ?: "Database execution failed")})"
+            )
         }
     }
 
@@ -2799,6 +3504,8 @@ class CraftBridge(
                 database = activity.openOrCreateDatabase("craft.db", Context.MODE_PRIVATE, null)
             }
 
+            database?.let { if (CraftNative.dbQuery(it, sql, paramsJson)) return }
+
             val params = JSONArray(paramsJson)
             val args = Array(params.length()) { params.getString(it) }
 
@@ -2816,19 +3523,11 @@ class CraftBridge(
                 }
             }
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftDbQueryResolve && window._craftDbQueryResolve($results)",
-                    null
-                )
-            }
+            evaluatePromiseJavascript("window._craftDbQueryResolve && window._craftDbQueryResolve($results)")
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftDbQueryReject && window._craftDbQueryReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftDbQueryReject && window._craftDbQueryReject(${jsQuote(e.message ?: "Database query failed")})"
+            )
         }
     }
 
@@ -2836,22 +3535,57 @@ class CraftBridge(
 
     @JavascriptInterface
     fun startBluetoothScan() {
+        // The ScanCallback object is CraftNative's, and so are the scanner and
+        // callback fields — which is why stopBluetoothScan has to reach the
+        // same way, or its own fields stay null and stopScan is never called.
+        if (CraftNative.startBluetoothScan(activity)) return
+
         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.BLUETOOTH_SCAN)
             != PackageManager.PERMISSION_GRANTED) {
+            rejectBluetoothScan("Bluetooth permission denied")
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.BLUETOOTH_SCAN), REQUEST_BLUETOOTH)
-            }
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftBleReject && window._craftBleReject('Permission denied')", null)
+                requestPermissionsBestEffort(arrayOf(Manifest.permission.BLUETOOTH_SCAN), REQUEST_BLUETOOTH)
             }
             return
         }
 
-        val bluetoothManager = activity.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
-        bluetoothAdapter = bluetoothManager.adapter
-        bluetoothScanner = bluetoothAdapter?.bluetoothLeScanner
+        val bluetoothManager = activity.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
+        if (bluetoothManager == null) {
+            rejectBluetoothScan("Bluetooth is unavailable on this device")
+            return
+        }
+        val adapter = try {
+            bluetoothManager.adapter
+        } catch (e: SecurityException) {
+            rejectBluetoothScan("Bluetooth permission denied")
+            return
+        }
+        if (adapter == null) {
+            rejectBluetoothScan("Bluetooth is unavailable on this device")
+            return
+        }
+        val enabled = try {
+            adapter.isEnabled
+        } catch (e: SecurityException) {
+            rejectBluetoothScan("Bluetooth permission denied")
+            return
+        }
+        if (!enabled) {
+            rejectBluetoothScan("Bluetooth is switched off")
+            return
+        }
+        val scanner = try {
+            adapter.bluetoothLeScanner
+        } catch (e: SecurityException) {
+            rejectBluetoothScan("Bluetooth permission denied")
+            return
+        }
+        if (scanner == null) {
+            rejectBluetoothScan("Bluetooth LE scanning is unavailable")
+            return
+        }
 
-        bleScanCallback = object : ScanCallback() {
+        val callback = object : ScanCallback() {
             override fun onScanResult(callbackType: Int, result: ScanResult) {
                 sendEvent("craftBluetoothDevice", mapOf(
                     "id" to result.device.address,
@@ -2861,14 +3595,31 @@ class CraftBridge(
             }
         }
 
-        bluetoothScanner?.startScan(bleScanCallback)
-        activity.runOnUiThread {
-            webView.evaluateJavascript("window._craftBleResolve && window._craftBleResolve(true)", null)
+        try {
+            scanner.startScan(callback)
+        } catch (e: SecurityException) {
+            rejectBluetoothScan("Bluetooth permission denied")
+            return
+        } catch (e: RuntimeException) {
+            rejectBluetoothScan("Bluetooth scan could not start")
+            return
         }
+        bluetoothAdapter = adapter
+        bluetoothScanner = scanner
+        bleScanCallback = callback
+        evaluatePromiseJavascript("window._craftBleResolve && window._craftBleResolve(true)")
+    }
+
+    private fun rejectBluetoothScan(message: String) {
+        evaluatePromiseJavascript(
+            "window._craftBleReject && window._craftBleReject(${jsQuote(message)})"
+        )
     }
 
     @JavascriptInterface
     fun stopBluetoothScan() {
+        if (CraftNative.stopBluetoothScan(activity)) return
+
         bleScanCallback?.let { bluetoothScanner?.stopScan(it) }
         bleScanCallback = null
     }
@@ -2879,15 +3630,13 @@ class CraftBridge(
     fun scanNFC() {
         val nfcAdapter = NfcAdapter.getDefaultAdapter(activity)
         if (nfcAdapter == null || !nfcAdapter.isEnabled) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript("window._craftNfcReject && window._craftNfcReject('NFC not available')", null)
-            }
+            evaluatePromiseJavascript("window._craftNfcReject && window._craftNfcReject('NFC not available')")
             return
         }
         // NFC requires foreground dispatch - simplified implementation
-        activity.runOnUiThread {
-            webView.evaluateJavascript("window._craftNfcReject && window._craftNfcReject('NFC requires activity integration')", null)
-        }
+        evaluatePromiseJavascript(
+            "window._craftNfcReject && window._craftNfcReject('NFC requires activity integration')"
+        )
     }
 
     // ==================== Fitness ====================
@@ -2907,32 +3656,137 @@ class CraftBridge(
         healthConnect.saveWorkout(workoutJson)
     }
 
-    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean =
-        healthConnect.onActivityResult(requestCode, resultCode, data)
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean {
+        if (closed) return requestCode == REQUEST_CAMERA || requestCode == REQUEST_GALLERY ||
+            requestCode == REQUEST_FILE_PICKER || requestCode == REQUEST_VIDEO ||
+            requestCode == REQUEST_PICK_CONTACT
+
+        return when (requestCode) {
+            REQUEST_CAMERA, REQUEST_GALLERY -> {
+                handleImageResult(requestCode, resultCode, data)
+                true
+            }
+            REQUEST_FILE_PICKER -> {
+                handleFilePickerResult(resultCode, data)
+                true
+            }
+            REQUEST_VIDEO -> {
+                handleVideoResult(resultCode, data)
+                true
+            }
+            REQUEST_PICK_CONTACT -> {
+                handleContactPickerResult(resultCode, data)
+                true
+            }
+            else -> healthConnect.onActivityResult(requestCode, resultCode, data)
+        }
+    }
 
     fun close() {
+        closed = true
+        currentPositionSequence.incrementAndGet()
+        activity.runOnUiThread {
+            runCatching {
+                webView.evaluateJavascript(
+                    "window.__craftRejectPendingPromises && window.__craftRejectPendingPromises('Android bridge closed');" +
+                        "window.__craftRejectPermissionRequests && window.__craftRejectPermissionRequests('Android bridge closed')",
+                    null
+                )
+            }
+        }
+        CraftNative.close(activity)
         healthConnect.close()
+
+        runCatching { speechRecognizer?.cancel() }
+        runCatching { speechRecognizer?.destroy() }
+        speechRecognizer = null
+        runCatching { biometricPrompt?.cancelAuthentication() }
+        biometricPrompt = null
+
+        mediaRecorder?.let { recorder ->
+            runCatching { recorder.stop() }
+            runCatching { recorder.release() }
+        }
+        mediaRecorder = null
+        audioFile?.delete()
+        audioFile = null
+
+        locationCallbacks.values.forEach { callback ->
+            runCatching { fusedLocationClient?.removeLocationUpdates(callback) }
+        }
+        locationCallbacks.clear()
+        oneShotLocationCallbacks.forEach { callback ->
+            runCatching { fusedLocationClient?.removeLocationUpdates(callback) }
+        }
+        oneShotLocationCallbacks.clear()
+        oneShotLocationTimeouts.values.forEach { timeout ->
+            oneShotLocationHandler.removeCallbacks(timeout)
+        }
+        oneShotLocationTimeouts.clear()
+
+        networkCallback?.let { callback ->
+            val manager = activity.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+            runCatching { manager.unregisterNetworkCallback(callback) }
+        }
+        networkCallback = null
+        ProcessLifecycleOwner.get().lifecycle.removeObserver(appStateObserver)
+
+        sensorListener?.let { listener ->
+            runCatching { sensorManager?.unregisterListener(listener) }
+        }
+        sensorListener = null
+        sensorManager = null
+
+        bleScanCallback?.let { callback ->
+            runCatching { bluetoothScanner?.stopScan(callback) }
+        }
+        bleScanCallback = null
+        bluetoothScanner = null
+        bluetoothAdapter = null
+
+        runCatching { productBillingClient?.endConnection() }
+        productBillingClient = null
+        runCatching { restoreBillingClient?.endConnection() }
+        restoreBillingClient = null
+        runCatching { database?.close() }
+        database = null
+
+        if (isFlashlightOn) setFlashlight(false)
+        activity.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        isKeepingAwake = false
+        pendingPermissionRequests.clear()
+        pendingEvents.clear()
     }
 
     // ==================== Screen Capture ====================
 
     @JavascriptInterface
     fun takeScreenshot() {
+        if (CraftNative.takeScreenshot(activity, webView)) return
+
         activity.runOnUiThread {
+            if (closed) return@runOnUiThread
             try {
                 val view = webView.rootView
-                view.isDrawingCacheEnabled = true
-                view.buildDrawingCache()
-                val bitmap = Bitmap.createBitmap(view.drawingCache)
-                view.isDrawingCacheEnabled = false
+                val bitmap = try {
+                    view.isDrawingCacheEnabled = true
+                    view.buildDrawingCache()
+                    Bitmap.createBitmap(view.drawingCache)
+                } finally {
+                    view.isDrawingCacheEnabled = false
+                }
 
                 val outputStream = ByteArrayOutputStream()
                 bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
                 val base64 = "data:image/png;base64," + Base64.encodeToString(outputStream.toByteArray(), Base64.NO_WRAP)
 
-                webView.evaluateJavascript("window._craftScreenshotResolve && window._craftScreenshotResolve('$base64')", null)
+                evaluatePromiseJavascript(
+                    "window._craftScreenshotResolve && window._craftScreenshotResolve(${jsQuote(base64)})"
+                )
             } catch (e: Exception) {
-                webView.evaluateJavascript("window._craftScreenshotReject && window._craftScreenshotReject('${e.message}')", null)
+                evaluatePromiseJavascript(
+                    "window._craftScreenshotReject && window._craftScreenshotReject(${jsQuote(e.message ?: "Screenshot failed")})"
+                )
             }
         }
     }
@@ -2941,89 +3795,44 @@ class CraftBridge(
 
     @JavascriptInterface
     fun registerBackgroundTask(taskId: String) {
-        try {
-            // WorkManager tasks don't require explicit registration, just track them
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBgTaskResolve && window._craftBgTaskResolve({taskId: '$taskId', registered: true})",
-                    null
-                )
-            }
-        } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBgTaskReject && window._craftBgTaskReject('${e.message}')",
-                    null
-                )
-            }
-        }
+        rejectBackgroundTask(taskId)
     }
 
     @JavascriptInterface
+    @Suppress("UNUSED_PARAMETER")
     fun scheduleBackgroundTask(taskId: String, delay: Long, requiresNetwork: Boolean, requiresCharging: Boolean) {
-        try {
-            // Note: Full WorkManager implementation requires adding the dependency
-            // implementation 'androidx.work:work-runtime-ktx:2.9.0'
-            // This is a placeholder that shows the API structure
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBgTaskResolve && window._craftBgTaskResolve({taskId: '$taskId', scheduled: true, delay: $delay})",
-                    null
-                )
-            }
-        } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBgTaskReject && window._craftBgTaskReject('${e.message}')",
-                    null
-                )
-            }
-        }
+        rejectBackgroundTask(taskId)
     }
 
     @JavascriptInterface
     fun cancelBackgroundTask(taskId: String) {
-        try {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBgTaskResolve && window._craftBgTaskResolve({taskId: '$taskId', cancelled: true})",
-                    null
-                )
-            }
-        } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBgTaskReject && window._craftBgTaskReject('${e.message}')",
-                    null
-                )
-            }
-        }
+        rejectBackgroundTask(taskId)
     }
 
     @JavascriptInterface
     fun cancelAllBackgroundTasks() {
-        try {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBgTaskResolve && window._craftBgTaskResolve({cancelled: true})",
-                    null
-                )
-            }
-        } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftBgTaskReject && window._craftBgTaskReject('${e.message}')",
-                    null
-                )
-            }
+        rejectBackgroundTask()
+    }
+
+    private fun rejectBackgroundTask(taskId: String? = null) {
+        val message = if (taskId == null) {
+            "Background tasks are unavailable on Android"
+        } else {
+            "Background task $taskId is unavailable on Android"
         }
+        evaluatePromiseJavascript(
+            "window._craftBgTaskReject && window._craftBgTaskReject(${jsQuote(message)})"
+        )
     }
 
     // ==================== PDF Viewer ====================
 
     @JavascriptInterface
     fun openPDF(source: String, page: Int) {
+        if (CraftNative.openPDF(activity, source, page)) return
+
         activity.runOnUiThread {
+            if (closed) return@runOnUiThread
             try {
                 val uri = if (source.startsWith("data:")) {
                     // Save base64 to temp file and open
@@ -3043,14 +3852,12 @@ class CraftBridge(
                 }
 
                 activity.startActivity(intent)
-                webView.evaluateJavascript(
-                    "window._craftPDFResolve && window._craftPDFResolve({opened: true})",
-                    null
+                evaluatePromiseJavascript(
+                    "window._craftPDFResolve && window._craftPDFResolve({opened: true})"
                 )
             } catch (e: Exception) {
-                webView.evaluateJavascript(
-                    "window._craftPDFReject && window._craftPDFReject('${e.message}')",
-                    null
+                evaluatePromiseJavascript(
+                    "window._craftPDFReject && window._craftPDFReject(${jsQuote(e.message ?: "PDF could not be opened")})"
                 )
             }
         }
@@ -3059,38 +3866,39 @@ class CraftBridge(
     @JavascriptInterface
     fun closePDF() {
         // PDFs are opened in external viewers, so we just acknowledge
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftPDFResolve && window._craftPDFResolve(true)",
-                null
-            )
-        }
+        evaluatePromiseJavascript("window._craftPDFResolve && window._craftPDFResolve(true)")
     }
 
     // ==================== Contacts Picker ====================
 
     @JavascriptInterface
     fun pickContact(multiple: Boolean) {
+        // `multiple` is ignored by both implementations: Android still opens
+        // the platform's single-contact ACTION_PICK surface.
         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.READ_CONTACTS)
             != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.READ_CONTACTS), REQUEST_PICK_CONTACT)
+            rejectContactPicker("Contacts permission is required; retry after granting it")
+            requestPermissionsBestEffort(arrayOf(Manifest.permission.READ_CONTACTS), REQUEST_PICK_CONTACT)
             return
         }
 
+        if (CraftNative.pickContact(activity)) return
+
         activity.runOnUiThread {
-            val intent = Intent(Intent.ACTION_PICK, ContactsContract.Contacts.CONTENT_URI)
-            activity.startActivityForResult(intent, REQUEST_PICK_CONTACT)
+            if (closed) return@runOnUiThread
+            try {
+                val intent = Intent(Intent.ACTION_PICK, ContactsContract.Contacts.CONTENT_URI)
+                activity.startActivityForResult(intent, REQUEST_PICK_CONTACT)
+            } catch (error: Exception) {
+                rejectContactPicker(error.message ?: "Contact picker could not be opened")
+            }
         }
     }
 
     fun handleContactPickerResult(resultCode: Int, data: Intent?) {
+        if (closed) return
         if (resultCode != Activity.RESULT_OK || data?.data == null) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftPickContactReject && window._craftPickContactReject('Cancelled')",
-                    null
-                )
-            }
+            rejectContactPicker("Cancelled")
             return
         }
 
@@ -3101,77 +3909,94 @@ class CraftBridge(
                 ContactsContract.Contacts.DISPLAY_NAME
             )
 
-            activity.contentResolver.query(contactUri, projection, null, null, null)?.use { cursor ->
-                if (cursor.moveToFirst()) {
-                    val contactId = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.Contacts._ID))
-                    val displayName = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.Contacts.DISPLAY_NAME))
-
-                    // Get phone numbers
-                    val phones = mutableListOf<Map<String, String>>()
-                    activity.contentResolver.query(
-                        ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
-                        arrayOf(ContactsContract.CommonDataKinds.Phone.NUMBER, ContactsContract.CommonDataKinds.Phone.TYPE),
-                        "${ContactsContract.CommonDataKinds.Phone.CONTACT_ID} = ?",
-                        arrayOf(contactId),
-                        null
-                    )?.use { phoneCursor ->
-                        while (phoneCursor.moveToNext()) {
-                            val number = phoneCursor.getString(phoneCursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.NUMBER))
-                            phones.add(mapOf("number" to number))
-                        }
-                    }
+            val contact = activity.contentResolver.query(contactUri, projection, null, null, null)?.use { cursor ->
+                if (!cursor.moveToFirst()) return@use null
 
-                    // Get emails
-                    val emails = mutableListOf<Map<String, String>>()
-                    activity.contentResolver.query(
-                        ContactsContract.CommonDataKinds.Email.CONTENT_URI,
-                        arrayOf(ContactsContract.CommonDataKinds.Email.ADDRESS),
-                        "${ContactsContract.CommonDataKinds.Email.CONTACT_ID} = ?",
-                        arrayOf(contactId),
-                        null
-                    )?.use { emailCursor ->
-                        while (emailCursor.moveToNext()) {
-                            val address = emailCursor.getString(emailCursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Email.ADDRESS))
-                            emails.add(mapOf("address" to address))
-                        }
-                    }
+                val contactId = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.Contacts._ID))
+                val displayName = cursor.getString(cursor.getColumnIndexOrThrow(ContactsContract.Contacts.DISPLAY_NAME))
 
-                    val result = JSONObject().apply {
-                        put("id", contactId)
-                        put("displayName", displayName)
-                        put("phoneNumbers", JSONArray(phones.map { JSONObject(it) }))
-                        put("emailAddresses", JSONArray(emails.map { JSONObject(it) }))
+                // Get phone numbers
+                val phones = mutableListOf<Map<String, String>>()
+                activity.contentResolver.query(
+                    ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
+                    arrayOf(ContactsContract.CommonDataKinds.Phone.NUMBER, ContactsContract.CommonDataKinds.Phone.TYPE),
+                    "${ContactsContract.CommonDataKinds.Phone.CONTACT_ID} = ?",
+                    arrayOf(contactId),
+                    null
+                )?.use { phoneCursor ->
+                    while (phoneCursor.moveToNext()) {
+                        val number = phoneCursor.getString(phoneCursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Phone.NUMBER))
+                        phones.add(mapOf("number" to number))
                     }
+                }
 
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftPickContactResolve && window._craftPickContactResolve($result)",
-                            null
-                        )
+                // Get emails
+                val emails = mutableListOf<Map<String, String>>()
+                activity.contentResolver.query(
+                    ContactsContract.CommonDataKinds.Email.CONTENT_URI,
+                    arrayOf(ContactsContract.CommonDataKinds.Email.ADDRESS),
+                    "${ContactsContract.CommonDataKinds.Email.CONTACT_ID} = ?",
+                    arrayOf(contactId),
+                    null
+                )?.use { emailCursor ->
+                    while (emailCursor.moveToNext()) {
+                        val address = emailCursor.getString(emailCursor.getColumnIndexOrThrow(ContactsContract.CommonDataKinds.Email.ADDRESS))
+                        emails.add(mapOf("address" to address))
                     }
                 }
+
+                JSONObject().apply {
+                    put("id", contactId)
+                    put("displayName", displayName)
+                    put("phoneNumbers", JSONArray(phones.map { JSONObject(it) }))
+                    put("emailAddresses", JSONArray(emails.map { JSONObject(it) }))
+                }
             }
-        } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftPickContactReject && window._craftPickContactReject('${e.message}')",
-                    null
-                )
+
+            if (contact == null) {
+                rejectContactPicker("Selected contact could not be read")
+                return
             }
+
+            evaluatePromiseJavascript(
+                "window._craftPickContactResolve && window._craftPickContactResolve($contact)"
+            )
+        } catch (e: Exception) {
+            evaluatePromiseJavascript(
+                "window._craftPickContactReject && window._craftPickContactReject(${jsQuote(e.message ?: "Selected contact could not be read")})"
+            )
         }
     }
 
+    private fun rejectContactPicker(message: String) {
+        evaluatePromiseJavascript(
+            "window._craftPickContactReject && window._craftPickContactReject(${jsQuote(message)})"
+        )
+    }
+
     // ==================== App Shortcuts ====================
 
+    fun dispatchShortcut(type: String) {
+        activity.runOnUiThread {
+            val data = mapOf<String, Any>("type" to type)
+            if (bridgeReady) {
+                sendEvent("craftShortcut", data)
+            } else {
+                pendingEvents.add("craftShortcut" to data)
+            }
+        }
+    }
+
     @JavascriptInterface
     fun setShortcuts(shortcutsJson: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.setShortcuts(activity, shortcutsJson)) return
+
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftShortcutsReject && window._craftShortcutsReject('App shortcuts require Android 7.1+')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftShortcutsReject && window._craftShortcutsReject('App shortcuts require Android 7.1+')"
+            )
             return
         }
 
@@ -3202,50 +4027,33 @@ class CraftBridge(
 
             shortcutManager?.dynamicShortcuts = shortcuts
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftShortcutsResolve && window._craftShortcutsResolve({count: ${shortcuts.size}})",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftShortcutsResolve && window._craftShortcutsResolve({set: true, count: ${shortcuts.size}})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftShortcutsReject && window._craftShortcutsReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftShortcutsReject && window._craftShortcutsReject(${jsQuote(e.message ?: "Shortcuts could not be set")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun clearShortcuts() {
+        if (CraftNative.clearShortcuts(activity)) return
+
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
             try {
                 val shortcutManager = activity.getSystemService(android.content.pm.ShortcutManager::class.java)
                 shortcutManager?.removeAllDynamicShortcuts()
 
-                activity.runOnUiThread {
-                    webView.evaluateJavascript(
-                        "window._craftShortcutsResolve && window._craftShortcutsResolve(true)",
-                        null
-                    )
-                }
+                evaluatePromiseJavascript("window._craftShortcutsResolve && window._craftShortcutsResolve({cleared: true})")
             } catch (e: Exception) {
-                activity.runOnUiThread {
-                    webView.evaluateJavascript(
-                        "window._craftShortcutsReject && window._craftShortcutsReject('${e.message}')",
-                        null
-                    )
-                }
-            }
-        } else {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftShortcutsResolve && window._craftShortcutsResolve(true)",
-                    null
+                evaluatePromiseJavascript(
+                    "window._craftShortcutsReject && window._craftShortcutsReject(${jsQuote(e.message ?: "Shortcuts could not be cleared")})"
                 )
             }
+        } else {
+            evaluatePromiseJavascript("window._craftShortcutsResolve && window._craftShortcutsResolve({cleared: true})")
         }
     }
 
@@ -3253,111 +4061,95 @@ class CraftBridge(
 
     @JavascriptInterface
     fun setSharedItem(key: String, value: String, group: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.setSharedItem(activity, key, value, group)) return
+
         try {
             val prefsName = if (group.isNotEmpty()) "craft_shared_$group" else "craft_shared"
             val prefs = activity.getSharedPreferences(prefsName, Context.MODE_PRIVATE)
             prefs.edit().putString(key, value).apply()
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftSharedKeychainResolve && window._craftSharedKeychainResolve({success: true, key: '$key'})",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftSharedKeychainResolve && window._craftSharedKeychainResolve({set: true, key: ${jsQuote(key)}})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftSharedKeychainReject && window._craftSharedKeychainReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftSharedKeychainReject && window._craftSharedKeychainReject(${jsQuote(e.message ?: "Shared item could not be stored")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun getSharedItem(key: String, group: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.getSharedItem(activity, key, group)) return
+
         try {
             val prefsName = if (group.isNotEmpty()) "craft_shared_$group" else "craft_shared"
             val prefs = activity.getSharedPreferences(prefsName, Context.MODE_PRIVATE)
             val value = prefs.getString(key, null)
 
-            activity.runOnUiThread {
-                if (value != null) {
-                    webView.evaluateJavascript(
-                        "window._craftSharedKeychainResolve && window._craftSharedKeychainResolve({value: '$value', key: '$key'})",
-                        null
-                    )
-                } else {
-                    webView.evaluateJavascript(
-                        "window._craftSharedKeychainResolve && window._craftSharedKeychainResolve({value: null, key: '$key'})",
-                        null
-                    )
-                }
+            val payload = if (value != null) {
+                "{value: ${jsQuote(value)}, key: ${jsQuote(key)}}"
+            } else {
+                "{value: null, key: ${jsQuote(key)}}"
             }
+            evaluatePromiseJavascript(
+                "window._craftSharedKeychainResolve && window._craftSharedKeychainResolve($payload)"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftSharedKeychainReject && window._craftSharedKeychainReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftSharedKeychainReject && window._craftSharedKeychainReject(${jsQuote(e.message ?: "Shared item could not be read")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun removeSharedItem(key: String, group: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice.
+        if (CraftNative.removeSharedItem(activity, key, group)) return
+
         try {
             val prefsName = if (group.isNotEmpty()) "craft_shared_$group" else "craft_shared"
             val prefs = activity.getSharedPreferences(prefsName, Context.MODE_PRIVATE)
             prefs.edit().remove(key).apply()
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftSharedKeychainResolve && window._craftSharedKeychainResolve({success: true, key: '$key'})",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftSharedKeychainResolve && window._craftSharedKeychainResolve({removed: true, key: ${jsQuote(key)}})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftSharedKeychainReject && window._craftSharedKeychainReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftSharedKeychainReject && window._craftSharedKeychainReject(${jsQuote(e.message ?: "Shared item could not be removed")})"
+            )
         }
     }
 
     // ==================== Local Auth Persistence ====================
 
-    private var authSessionExpiry: Long = 0L
+    private val authSessionExpiryKey = "craft_auth_session_expiry"
 
     @JavascriptInterface
     fun setAuthPersistence(enabled: Boolean, duration: Long) {
         try {
             if (enabled) {
-                authSessionExpiry = System.currentTimeMillis() + (duration * 1000)
-                activity.runOnUiThread {
-                    webView.evaluateJavascript(
-                        "window._craftAuthPersistResolve && window._craftAuthPersistResolve({enabled: true, duration: $duration, expiresAt: $authSessionExpiry})",
-                        null
-                    )
-                }
+                val expiresAt = System.currentTimeMillis() + (duration * 1000)
+                securePrefs.edit().putLong(authSessionExpiryKey, expiresAt).apply()
+                evaluatePromiseJavascript(
+                    "window._craftAuthPersistResolve && window._craftAuthPersistResolve({enabled: true, duration: $duration, expiresAt: $expiresAt})"
+                )
             } else {
-                authSessionExpiry = 0L
-                activity.runOnUiThread {
-                    webView.evaluateJavascript(
-                        "window._craftAuthPersistResolve && window._craftAuthPersistResolve({enabled: false})",
-                        null
-                    )
-                }
-            }
-        } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftAuthPersistReject && window._craftAuthPersistReject('${e.message}')",
-                    null
+                securePrefs.edit().remove(authSessionExpiryKey).apply()
+                evaluatePromiseJavascript(
+                    "window._craftAuthPersistResolve && window._craftAuthPersistResolve({enabled: false})"
                 )
             }
+        } catch (e: Exception) {
+            evaluatePromiseJavascript(
+                "window._craftAuthPersistReject && window._craftAuthPersistReject(${jsQuote(e.message ?: "Auth persistence could not be updated")})"
+            )
         }
     }
 
@@ -3365,43 +4157,32 @@ class CraftBridge(
     fun checkAuthPersistence() {
         try {
             val now = System.currentTimeMillis()
+            val authSessionExpiry = securePrefs.getLong(authSessionExpiryKey, 0L)
             val isValid = authSessionExpiry > now
             val remainingMs = if (isValid) authSessionExpiry - now else 0L
             val remainingSeconds = remainingMs / 1000
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftAuthPersistResolve && window._craftAuthPersistResolve({isValid: $isValid, remainingSeconds: $remainingSeconds})",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftAuthPersistResolve && window._craftAuthPersistResolve({isValid: $isValid, remainingSeconds: $remainingSeconds})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftAuthPersistReject && window._craftAuthPersistReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftAuthPersistReject && window._craftAuthPersistReject(${jsQuote(e.message ?: "Auth persistence could not be checked")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun clearAuthPersistence() {
         try {
-            authSessionExpiry = 0L
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftAuthPersistResolve && window._craftAuthPersistResolve({cleared: true})",
-                    null
-                )
-            }
+            securePrefs.edit().remove(authSessionExpiryKey).apply()
+            evaluatePromiseJavascript(
+                "window._craftAuthPersistResolve && window._craftAuthPersistResolve({cleared: true})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftAuthPersistReject && window._craftAuthPersistReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftAuthPersistReject && window._craftAuthPersistReject(${jsQuote(e.message ?: "Auth persistence could not be cleared")})"
+            )
         }
     }
 
@@ -3412,58 +4193,60 @@ class CraftBridge(
 
     @JavascriptInterface
     fun startAR(optionsJson: String) {
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftARReject && window._craftARReject('ARCore requires native Activity integration. Use Sceneform or AR Fragment for full AR support.')",
-                null
-            )
-        }
+        evaluatePromiseJavascript(
+            "window._craftARReject && window._craftARReject('ARCore requires native Activity integration. Use Sceneform or AR Fragment for full AR support.')"
+        )
     }
 
     @JavascriptInterface
     fun stopAR() {
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftARResolve && window._craftARResolve({stopped: true})",
-                null
-            )
-        }
+        evaluatePromiseJavascript("window._craftARResolve && window._craftARResolve({stopped: true})")
     }
 
     @JavascriptInterface
     fun placeARObject(model: String, positionJson: String) {
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftARReject && window._craftARReject('ARCore requires native Activity integration')",
-                null
-            )
-        }
+        evaluatePromiseJavascript(
+            "window._craftARReject && window._craftARReject('ARCore requires native Activity integration')"
+        )
     }
 
     @JavascriptInterface
     fun removeARObject(objectId: String) {
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftARReject && window._craftARReject('ARCore requires native Activity integration')",
-                null
-            )
-        }
+        evaluatePromiseJavascript(
+            "window._craftARReject && window._craftARReject('ARCore requires native Activity integration')"
+        )
     }
 
     @JavascriptInterface
     fun getARPlanes() {
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftARResolve && window._craftARResolve([])",
-                null
-            )
-        }
+        evaluatePromiseJavascript("window._craftARResolve && window._craftARResolve([])")
     }
 
     // ==================== ML Kit ====================
 
+    private fun createMlSettlement(): Pair<(JSONArray) -> Unit, (String) -> Unit> {
+        val settled = java.util.concurrent.atomic.AtomicBoolean(false)
+        val resolve: (JSONArray) -> Unit = { results ->
+            if (!closed && settled.compareAndSet(false, true)) {
+                evaluatePromiseJavascript("window._craftMLResolve && window._craftMLResolve($results)")
+            }
+        }
+        val reject: (String) -> Unit = { message ->
+            if (!closed && settled.compareAndSet(false, true)) {
+                evaluatePromiseJavascript(
+                    "window._craftMLReject && window._craftMLReject(${jsQuote(message)})"
+                )
+            }
+        }
+        return resolve to reject
+    }
+
     @JavascriptInterface
     fun classifyImage(imageBase64: String) {
+        if (CraftNative.classifyImage(imageBase64)) return
+
+        val (resolve, reject) = createMlSettlement()
+
         try {
             val imageBytes = Base64.decode(imageBase64, Base64.DEFAULT)
             val bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
@@ -3472,41 +4255,33 @@ class CraftBridge(
             val labeler = ImageLabeling.getClient(ImageLabelerOptions.DEFAULT_OPTIONS)
             labeler.process(inputImage)
                 .addOnSuccessListener { labels ->
-                    val results = JSONArray()
-                    for (label in labels) {
-                        val obj = JSONObject()
-                        obj.put("label", label.text)
-                        obj.put("confidence", label.confidence)
-                        obj.put("index", label.index)
-                        results.put(obj)
-                    }
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftMLResolve && window._craftMLResolve($results)",
-                            null
-                        )
-                    }
-                }
-                .addOnFailureListener { e ->
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftMLReject && window._craftMLReject('${e.message}')",
-                            null
-                        )
+                    try {
+                        val results = JSONArray()
+                        for (label in labels) {
+                            val obj = JSONObject()
+                            obj.put("label", label.text)
+                            obj.put("confidence", label.confidence)
+                            obj.put("index", label.index)
+                            results.put(obj)
+                        }
+                        resolve(results)
+                    } catch (error: Exception) {
+                        reject(error.message ?: "Image classification failed")
                     }
                 }
+                .addOnFailureListener { error -> reject(error.message ?: "Image classification failed") }
+                .addOnCompleteListener { labeler.close() }
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftMLReject && window._craftMLReject('${e.message}')",
-                    null
-                )
-            }
+            reject(e.message ?: "Image classification failed")
         }
     }
 
     @JavascriptInterface
     fun detectObjects(imageBase64: String) {
+        if (CraftNative.detectObjects(imageBase64)) return
+
+        val (resolve, reject) = createMlSettlement()
+
         try {
             val imageBytes = Base64.decode(imageBase64, Base64.DEFAULT)
             val bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
@@ -3521,59 +4296,51 @@ class CraftBridge(
             val objectDetector = ObjectDetection.getClient(options)
             objectDetector.process(inputImage)
                 .addOnSuccessListener { detectedObjects ->
-                    val results = JSONArray()
-                    for (obj in detectedObjects) {
-                        val objJson = JSONObject()
-
-                        // Bounding box
-                        val bbox = JSONObject()
-                        bbox.put("x", obj.boundingBox.left)
-                        bbox.put("y", obj.boundingBox.top)
-                        bbox.put("width", obj.boundingBox.width())
-                        bbox.put("height", obj.boundingBox.height())
-                        objJson.put("boundingBox", bbox)
-
-                        // Labels
-                        val labels = JSONArray()
-                        for (label in obj.labels) {
-                            val labelJson = JSONObject()
-                            labelJson.put("label", label.text)
-                            labelJson.put("confidence", label.confidence)
-                            labelJson.put("index", label.index)
-                            labels.put(labelJson)
-                        }
-                        objJson.put("labels", labels)
-                        objJson.put("trackingId", obj.trackingId)
+                    try {
+                        val results = JSONArray()
+                        for (obj in detectedObjects) {
+                            val objJson = JSONObject()
+
+                            // Bounding box
+                            val bbox = JSONObject()
+                            bbox.put("x", obj.boundingBox.left)
+                            bbox.put("y", obj.boundingBox.top)
+                            bbox.put("width", obj.boundingBox.width())
+                            bbox.put("height", obj.boundingBox.height())
+                            objJson.put("boundingBox", bbox)
+
+                            // Labels
+                            val labels = JSONArray()
+                            for (label in obj.labels) {
+                                val labelJson = JSONObject()
+                                labelJson.put("label", label.text)
+                                labelJson.put("confidence", label.confidence)
+                                labelJson.put("index", label.index)
+                                labels.put(labelJson)
+                            }
+                            objJson.put("labels", labels)
+                            objJson.put("trackingId", obj.trackingId)
 
-                        results.put(objJson)
-                    }
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftMLResolve && window._craftMLResolve($results)",
-                            null
-                        )
-                    }
-                }
-                .addOnFailureListener { e ->
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftMLReject && window._craftMLReject('${e.message}')",
-                            null
-                        )
+                            results.put(objJson)
+                        }
+                        resolve(results)
+                    } catch (error: Exception) {
+                        reject(error.message ?: "Object detection failed")
                     }
                 }
+                .addOnFailureListener { error -> reject(error.message ?: "Object detection failed") }
+                .addOnCompleteListener { objectDetector.close() }
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftMLReject && window._craftMLReject('${e.message}')",
-                    null
-                )
-            }
+            reject(e.message ?: "Object detection failed")
         }
     }
 
     @JavascriptInterface
     fun recognizeText(imageBase64: String) {
+        if (CraftNative.recognizeText(imageBase64)) return
+
+        val (resolve, reject) = createMlSettlement()
+
         try {
             val imageBytes = Base64.decode(imageBase64, Base64.DEFAULT)
             val bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
@@ -3582,48 +4349,36 @@ class CraftBridge(
             val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
             recognizer.process(inputImage)
                 .addOnSuccessListener { visionText ->
-                    val results = JSONArray()
-                    for (block in visionText.textBlocks) {
-                        for (line in block.lines) {
-                            val lineJson = JSONObject()
-                            lineJson.put("text", line.text)
-                            lineJson.put("confidence", line.confidence ?: 0.0)
-
-                            val boundingBox = line.boundingBox
-                            if (boundingBox != null) {
-                                val bbox = JSONObject()
-                                bbox.put("x", boundingBox.left)
-                                bbox.put("y", boundingBox.top)
-                                bbox.put("width", boundingBox.width())
-                                bbox.put("height", boundingBox.height())
-                                lineJson.put("boundingBox", bbox)
-                            }
+                    try {
+                        val results = JSONArray()
+                        for (block in visionText.textBlocks) {
+                            for (line in block.lines) {
+                                val lineJson = JSONObject()
+                                lineJson.put("text", line.text)
+                                lineJson.put("confidence", line.confidence ?: 0.0)
+
+                                val boundingBox = line.boundingBox
+                                if (boundingBox != null) {
+                                    val bbox = JSONObject()
+                                    bbox.put("x", boundingBox.left)
+                                    bbox.put("y", boundingBox.top)
+                                    bbox.put("width", boundingBox.width())
+                                    bbox.put("height", boundingBox.height())
+                                    lineJson.put("boundingBox", bbox)
+                                }
 
-                            results.put(lineJson)
+                                results.put(lineJson)
+                            }
                         }
-                    }
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftMLResolve && window._craftMLResolve($results)",
-                            null
-                        )
-                    }
-                }
-                .addOnFailureListener { e ->
-                    activity.runOnUiThread {
-                        webView.evaluateJavascript(
-                            "window._craftMLReject && window._craftMLReject('${e.message}')",
-                            null
-                        )
+                        resolve(results)
+                    } catch (error: Exception) {
+                        reject(error.message ?: "Text recognition failed")
                     }
                 }
+                .addOnFailureListener { error -> reject(error.message ?: "Text recognition failed") }
+                .addOnCompleteListener { recognizer.close() }
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftMLReject && window._craftMLReject('${e.message}')",
-                    null
-                )
-            }
+            reject(e.message ?: "Text recognition failed")
         }
     }
 
@@ -3635,6 +4390,11 @@ class CraftBridge(
 
     @JavascriptInterface
     fun updateWidget(dataJson: String) {
+        // Zig answers through the reply channel, so returning here is what
+        // stops the promise being settled twice. The action is passed across
+        // rather than rebuilt there — see CraftNative.updateWidget.
+        if (CraftNative.updateWidget(activity, "{{PACKAGE_NAME}}.WIDGET_UPDATE", dataJson)) return
+
         try {
             val data = JSONObject(dataJson)
             val editor = widgetPrefs.edit()
@@ -3659,66 +4419,37 @@ class CraftBridge(
             intent.setPackage(activity.packageName)
             activity.sendBroadcast(intent)
 
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftWidgetResolve && window._craftWidgetResolve({updated: true})",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftWidgetResolve && window._craftWidgetResolve({updated: true})"
+            )
         } catch (e: Exception) {
-            activity.runOnUiThread {
-                webView.evaluateJavascript(
-                    "window._craftWidgetReject && window._craftWidgetReject('${e.message}')",
-                    null
-                )
-            }
+            evaluatePromiseJavascript(
+                "window._craftWidgetReject && window._craftWidgetReject(${jsQuote(e.message ?: "Widget update failed")})"
+            )
         }
     }
 
     @JavascriptInterface
     fun reloadWidgets() {
-        val intent = Intent("{{PACKAGE_NAME}}.WIDGET_UPDATE")
-        intent.setPackage(activity.packageName)
-        activity.sendBroadcast(intent)
+        if (CraftNative.reloadWidgets(activity, "{{PACKAGE_NAME}}.WIDGET_UPDATE")) return
 
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftWidgetResolve && window._craftWidgetResolve({reloaded: true})",
-                null
-            )
-        }
-    }
-
-    // ==================== Google Assistant / App Actions ====================
-
-    @JavascriptInterface
-    fun registerVoiceAction(phrase: String, action: String) {
-        // App Actions are defined in shortcuts.xml, not dynamically
-        // This stores the action for handling incoming intents
-        val prefs = activity.getSharedPreferences("craft_voice_actions", Context.MODE_PRIVATE)
-        prefs.edit().putString(action, phrase).apply()
+        try {
+            val intent = Intent("{{PACKAGE_NAME}}.WIDGET_UPDATE")
+            intent.setPackage(activity.packageName)
+            activity.sendBroadcast(intent)
 
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftVoiceResolve && window._craftVoiceResolve({registered: true, action: '$action', phrase: '$phrase'})",
-                null
+            evaluatePromiseJavascript(
+                "window._craftWidgetResolve && window._craftWidgetResolve({reloaded: true})"
             )
-        }
-    }
-
-    @JavascriptInterface
-    fun removeVoiceAction(action: String) {
-        val prefs = activity.getSharedPreferences("craft_voice_actions", Context.MODE_PRIVATE)
-        prefs.edit().remove(action).apply()
-
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftVoiceResolve && window._craftVoiceResolve({removed: true, action: '$action'})",
-                null
+        } catch (error: Exception) {
+            evaluatePromiseJavascript(
+                "window._craftWidgetReject && window._craftWidgetReject(${jsQuote(error.message ?: "Widget reload failed")})"
             )
         }
     }
 
+    // ==================== Google Assistant / App Actions ====================
+
     // Handle incoming voice action from Google Assistant
     fun handleVoiceAction(intent: Intent?) {
         intent?.let {
@@ -3726,12 +4457,9 @@ class CraftBridge(
             val data = it.dataString
 
             if (action != null) {
-                activity.runOnUiThread {
-                    webView.evaluateJavascript(
-                        "window.dispatchEvent(new CustomEvent('craftVoiceAction', {detail: {action: '$action', data: '$data'}}));",
-                        null
-                    )
-                }
+                evaluateJavascriptUnlessClosed(
+                    "window.dispatchEvent(new CustomEvent('craftVoiceAction', {detail: {action: ${jsQuote(action)}, data: ${jsQuote(data)}}}));"
+                )
             }
         }
     }
@@ -3742,23 +4470,17 @@ class CraftBridge(
     fun sendToWatch(messageJson: String) {
         // Note: Full Wearable API requires separate Wear OS app
         // This provides placeholder API for future integration
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftWatchReject && window._craftWatchReject('Wear OS integration requires companion app setup')",
-                null
-            )
-        }
+        evaluatePromiseJavascript(
+            "window._craftWatchReject && window._craftWatchReject('Wear OS integration requires companion app setup')"
+        )
     }
 
     @JavascriptInterface
     fun updateWatchContext(contextJson: String) {
         // Note: Full Wearable API requires Data Layer API setup
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window._craftWatchReject && window._craftWatchReject('Wear OS integration requires companion app setup')",
-                null
-            )
-        }
+        evaluatePromiseJavascript(
+            "window._craftWatchReject && window._craftWatchReject('Wear OS integration requires companion app setup')"
+        )
     }
 
     @JavascriptInterface
@@ -3772,11 +4494,14 @@ class CraftBridge(
     private var initialURL: String? = null
 
     fun setInitialURL(url: String?) {
+        if (nativeDeepLinks && CraftNative.setInitialURL(url)) return
         initialURL = url
     }
 
     @JavascriptInterface
     fun getInitialURL() {
+        if (nativeDeepLinks && CraftNative.getInitialURL()) return
+
         activity.runOnUiThread {
             if (initialURL != null) {
                 val uri = Uri.parse(initialURL)
@@ -3793,20 +4518,20 @@ class CraftBridge(
                     }
                     put("queryParams", queryParams)
                 }
-                webView.evaluateJavascript(
-                    "window._craftDeepLinkResolve && window._craftDeepLinkResolve($json)",
-                    null
+                evaluatePromiseJavascript(
+                    "window._craftDeepLinkResolve && window._craftDeepLinkResolve($json)"
                 )
             } else {
-                webView.evaluateJavascript(
-                    "window._craftDeepLinkResolve && window._craftDeepLinkResolve(null)",
-                    null
+                evaluatePromiseJavascript(
+                    "window._craftDeepLinkResolve && window._craftDeepLinkResolve(null)"
                 )
             }
         }
     }
 
     fun dispatchDeepLink(url: String) {
+        if (nativeDeepLinks && CraftNative.dispatchDeepLink(url)) return
+
         // Store as initial URL if this is the first one
         if (initialURL == null) {
             initialURL = url
@@ -3827,18 +4552,17 @@ class CraftBridge(
             put("queryParams", queryParams)
         }
 
-        activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window.dispatchEvent(new CustomEvent('craftDeepLink', {detail: $json}));",
-                null
-            )
-        }
+        evaluateJavascriptUnlessClosed(
+            "window.dispatchEvent(new CustomEvent('craftDeepLink', {detail: $json}));"
+        )
     }
 
     // ==================== Performance Profiling ====================
 
     @JavascriptInterface
     fun getMemoryUsage(): String {
+        CraftNative.getMemoryUsage()?.let { return it }
+
         val runtime = Runtime.getRuntime()
         val usedMemory = runtime.totalMemory() - runtime.freeMemory()
         val maxMemory = runtime.maxMemory()
@@ -3855,17 +4579,48 @@ class CraftBridge(
 
     // ==================== Helpers ====================
 
-    private fun sendEvent(event: String, data: Map<String, Any>) {
-        val json = JSONObject(data).toString()
+    /**
+     * Give Zig a way to reach the page.
+     *
+     * The lambda is this class's own `runOnUiThread`/`evaluateJavascript`
+     * pair, which is what `sendEvent` below already does — so Zig and Kotlin
+     * deliver through exactly one implementation rather than two that have to
+     * agree about threading.
+     */
+    private fun installNativeDeliverer() {
+        CraftNative.setDeliverer { script ->
+            evaluateJavascriptUnlessClosed(script)
+        }
+    }
+
+    private fun evaluatePromiseJavascript(script: String) {
+        evaluateJavascriptUnlessClosed(script)
+    }
+
+    private fun requestPermissionsBestEffort(permissions: Array<String>, requestCode: Int) {
         activity.runOnUiThread {
-            webView.evaluateJavascript(
-                "window.dispatchEvent(new CustomEvent('$event', {detail: $json}));",
-                null
-            )
+            if (closed) return@runOnUiThread
+            runCatching { ActivityCompat.requestPermissions(activity, permissions, requestCode) }
         }
     }
 
+    private fun evaluateJavascriptUnlessClosed(script: String) {
+        if (closed) return
+        activity.runOnUiThread {
+            if (closed) return@runOnUiThread
+            webView.evaluateJavascript(script, null)
+        }
+    }
+
+    private fun sendEvent(event: String, data: Map<String, Any>) {
+        val json = JSONObject(data).toString()
+        evaluateJavascriptUnlessClosed(
+            "window.dispatchEvent(new CustomEvent(${jsQuote(event)}, {detail: $json}));"
+        )
+    }
+
     companion object {
+        private val MIME_TYPE = Regex("^[^\\s/]+/[^\\s/]+$")
         const val REQUEST_CAMERA = 1001
         const val REQUEST_GALLERY = 1002
         const val REQUEST_LOCATION = 1003
@@ -3876,5 +4631,8 @@ class CraftBridge(
         const val REQUEST_VIDEO = 1008
         const val REQUEST_BLUETOOTH = 1009
         const val REQUEST_PICK_CONTACT = 1010
+        private const val PERMISSION_REQUEST_START = 2000
+        private const val PERMISSION_REQUEST_END = 2999
+        private const val LOCATION_REQUEST_TIMEOUT_MS = 15_000L
     }
 }