craft-native 0.0.90 → 0.0.92

package/dist/ios/templates/CraftApp.swift

@@ -40,9 +40,24 @@ extension Notification.Name {
 final class CraftAppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
         UNUserNotificationCenter.current().delegate = self
+        if let shortcut = launchOptions?[.shortcutItem] as? UIApplicationShortcutItem {
+            CraftEventManager.shared.handleShortcut(shortcut)
+            // Returning false tells UIKit the launch-time item was handled and
+            // prevents a second performActionFor callback for the same tap.
+            return false
+        }
         return true
     }
 
+    func application(_ application: UIApplication, performActionFor shortcutItem: UIApplicationShortcutItem, completionHandler: @escaping (Bool) -> Void) {
+        CraftEventManager.shared.handleShortcut(shortcutItem)
+        completionHandler(true)
+    }
+
+    func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
+        CraftEventManager.shared.handleSiriActivity(userActivity)
+    }
+
     func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
         let token = deviceToken.map { String(format: "%02x", $0) }.joined()
         NotificationCenter.default.post(name: .craftPushToken, object: token)
@@ -62,6 +77,71 @@ final class CraftAppDelegate: NSObject, UIApplicationDelegate, UNUserNotificatio
     }
 }
 
+// MARK: - Native Event Manager
+class CraftEventManager {
+    static let shared = CraftEventManager()
+
+    private weak var webView: WKWebView?
+    private var isReady = false
+    private var pendingEvents: [(name: String, data: [String: Any])] = []
+
+    private init() {}
+
+    func setWebView(_ webView: WKWebView) {
+        self.webView = webView
+    }
+
+    func setLoading() {
+        isReady = false
+    }
+
+    func setReady() {
+        isReady = true
+        let events = pendingEvents
+        pendingEvents.removeAll()
+        for event in events {
+            dispatch(event.name, data: event.data)
+        }
+    }
+
+    func handleShortcut(_ shortcut: UIApplicationShortcutItem) {
+        sendToWeb("craftShortcut", data: ["type": shortcut.type])
+    }
+
+    func handleSiriActivity(_ activity: NSUserActivity) -> Bool {
+        let prefix = "\(Bundle.main.bundleIdentifier ?? "{{BUNDLE_ID}}")."
+        guard activity.activityType.hasPrefix(prefix) else { return false }
+
+        let action = activity.userInfo?["action"] as? String
+            ?? String(activity.activityType.dropFirst(prefix.count))
+        var data: [String: Any] = [:]
+        for (key, value) in activity.userInfo ?? [:] {
+            guard let key = key as? String, key != "action" else { continue }
+            data[key] = value
+        }
+        sendToWeb("craftSiriShortcut", data: ["action": action, "data": data])
+        return true
+    }
+
+    private func sendToWeb(_ event: String, data: [String: Any]) {
+        guard isReady, webView != nil else {
+            pendingEvents.append((event, data))
+            return
+        }
+        dispatch(event, data: data)
+    }
+
+    private func dispatch(_ event: String, data: [String: Any]) {
+        guard let webView = webView,
+              let jsonData = try? JSONSerialization.data(withJSONObject: data),
+              let json = String(data: jsonData, encoding: .utf8) else { return }
+        let script = "window.dispatchEvent(new CustomEvent('\(event)', {detail: \(json)}));"
+        DispatchQueue.main.async {
+            webView.evaluateJavaScript(script, completionHandler: nil)
+        }
+    }
+}
+
 // MARK: - App Entry Point
 @main
 struct CraftApp: App {
@@ -92,9 +172,16 @@ class DeepLinkManager {
     static let shared = DeepLinkManager()
 
     private var initialURL: URL?
-    private var pendingURL: URL?
+    // Every link that arrived while no page could receive it, in order. This
+    // was a single slot, so a second link before the bridge was ready replaced
+    // the first; on a cold start, that could be the link that launched the app.
+    private var pendingURLs: [URL] = []
     private weak var webView: WKWebView?
     private var isReady = false
+    // Whether a page has ever become ready. A link that arrives before that is
+    // the one the app was opened with; a link that arrives later is not, and
+    // is no answer to getInitialURL.
+    private var hasBeenReady = false
 
     private init() {}
 
@@ -102,26 +189,33 @@ class DeepLinkManager {
         self.webView = webView
     }
 
+    // A navigation started, so the page that would have received a link is
+    // going away. Without this a link arriving during a reload was dispatched
+    // into the page being torn down and lost.
+    func setLoading() {
+        isReady = false
+    }
+
     func setReady() {
         isReady = true
-        // If there's a pending URL, dispatch it now
-        if let url = pendingURL {
-            dispatchDeepLink(url)
-            pendingURL = nil
+        let firstPage = !hasBeenReady
+        hasBeenReady = true
+        let urls = pendingURLs
+        pendingURLs.removeAll()
+        for url in urls {
+            dispatchDeepLink(url, initial: firstPage && url == initialURL)
         }
     }
 
     func handleURL(_ url: URL) {
-        // Store as initial URL if this is the first one
-        if initialURL == nil {
+        if initialURL == nil && !hasBeenReady {
             initialURL = url
         }
 
-        if isReady, let webView = webView {
-            dispatchDeepLink(url)
+        if isReady && webView != nil {
+            dispatchDeepLink(url, initial: false)
         } else {
-            // Store for later when web view is ready
-            pendingURL = url
+            pendingURLs.append(url)
         }
     }
 
@@ -129,7 +223,7 @@ class DeepLinkManager {
         return initialURL
     }
 
-    private func dispatchDeepLink(_ url: URL) {
+    private func dispatchDeepLink(_ url: URL, initial: Bool) {
         guard let webView = webView else { return }
 
         // Parse URL components
@@ -138,7 +232,10 @@ class DeepLinkManager {
             "scheme": url.scheme ?? "",
             "host": url.host ?? "",
             "path": url.path,
-            "query": url.query ?? ""
+            "query": url.query ?? "",
+            // Lets the page tell the launch link apart from later ones, so a
+            // page that reads getInitialURL is not also handed it again.
+            "initial": initial
         ]
 
         // Parse query parameters
@@ -346,6 +443,7 @@ struct CraftWebView: UIViewRepresentable {
 
         // Register with DeepLinkManager
         DeepLinkManager.shared.setWebView(webView)
+        CraftEventManager.shared.setWebView(webView)
 
         // Parse background color
         let bgColor = UIColor(hex: config.backgroundColor) ?? .black
@@ -400,7 +498,9 @@ struct CraftWebView: UIViewRepresentable {
         // Location
         private var locationManager: CLLocationManager?
         private var singleLocationCallbackId: String?
+        private var singleLocationTimeoutWorkItem: DispatchWorkItem?
         private var locationPermissionCallbackId: String?
+        private var locationPermissionRequiresAlways = false
         private var isWatchingLocation = false
         private var isRecordingLocation = false
         private var isLocationRecordingPaused = false
@@ -567,16 +667,23 @@ struct CraftWebView: UIViewRepresentable {
             switch action {
             case "startListening":
                 if config.enableSpeechRecognition {
+                    // Answers that the request was taken. Authorization and the
+                    // recognizer answer later, as craftSpeech* events; waiting
+                    // for them here would leave the promise open on every path
+                    // that ends without one.
                     startSpeechRecognition()
+                    resolveCallback(callbackId, result: true)
                 } else {
                     rejectCallback(callbackId, error: "Speech recognition is disabled", code: "CAPABILITY_DISABLED")
                 }
             case "stopListening":
                 stopSpeechRecognition()
+                resolveCallback(callbackId, result: true)
             case "haptic":
                 if config.enableHaptics {
                     let style = body["style"] as? String ?? "medium"
                     triggerHaptic(style: style)
+                    resolveCallback(callbackId, result: true)
                 } else {
                     rejectCallback(callbackId, error: "Haptics is disabled", code: "CAPABILITY_DISABLED")
                 }
@@ -683,7 +790,7 @@ struct CraftWebView: UIViewRepresentable {
             // Geolocation
             case "getCurrentPosition":
                 if config.enableGeolocation {
-                    getCurrentPosition(callbackId: callbackId)
+                    getCurrentPosition(body: body, callbackId: callbackId)
                 } else {
                     rejectCallback(callbackId, error: "Geolocation is disabled", code: "CAPABILITY_DISABLED")
                 }
@@ -1094,7 +1201,7 @@ struct CraftWebView: UIViewRepresentable {
             case "updateLiveActivity":
                 updateLiveActivity(body: body, callbackId: callbackId)
             case "endLiveActivity":
-                endLiveActivity(callbackId: callbackId)
+                endLiveActivity(body: body, callbackId: callbackId)
 
             // MARK: - Screen Capture
             case "takeScreenshot":
@@ -1315,6 +1422,11 @@ struct CraftWebView: UIViewRepresentable {
             }
         }
 
+        func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
+            CraftEventManager.shared.setLoading()
+            DeepLinkManager.shared.setLoading()
+        }
+
         func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
             self.webView = webView
             guard isTrustedURL(webView.url) else { return }
@@ -1358,11 +1470,29 @@ struct CraftWebView: UIViewRepresentable {
 
         private func isTrustedURL(_ url: URL?) -> Bool {
             guard let url = url else { return false }
-            if url.scheme == "craft" && url.host == "app" { return true }
             return isTrustedOrigin(scheme: url.scheme ?? "", host: url.host ?? "", port: url.port ?? 0)
         }
 
+        /// The single answer to "may this origin reach native?".
+        ///
+        /// The bundled app is served from craft://app by
+        /// `BundledAssetSchemeHandler`, and it is the only content a generated
+        /// app loads when no dev server is configured. That origin used to be
+        /// trusted for *navigation* only: `isTrustedURL` carried the clause,
+        /// while the `userContentController` guard called this function
+        /// directly and fell through to the https/localhost check. So every
+        /// bridge call from the app's own page was answered with
+        ///
+        ///     Blocked Craft bridge message from untrusted origin: craft://app
+        ///
+        /// and its promise never settled — the whole native surface was dead
+        /// in the default configuration, which is the one every generated app
+        /// ships with. Two guards that had to agree, and did not. There is one
+        /// now, and `scripts/mobile-e2e.ts` runs a real round trip on a booted
+        /// simulator so a future hardening pass cannot quietly take the bridge
+        /// away again.
         private func isTrustedOrigin(scheme: String, host: String, port: Int) -> Bool {
+            if scheme == "craft" && host == "app" { return true }
             if scheme == "file" { return true }
             guard scheme == "https" || (scheme == "http" && ["localhost", "127.0.0.1", "::1"].contains(host)) else { return false }
             let defaultPort = scheme == "https" ? 443 : 80
@@ -1782,20 +1912,170 @@ struct CraftWebView: UIViewRepresentable {
                     };
                 },
 
+                // Flat SDK compatibility methods. The native dispatcher already
+                // owns these actions; keep the public CraftBridge shape callable
+                // while the versioned API below provides the namespaced form.
+                scanNFC: function() {
+                    return this._invoke('scanNFC');
+                },
+                scanQRCode: function() {
+                    return this._invoke('scanQRCode');
+                },
+                takeScreenshot: function() {
+                    return this._invoke('takeScreenshot');
+                },
+                startAudioRecording: function() {
+                    return this._invoke('startAudioRecording');
+                },
+                stopAudioRecording: function() {
+                    return this._invoke('stopAudioRecording');
+                },
+                startVideoRecording: function() {
+                    return this._invoke('startVideoRecording');
+                },
+                pickFile: function(types) {
+                    return this._invoke('pickFile', {types: types || []});
+                },
+                downloadFile: function(url, filename) {
+                    return this._invoke('downloadFile', {url: url, filename: filename});
+                },
+                saveFile: function(data, filename, mimeType) {
+                    return this._invoke('saveFile', {data: data, filename: filename, mimeType: mimeType});
+                },
+                startMotionUpdates: function() {
+                    return this._invoke('startMotionUpdates');
+                },
+                stopMotionUpdates: function() {
+                    return this._invoke('stopMotionUpdates');
+                },
+                getCurrentPosition: function() {
+                    return this.geolocation.getCurrentPosition({});
+                },
+                watchPosition: function(callback) {
+                    return this.geolocation.watchPosition(callback);
+                },
+                clearWatch: function(watchId) {
+                    return this.geolocation.clearWatch(watchId);
+                },
+                getContacts: function() {
+                    return this._invoke('getContacts');
+                },
+                addContact: function(contact) {
+                    return this._invoke('addContact', {contact: contact});
+                },
+                getCalendarEvents: function(startDate, endDate) {
+                    return this._invoke('getCalendarEvents', {startDate: startDate, endDate: endDate});
+                },
+                createCalendarEvent: function(event) {
+                    return this._invoke('createCalendarEvent', {event: event});
+                },
+                deleteCalendarEvent: function(eventId) {
+                    return this._invoke('deleteCalendarEvent', {eventId: eventId});
+                },
+                scheduleNotification: function(notification) {
+                    return this._invoke('scheduleNotification', {notification: notification});
+                },
+                cancelNotification: function(id) {
+                    return this._invoke('cancelNotification', {id: id});
+                },
+                cancelAllNotifications: function() {
+                    return this._invoke('cancelAllNotifications');
+                },
+                getPendingNotifications: function() {
+                    return this._invoke('getPendingNotifications');
+                },
+                getProducts: function(productIds) {
+                    return this.iap.getProducts(productIds);
+                },
+                purchase: function(productId) {
+                    return this.iap.purchase(productId);
+                },
+                restorePurchases: function() {
+                    return this._invoke('restorePurchases');
+                },
+                signInWithApple: function() {
+                    return this._invoke('signInWithApple');
+                },
+                signInWithGoogle: function() {
+                    return Promise.reject(new Error('Google Sign-In is unavailable on iOS'));
+                },
+                startBluetoothScan: function() {
+                    return this._invoke('startBluetoothScan');
+                },
+                stopBluetoothScan: function() {
+                    return this._invoke('stopBluetoothScan');
+                },
+                requestHealthAuthorization: function(types) {
+                    return this._invoke('requestHealthAuthorization', {types: types || []});
+                },
+                getHealthData: function(type, startDate, endDate) {
+                    var start = startDate instanceof Date ? startDate.getTime() : startDate;
+                    var end = endDate instanceof Date ? endDate.getTime() : endDate;
+                    return this._invoke('getHealthData', {type: type, startDate: start, endDate: end});
+                },
+                requestFitnessAuthorization: function() {
+                    return Promise.reject(new Error('Android fitness APIs are unavailable on iOS'));
+                },
+                getFitnessData: function() {
+                    return Promise.reject(new Error('Android fitness APIs are unavailable on iOS'));
+                },
+
+                // Resolves true once UIKit has taken the haptic, and rejects
+                // CAPABILITY_DISABLED when enableHaptics is off.
                 haptic: function(style) {
-                    window.webkit.messageHandlers.craft.postMessage({action: 'haptic', style: style || 'medium'});
+                    var self = window.craft;
+                    var id = 'cb_' + (++self._callbackId);
+                    window.webkit.messageHandlers.craft.postMessage({action: 'haptic', style: style || 'medium', callbackId: id});
+                    return new Promise(function(resolve, reject) {
+                        self._callbacks[id] = {resolve: resolve, reject: reject};
+                    });
                 },
 
+                // Resolves true once native has taken the request, not once
+                // audio is flowing. What happens next (a prompt declined, no
+                // recognizer, a transcript) still arrives as craftSpeech*
+                // events, because none of it is known when this answers.
                 startListening: function() {
-                    window.webkit.messageHandlers.craft.postMessage({action: 'startListening'});
+                    var self = window.craft;
+                    var id = 'cb_' + (++self._callbackId);
+                    window.webkit.messageHandlers.craft.postMessage({action: 'startListening', callbackId: id});
+                    return new Promise(function(resolve, reject) {
+                        self._callbacks[id] = {resolve: resolve, reject: reject};
+                    });
                 },
 
                 stopListening: function() {
-                    window.webkit.messageHandlers.craft.postMessage({action: 'stopListening'});
+                    var self = window.craft;
+                    var id = 'cb_' + (++self._callbackId);
+                    window.webkit.messageHandlers.craft.postMessage({action: 'stopListening', callbackId: id});
+                    return new Promise(function(resolve, reject) {
+                        self._callbacks[id] = {resolve: resolve, reject: reject};
+                    });
                 },
 
                 share: function(text) {
-                    window.webkit.messageHandlers.craft.postMessage({action: 'share', text: text});
+                    return this._share({text: text});
+                },
+
+                // Both share entry points come through here, because the
+                // native side answers them the same way: `true` when the
+                // person finished an activity, `false` when they dismissed
+                // the sheet, a rejection when sharing is disabled or there is
+                // nothing to share. The flat `share` used to post with no
+                // callbackId, so every one of those answers stopped at the nil
+                // guard in resolveCallback and the page got `undefined`.
+                //
+                // No timeout, unlike `_invoke`'s thirty seconds. The sheet
+                // waits on a person, and someone slower than that to pick an
+                // app would be told the share failed while it was still on
+                // screen, with the real answer then dropped.
+                _share: function(payload) {
+                    var self = this;
+                    var id = 'cb_' + (++this._callbackId);
+                    window.webkit.messageHandlers.craft.postMessage(Object.assign({}, payload, {action: 'share', callbackId: id}));
+                    return new Promise(function(resolve, reject) {
+                        self._callbacks[id] = {resolve: resolve, reject: reject};
+                    });
                 },
 
                 openCamera: function() {
@@ -1863,20 +2143,79 @@ struct CraftWebView: UIViewRepresentable {
 
                 // Geolocation
                 geolocation: {
-                    getCurrentPosition: function() {
+                    getCurrentPosition: function(options) {
+                        options = options || {};
                         var self = window.craft;
                         var id = 'cb_' + (++self._callbackId);
-                        window.webkit.messageHandlers.craft.postMessage({action: 'getCurrentPosition', callbackId: id});
+                        var requestedTimeout = Number(options.timeout);
+                        var timeoutMs = Number.isFinite(requestedTimeout) && requestedTimeout >= 0
+                            ? Math.min(requestedTimeout, 2147483647)
+                            : 30000;
                         return new Promise(function(resolve, reject) {
-                            self._callbacks[id] = {resolve: resolve, reject: reject};
+                            var timeout;
+                            self._callbacks[id] = {
+                                resolve: function(value) { clearTimeout(timeout); resolve(value); },
+                                reject: function(error) {
+                                    clearTimeout(timeout);
+                                    var locationErrorCode = error && ({
+                                        'PERMISSION_DENIED': 1,
+                                        'POSITION_UNAVAILABLE': 2,
+                                        'NATIVE_CALL_FAILED': 2,
+                                        'TIMEOUT': 3,
+                                        'LOCATION_TIMEOUT': 3
+                                    })[error.code];
+                                    if (locationErrorCode) {
+                                        error.name = 'GeolocationPositionError';
+                                        error.code = locationErrorCode;
+                                    }
+                                    reject(error);
+                                }
+                            };
+                            timeout = setTimeout(function() {
+                                if (!self._callbacks[id]) return;
+                                delete self._callbacks[id];
+                                var error = new Error('Location request timed out after ' + timeoutMs + 'ms');
+                                error.name = 'GeolocationPositionError';
+                                error.code = 3;
+                                error.bridge = true;
+                                reject(error);
+                            }, timeoutMs);
+                            try {
+                                window.webkit.messageHandlers.craft.postMessage({
+                                    action: 'getCurrentPosition',
+                                    callbackId: id,
+                                    enableHighAccuracy: options.enableHighAccuracy === true,
+                                    timeout: timeoutMs,
+                                    maximumAge: Number.isFinite(Number(options.maximumAge))
+                                        ? Math.max(0, Number(options.maximumAge))
+                                        : 0
+                                });
+                            } catch (error) {
+                                clearTimeout(timeout);
+                                delete self._callbacks[id];
+                                reject(error);
+                            }
                         });
                     },
+                    // Resolves true once updates have started, before any
+                    // authorization answer. A later refusal arrives as a
+                    // craftLocationError event.
                     watchPosition: function(callback) {
+                        var self = window.craft;
+                        var id = 'cb_' + (++self._callbackId);
                         window.addEventListener('craftLocationUpdate', function(e) { callback(e.detail); });
-                        window.webkit.messageHandlers.craft.postMessage({action: 'watchPosition'});
+                        window.webkit.messageHandlers.craft.postMessage({action: 'watchPosition', callbackId: id});
+                        return new Promise(function(resolve, reject) {
+                            self._callbacks[id] = {resolve: resolve, reject: reject};
+                        });
                     },
                     clearWatch: function() {
-                        window.webkit.messageHandlers.craft.postMessage({action: 'clearWatch'});
+                        var self = window.craft;
+                        var id = 'cb_' + (++self._callbackId);
+                        window.webkit.messageHandlers.craft.postMessage({action: 'clearWatch', callbackId: id});
+                        return new Promise(function(resolve, reject) {
+                            self._callbacks[id] = {resolve: resolve, reject: reject};
+                        });
                     }
                 },
 
@@ -1938,7 +2277,14 @@ struct CraftWebView: UIViewRepresentable {
                     });
                 },
                 onNetworkChange: function(callback) {
-                    window.addEventListener('craftNetworkChange', function(e) { callback(e.detail); });
+                    this.offNetworkChange();
+                    this._networkChangeHandler = function(e) { callback(e.detail); };
+                    window.addEventListener('craftNetworkChange', this._networkChangeHandler);
+                },
+                offNetworkChange: function() {
+                    if (!this._networkChangeHandler) return;
+                    window.removeEventListener('craftNetworkChange', this._networkChangeHandler);
+                    this._networkChangeHandler = null;
                 },
 
                 // App review
@@ -1957,13 +2303,24 @@ struct CraftWebView: UIViewRepresentable {
                     var id = 'cb_' + (++this._callbackId);
                     window.webkit.messageHandlers.craft.postMessage({action: 'setFlashlight', enabled: enabled, callbackId: id});
                     return new Promise(function(resolve, reject) {
-                        self._callbacks[id] = {resolve: resolve, reject: reject};
+                        self._callbacks[id] = {
+                            resolve: function(value) { self._flashlightEnabled = enabled; resolve(value); },
+                            reject: reject
+                        };
                     });
                 },
+                toggleFlashlight: function() {
+                    return this.setFlashlight(!this._flashlightEnabled);
+                },
 
                 // Vibrate
                 vibrate: function(pattern) {
-                    window.webkit.messageHandlers.craft.postMessage({action: 'vibrate', pattern: pattern});
+                    var self = window.craft;
+                    var id = 'cb_' + (++self._callbackId);
+                    window.webkit.messageHandlers.craft.postMessage({action: 'vibrate', pattern: pattern, callbackId: id});
+                    return new Promise(function(resolve, reject) {
+                        self._callbacks[id] = {resolve: resolve, reject: reject};
+                    });
                 },
 
                 // Open URL
@@ -1985,6 +2342,18 @@ struct CraftWebView: UIViewRepresentable {
                         self._callbacks[id] = {resolve: resolve, reject: reject};
                     });
                 },
+                onAppStateChange: function(callback) {
+                    this.offAppStateChange();
+                    this._appStateChangeHandler = function() {
+                        callback(document.visibilityState === 'visible' ? 'active' : 'background');
+                    };
+                    document.addEventListener('visibilitychange', this._appStateChangeHandler);
+                },
+                offAppStateChange: function() {
+                    if (!this._appStateChangeHandler) return;
+                    document.removeEventListener('visibilitychange', this._appStateChangeHandler);
+                    this._appStateChangeHandler = null;
+                },
 
                 // Contacts
                 contacts: {
@@ -2128,7 +2497,7 @@ struct CraftWebView: UIViewRepresentable {
 
                 // Deep Links
                 onDeepLink: function(callback) {
-                    window.addEventListener('craftDeepLink', function(e) { callback(e.detail); });
+                    return window.craft._subscribeDeepLinks(callback);
                 },
 
                 // Background Tasks
@@ -2456,6 +2825,7 @@ struct CraftWebView: UIViewRepresentable {
                 deepLinks: {
                     getInitialURL: function() {
                         var self = window.craft;
+                        self._claimInitialDeepLink();
                         var id = 'cb_' + (++self._callbackId);
                         window.webkit.messageHandlers.craft.postMessage({action: 'getInitialURL', callbackId: id});
                         return new Promise(function(resolve, reject) {
@@ -2463,7 +2833,7 @@ struct CraftWebView: UIViewRepresentable {
                         });
                     },
                     onLink: function(callback) {
-                        window.addEventListener('craftDeepLink', function(e) { callback(e.detail); });
+                        return window.craft._subscribeDeepLinks(callback);
                     }
                 },
 
@@ -2471,8 +2841,6 @@ struct CraftWebView: UIViewRepresentable {
                 ota: {
                     _config: null,
                     _status: 'idle',
-                    _progressCallbacks: [],
-                    _statusCallbacks: [],
 
                     // OTA is not implemented natively. These five used to post
                     // to actions the switch below does not handle, and register
@@ -2513,12 +2881,10 @@ struct CraftWebView: UIViewRepresentable {
                         };
                     },
                     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');
                     }
                 },
 
@@ -2530,6 +2896,61 @@ struct CraftWebView: UIViewRepresentable {
             // Stable, versioned mobile contract consumed by craft-native/mobile.
             // Legacy flat methods remain available while every public SDK method
             // is routed through this nested contract.
+            // Links that arrive before anything is listening (#198).
+            //
+            // The native side dispatches a link the moment this script has
+            // run, and on a cold start that is the link the app was opened
+            // with. No page code can have called onLink by then: onLink is
+            // defined by this very script. So every such link was dispatched
+            // to nobody, and a page that subscribes, rather than asking
+            // getInitialURL, never learned how it was opened.
+            //
+            // Held here instead, and handed to the first subscriber on the
+            // next turn, so an unsubscribe returned in the same tick still
+            // applies. The launch link belongs to getInitialURL once the page
+            // has called it, whether native has dispatched it yet or not, so a
+            // page that does both in the same tick, in either order, gets it
+            // once. That includes a craftReady handler, which runs before
+            // native dispatches anything. A page that asks getInitialURL only
+            // later, after an await, should skip `initial` in onLink.
+            //
+            // The same block runs on Android (#215), where this script can run
+            // twice in one document, so its state lives on window.
+            (function installDeepLinkReplay(craft) {
+                var replay = window.__craftDeepLinkReplay;
+                if (!replay) {
+                    replay = window.__craftDeepLinkReplay = {undelivered: [], subscribed: false, initialClaimed: false};
+                    window.addEventListener('craftDeepLink', function(e) {
+                        if (!replay.subscribed && !claimed(e.detail)) replay.undelivered.push(e.detail);
+                    });
+                }
+                function claimed(detail) {
+                    return replay.initialClaimed && detail && detail.initial;
+                }
+                craft._subscribeDeepLinks = function(callback) {
+                    var active = true;
+                    var listener = function(e) { if (!claimed(e.detail)) callback(e.detail); };
+                    window.addEventListener('craftDeepLink', listener);
+                    if (!replay.subscribed) {
+                        replay.subscribed = true;
+                        setTimeout(function() {
+                            var pending = replay.undelivered;
+                            replay.undelivered = [];
+                            if (!active) return;
+                            pending.forEach(function(detail) { callback(detail); });
+                        }, 0);
+                    }
+                    return function() {
+                        active = false;
+                        window.removeEventListener('craftDeepLink', listener);
+                    };
+                };
+                craft._claimInitialDeepLink = function() {
+                    replay.initialClaimed = true;
+                    replay.undelivered = replay.undelivered.filter(function(detail) { return !(detail && detail.initial); });
+                };
+            })(window.craft);
+
             (function installCraftMobileContract(craft) {
                 var legacyShare = craft.share.bind(craft);
                 var legacyOpenCamera = craft.openCamera.bind(craft);
@@ -2561,14 +2982,25 @@ struct CraftWebView: UIViewRepresentable {
                     getInfo: function() { return craft.getDeviceInfo(); },
                     getCapabilities: function() { return Promise.resolve(Object.assign({}, craft.capabilities)); }
                 };
+                // Feedback, as on Android and the web, where there is no
+                // motor to fire: an app that left enableHaptics off gets
+                // nothing played and a settled promise, so `await
+                // haptics.selection()` in the middle of a flow does not stop
+                // the flow. A native failure still rejects, and
+                // craft.haptic() itself reports the refusal.
+                function hapticFeedback(answer) {
+                    return answer.then(function() {}, function(error) {
+                        if (error && error.code === 'CAPABILITY_DISABLED') return;
+                        throw error;
+                    });
+                }
                 craft.haptics = {
-                    impact: function(style) { craft.haptic(style || 'medium'); return Promise.resolve(); },
+                    impact: function(style) { return hapticFeedback(craft.haptic(style || 'medium')); },
                     notification: function(type) {
-                        craft.haptic(type === 'error' ? 'heavy' : type === 'warning' ? 'medium' : 'light');
-                        return Promise.resolve();
+                        return hapticFeedback(craft.haptic(type === 'error' ? 'heavy' : type === 'warning' ? 'medium' : 'light'));
                     },
-                    selection: function() { craft.haptic('soft'); return Promise.resolve(); },
-                    vibrate: function(pattern) { craft.vibrate(pattern || []); return Promise.resolve(); }
+                    selection: function() { return hapticFeedback(craft.haptic('soft')); },
+                    vibrate: function(pattern) { return hapticFeedback(craft.vibrate(pattern || [])); }
                 };
                 craft.permissions = {
                     check: function(permission) { return craft._invoke('checkPermission', {permission: permission}); },
@@ -2608,9 +3040,7 @@ struct CraftWebView: UIViewRepresentable {
                     },
                     clearWatch: function(id) {
                         locationWatchCallbacks.delete(id);
-                        if (locationWatchCallbacks.size === 0) {
-                            window.webkit.messageHandlers.craft.postMessage({action: 'clearWatch'});
-                        }
+                        if (locationWatchCallbacks.size === 0) void craft._invoke('clearWatch');
                     },
                     startRecording: function() { return craft._invoke('startLocationRecording'); },
                     pauseRecording: function() { return craft._invoke('pauseLocationRecording'); },
@@ -2629,11 +3059,17 @@ struct CraftWebView: UIViewRepresentable {
                 };
                 craft.liveActivity = {
                     start: function(options) { return craft._invoke('startLiveActivity', options || {}); },
-                    update: function(options) { return craft._invoke('updateLiveActivity', options || {}); },
-                    end: function() { return craft._invoke('endLiveActivity'); }
+                    update: function(idOrState, state) {
+                        if (typeof idOrState !== 'string') return craft._invoke('updateLiveActivity', idOrState || {});
+                        return craft._invoke('updateLiveActivity', Object.assign({}, state || {}, {id: idOrState}));
+                    },
+                    end: function(id, finalState) {
+                        if (typeof id !== 'string') return craft._invoke('endLiveActivity');
+                        return craft._invoke('endLiveActivity', Object.assign({}, finalState || {}, {id: id}));
+                    }
                 };
                 var shareApi = function(text) { return legacyShare(text); };
-                shareApi.share = function(options) { return craft._invoke('share', {options: options || {}}); };
+                shareApi.share = function(options) { return craft._share({options: options || {}}); };
                 craft.share = shareApi;
                 craft.lifecycle = {
                     getState: function() { return document.visibilityState === 'visible' ? 'active' : 'background'; },
@@ -2686,6 +3122,7 @@ struct CraftWebView: UIViewRepresentable {
 
             // Mark DeepLinkManager as ready
             DeepLinkManager.shared.setReady()
+            CraftEventManager.shared.setReady()
         }
 
         // MARK: - Callback Helpers
@@ -2899,7 +3336,15 @@ struct CraftWebView: UIViewRepresentable {
         func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
             picker.dismiss(animated: true)
 
-            if let image = info[.originalImage] as? UIImage,
+            if let movieURL = info[.mediaURL] as? URL {
+                do {
+                    let movieData = try Data(contentsOf: movieURL, options: .mappedIfSafe)
+                    let base64 = movieData.base64EncodedString()
+                    resolveCallback(pendingCallbackId, result: "data:video/quicktime;base64," + base64)
+                } catch {
+                    rejectCallback(pendingCallbackId, error: "Failed to process video: \(error.localizedDescription)")
+                }
+            } else if let image = info[.originalImage] as? UIImage,
                let imageData = image.jpegData(compressionQuality: 0.8) {
                 let base64 = imageData.base64EncodedString()
                 resolveCallback(pendingCallbackId, result: [
@@ -3036,7 +3481,7 @@ struct CraftWebView: UIViewRepresentable {
             }
             switch permission {
             case "location", "locationAlways":
-                let status = CLLocationManager.authorizationStatus()
+                let status = (locationManager ?? CLLocationManager()).authorizationStatus
                 let granted = status == .authorizedAlways || (permission == "location" && status == .authorizedWhenInUse)
                 resolveCallback(callbackId, result: permissionStatus(granted, denied: status == .denied, restricted: status == .restricted))
             case "camera":
@@ -3084,11 +3529,27 @@ struct CraftWebView: UIViewRepresentable {
             }
             switch permission {
             case "location", "locationAlways":
+                guard let manager = locationManager else {
+                    rejectCallback(callbackId, error: "Geolocation is disabled", code: "CAPABILITY_DISABLED")
+                    return
+                }
+                manager.delegate = self
+                let requiresAlways = permission == "locationAlways" || config.enableBackgroundLocation
+                let status = manager.authorizationStatus
+                let alreadyGranted = status == .authorizedAlways || (!requiresAlways && status == .authorizedWhenInUse)
+                if alreadyGranted || status == .denied || status == .restricted {
+                    resolveCallback(callbackId, result: permissionStatus(alreadyGranted, denied: status == .denied, restricted: status == .restricted))
+                    return
+                }
+                if let pendingCallbackId = locationPermissionCallbackId {
+                    rejectCallback(pendingCallbackId, error: "A newer location permission request replaced this request", code: "REQUEST_REPLACED")
+                }
                 locationPermissionCallbackId = callbackId
-                if permission == "locationAlways" || config.enableBackgroundLocation {
-                    locationManager?.requestAlwaysAuthorization()
+                locationPermissionRequiresAlways = requiresAlways
+                if requiresAlways {
+                    manager.requestAlwaysAuthorization()
                 } else {
-                    locationManager?.requestWhenInUseAuthorization()
+                    manager.requestWhenInUseAuthorization()
                 }
             case "camera":
                 AVCaptureDevice.requestAccess(for: .video) { granted in
@@ -3134,11 +3595,60 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         // MARK: - Geolocation
-        private func getCurrentPosition(callbackId: String?) {
-            locationManager?.delegate = self
+        private func getCurrentPosition(body: [String: Any], callbackId: String?) {
+            guard let manager = locationManager else {
+                rejectCallback(callbackId, error: "Geolocation is disabled", code: "CAPABILITY_DISABLED")
+                return
+            }
+            manager.delegate = self
+            manager.desiredAccuracy = body["enableHighAccuracy"] as? Bool == true
+                ? kCLLocationAccuracyBest
+                : kCLLocationAccuracyHundredMeters
+
+            if let pendingCallbackId = singleLocationCallbackId {
+                finishSingleLocationRequest()
+                rejectCallback(pendingCallbackId, error: "A newer location request replaced this request", code: "POSITION_UNAVAILABLE")
+            }
             singleLocationCallbackId = callbackId
+            let maximumAge = max(0, (body["maximumAge"] as? NSNumber)?.doubleValue ?? 0)
+            if maximumAge > 0,
+               let cachedLocation = manager.location,
+               max(0, Date().timeIntervalSince(cachedLocation.timestamp) * 1000) <= maximumAge {
+                finishSingleLocationRequest()
+                resolveCallback(callbackId, result: locationData(cachedLocation))
+                return
+            }
+
+            let timeoutMs = max(0, (body["timeout"] as? NSNumber)?.doubleValue ?? 30_000)
+            let timeoutWorkItem = DispatchWorkItem { [weak self] in
+                guard let self, self.singleLocationCallbackId == callbackId else { return }
+                self.finishSingleLocationRequest()
+                self.rejectCallback(callbackId, error: "Location request timed out", code: "LOCATION_TIMEOUT")
+            }
+            singleLocationTimeoutWorkItem = timeoutWorkItem
+            DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(Int(min(timeoutMs + 100, Double(Int.max)))), execute: timeoutWorkItem)
             requestLocationAuthorization()
-            locationManager?.requestLocation()
+            manager.requestLocation()
+        }
+
+        private func finishSingleLocationRequest() {
+            singleLocationTimeoutWorkItem?.cancel()
+            singleLocationTimeoutWorkItem = nil
+            singleLocationCallbackId = nil
+            locationManager?.desiredAccuracy = kCLLocationAccuracyBest
+        }
+
+        private func locationData(_ location: CLLocation) -> [String: Any] {
+            [
+                "latitude": location.coordinate.latitude,
+                "longitude": location.coordinate.longitude,
+                "altitude": location.altitude,
+                "accuracy": location.horizontalAccuracy,
+                "altitudeAccuracy": location.verticalAccuracy,
+                "heading": location.course,
+                "speed": location.speed,
+                "timestamp": location.timestamp.timeIntervalSince1970 * 1000
+            ]
         }
 
         private func watchPosition(callbackId: String?) {
@@ -3326,20 +3836,11 @@ struct CraftWebView: UIViewRepresentable {
 
         func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
             guard let location = locations.last else { return }
-            let data: [String: Any] = [
-                "latitude": location.coordinate.latitude,
-                "longitude": location.coordinate.longitude,
-                "altitude": location.altitude,
-                "accuracy": location.horizontalAccuracy,
-                "altitudeAccuracy": location.verticalAccuracy,
-                "heading": location.course,
-                "speed": location.speed,
-                "timestamp": location.timestamp.timeIntervalSince1970 * 1000
-            ]
+            let data = locationData(location)
 
             if let callbackId = singleLocationCallbackId {
+                finishSingleLocationRequest()
                 resolveCallback(callbackId, result: data)
-                singleLocationCallbackId = nil
             }
 
             appendRecordedLocation(data)
@@ -3349,8 +3850,13 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
-            rejectCallback(singleLocationCallbackId, error: error.localizedDescription)
-            singleLocationCallbackId = nil
+            let callbackId = singleLocationCallbackId
+            finishSingleLocationRequest()
+            let nativeError = error as NSError
+            let code = nativeError.domain == kCLErrorDomain && nativeError.code == CLError.Code.denied.rawValue
+                ? "PERMISSION_DENIED"
+                : "POSITION_UNAVAILABLE"
+            rejectCallback(callbackId, error: error.localizedDescription, code: code)
             sendToWeb("craftLocationError", data: ["message": error.localizedDescription])
         }
 
@@ -3358,9 +3864,11 @@ struct CraftWebView: UIViewRepresentable {
             guard let callbackId = locationPermissionCallbackId else { return }
             let status = manager.authorizationStatus
             if status == .notDetermined { return }
-            let granted = status == .authorizedAlways || status == .authorizedWhenInUse
+            if locationPermissionRequiresAlways && status == .authorizedWhenInUse { return }
+            let granted = status == .authorizedAlways || (!locationPermissionRequiresAlways && status == .authorizedWhenInUse)
             resolveCallback(callbackId, result: permissionStatus(granted, denied: status == .denied, restricted: status == .restricted))
             locationPermissionCallbackId = nil
+            locationPermissionRequiresAlways = false
         }
 
         // MARK: - Memory Usage (for Profiling)
@@ -3478,7 +3986,11 @@ struct CraftWebView: UIViewRepresentable {
 
         // MARK: - Contacts
         private func getContacts(callbackId: String?) {
-            contactStore?.requestAccess(for: .contacts) { [weak self] granted, error in
+            guard let store = contactStore else {
+                rejectCallback(callbackId, error: "Contacts access is disabled", code: "CAPABILITY_DISABLED")
+                return
+            }
+            store.requestAccess(for: .contacts) { [weak self] granted, error in
                 guard granted else {
                     self?.rejectCallback(callbackId, error: error?.localizedDescription ?? "Permission denied")
                     return
@@ -3489,7 +4001,7 @@ struct CraftWebView: UIViewRepresentable {
 
                 var contacts: [[String: Any]] = []
                 do {
-                    try self?.contactStore?.enumerateContacts(with: request) { contact, _ in
+                    try store.enumerateContacts(with: request) { contact, _ in
                         var phones: [String] = []
                         for phone in contact.phoneNumbers {
                             phones.append(phone.value.stringValue)
@@ -3515,9 +4027,13 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         private func addContact(_ data: [String: Any], callbackId: String?) {
-            contactStore?.requestAccess(for: .contacts) { [weak self] granted, error in
+            guard let store = contactStore else {
+                rejectCallback(callbackId, error: "Contacts access is disabled", code: "CAPABILITY_DISABLED")
+                return
+            }
+            store.requestAccess(for: .contacts) { [weak self] granted, error in
                 guard granted else {
-                    self?.rejectCallback(callbackId, error: "Permission denied")
+                    self?.rejectCallback(callbackId, error: error?.localizedDescription ?? "Permission denied")
                     return
                 }
 
@@ -3535,7 +4051,7 @@ struct CraftWebView: UIViewRepresentable {
                 saveRequest.add(contact, toContainerWithIdentifier: nil)
 
                 do {
-                    try self?.contactStore?.execute(saveRequest)
+                    try store.execute(saveRequest)
                     self?.resolveCallback(callbackId, result: contact.identifier)
                 } catch {
                     self?.rejectCallback(callbackId, error: error.localizedDescription)
@@ -3545,17 +4061,23 @@ struct CraftWebView: UIViewRepresentable {
 
         // MARK: - Calendar
         private func getCalendarEvents(startDate: Double?, endDate: Double?, callbackId: String?) {
-            eventStore?.requestAccess(to: .event) { [weak self] granted, error in
+            guard let store = eventStore else {
+                rejectCallback(callbackId, error: "Calendar access is disabled", code: "CAPABILITY_DISABLED")
+                return
+            }
+            store.requestAccess(to: .event) { [weak self] granted, error in
                 guard granted else {
                     self?.rejectCallback(callbackId, error: error?.localizedDescription ?? "Permission denied")
                     return
                 }
 
-                let start = startDate != nil ? Date(timeIntervalSince1970: startDate! / 1000) : Date()
-                let end = endDate != nil ? Date(timeIntervalSince1970: endDate! / 1000) : Calendar.current.date(byAdding: .month, value: 1, to: Date())!
+                let start = startDate.map { Date(timeIntervalSince1970: $0 / 1000) } ?? Date()
+                let end = endDate.map { Date(timeIntervalSince1970: $0 / 1000) }
+                    ?? Calendar.current.date(byAdding: .month, value: 1, to: Date())
+                    ?? Date()
 
-                let predicate = self?.eventStore?.predicateForEvents(withStart: start, end: end, calendars: nil)
-                let events = self?.eventStore?.events(matching: predicate!) ?? []
+                let predicate = store.predicateForEvents(withStart: start, end: end, calendars: nil)
+                let events = store.events(matching: predicate)
 
                 let eventData: [[String: Any]] = events.map { event in
                     return [
@@ -3574,13 +4096,17 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         private func createCalendarEvent(_ data: [String: Any], callbackId: String?) {
-            eventStore?.requestAccess(to: .event) { [weak self] granted, error in
+            guard let store = eventStore else {
+                rejectCallback(callbackId, error: "Calendar access is disabled", code: "CAPABILITY_DISABLED")
+                return
+            }
+            store.requestAccess(to: .event) { [weak self] granted, error in
                 guard granted else {
-                    self?.rejectCallback(callbackId, error: "Permission denied")
+                    self?.rejectCallback(callbackId, error: error?.localizedDescription ?? "Permission denied")
                     return
                 }
 
-                let event = EKEvent(eventStore: self!.eventStore!)
+                let event = EKEvent(eventStore: store)
                 event.title = data["title"] as? String ?? ""
                 event.location = data["location"] as? String
                 event.notes = data["notes"] as? String
@@ -3592,11 +4118,15 @@ struct CraftWebView: UIViewRepresentable {
                     event.endDate = Date(timeIntervalSince1970: end / 1000)
                 }
                 event.isAllDay = data["isAllDay"] as? Bool ?? false
-                event.calendar = self?.eventStore?.defaultCalendarForNewEvents
+                event.calendar = store.defaultCalendarForNewEvents
 
                 do {
-                    try self?.eventStore?.save(event, span: .thisEvent)
-                    self?.resolveCallback(callbackId, result: event.eventIdentifier)
+                    try store.save(event, span: .thisEvent)
+                    guard let identifier = event.eventIdentifier else {
+                        self?.rejectCallback(callbackId, error: "Saved event has no identifier")
+                        return
+                    }
+                    self?.resolveCallback(callbackId, result: identifier)
                 } catch {
                     self?.rejectCallback(callbackId, error: error.localizedDescription)
                 }
@@ -3604,13 +4134,17 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         private func deleteCalendarEvent(_ eventId: String, callbackId: String?) {
-            guard let event = eventStore?.event(withIdentifier: eventId) else {
+            guard let store = eventStore else {
+                rejectCallback(callbackId, error: "Calendar access is disabled", code: "CAPABILITY_DISABLED")
+                return
+            }
+            guard let event = store.event(withIdentifier: eventId) else {
                 rejectCallback(callbackId, error: "Event not found")
                 return
             }
 
             do {
-                try eventStore?.remove(event, span: .thisEvent)
+                try store.remove(event, span: .thisEvent)
                 resolveCallback(callbackId, result: true)
             } catch {
                 rejectCallback(callbackId, error: error.localizedDescription)
@@ -4388,10 +4922,25 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         private func updateLiveActivity(body: [String: Any], callbackId: String?) {
-            guard #available(iOS 16.2, *), let activity = Activity<CraftActivityAttributes>.activities.first else {
+            guard #available(iOS 16.2, *) else {
                 rejectCallback(callbackId, error: "No Live Activity is running")
                 return
             }
+            let activities = Activity<CraftActivityAttributes>.activities
+            let activity: Activity<CraftActivityAttributes>
+            if let activityId = body["id"] as? String {
+                guard let matchingActivity = activities.first(where: { $0.id == activityId }) else {
+                    rejectCallback(callbackId, error: "No Live Activity with id \(activityId) is running")
+                    return
+                }
+                activity = matchingActivity
+            } else {
+                guard let currentActivity = activities.first else {
+                    rejectCallback(callbackId, error: "No Live Activity is running")
+                    return
+                }
+                activity = currentActivity
+            }
             let current = activity.content.state
             let state = CraftActivityAttributes.ContentState(
                 status: body["status"] as? String ?? current.status,
@@ -4405,13 +4954,45 @@ struct CraftWebView: UIViewRepresentable {
             }
         }
 
-        private func endLiveActivity(callbackId: String?) {
-            guard #available(iOS 16.2, *), let activity = Activity<CraftActivityAttributes>.activities.first else {
+        private func endLiveActivity(body: [String: Any], callbackId: String?) {
+            guard #available(iOS 16.2, *) else {
                 resolveCallback(callbackId, result: ["ended": false])
                 return
             }
+            let activities = Activity<CraftActivityAttributes>.activities
+            let activity: Activity<CraftActivityAttributes>
+            if let activityId = body["id"] as? String {
+                guard let matchingActivity = activities.first(where: { $0.id == activityId }) else {
+                    rejectCallback(callbackId, error: "No Live Activity with id \(activityId) is running")
+                    return
+                }
+                activity = matchingActivity
+            } else {
+                guard let currentActivity = activities.first else {
+                    resolveCallback(callbackId, result: ["ended": false])
+                    return
+                }
+                activity = currentActivity
+            }
+            let hasFinalState = body["status"] != nil
+                || body["distanceMeters"] != nil
+                || body["durationSeconds"] != nil
+                || body["progress"] != nil
+            let finalContent: ActivityContent<CraftActivityAttributes.ContentState>?
+            if hasFinalState {
+                let current = activity.content.state
+                let state = CraftActivityAttributes.ContentState(
+                    status: body["status"] as? String ?? current.status,
+                    distanceMeters: body["distanceMeters"] as? Double ?? current.distanceMeters,
+                    durationSeconds: body["durationSeconds"] as? Double ?? current.durationSeconds,
+                    progress: min(max(body["progress"] as? Double ?? current.progress, 0), 1)
+                )
+                finalContent = ActivityContent(state: state, staleDate: nil)
+            } else {
+                finalContent = nil
+            }
             Task {
-                await activity.end(nil, dismissalPolicy: .default)
+                await activity.end(finalContent, dismissalPolicy: .default)
                 resolveCallback(callbackId, result: ["ended": true])
             }
         }
@@ -5039,9 +5620,42 @@ struct CraftWebView: UIViewRepresentable {
             resolveCallback(callbackId, result: ["registered": true, "action": action, "phrase": phrase])
         }
 
+        // Removals waiting on their completion, each under a token of its own:
+        // callbackId can be nil, and restarts when the page reloads.
+        private var pendingSiriRemovals: [UUID: DispatchWorkItem] = [:]
+        // The only thing that settles craft.siri.remove, which arms no timeout
+        // of its own; the same as Zig's.
+        private static let siriRemovalDeadline: TimeInterval = 15
+
         private func removeSiriShortcut(action: String, callbackId: String?) {
+            // The completion comes from a system daemon, and sometimes it never
+            // comes (#211). The deadline settles the call instead, and never
+            // with removed: true, because the deletion may still have happened.
+            // Both run on the main queue and remove the same entry, so only one
+            // of them answers.
+            let token = UUID()
+            let deadline = DispatchWorkItem { [weak self] in
+                guard let self, self.pendingSiriRemovals.removeValue(forKey: token) != nil else { return }
+                self.rejectCallback(
+                    callbackId,
+                    error: "NSUserActivity.deleteSavedUserActivities did not call its completion handler within \(Int(Coordinator.siriRemovalDeadline))s",
+                    code: "TIMEOUT"
+                )
+            }
+            pendingSiriRemovals[token] = deadline
+            DispatchQueue.main.asyncAfter(deadline: .now() + Coordinator.siriRemovalDeadline, execute: deadline)
+
             NSUserActivity.deleteSavedUserActivities(withPersistentIdentifiers: [action]) {
-                self.resolveCallback(callbackId, result: ["removed": true, "action": action])
+                // The queue this runs on is not documented, and a zig: hand-off
+                // reply goes to evaluateJavaScript without a hop of its own.
+                DispatchQueue.main.async { [weak self] in
+                    guard let self, let pending = self.pendingSiriRemovals.removeValue(forKey: token) else {
+                        print("removeSiriShortcut: the completion for \(action) arrived after its deadline; ignored")
+                        return
+                    }
+                    pending.cancel()
+                    self.resolveCallback(callbackId, result: ["removed": true, "action": action])
+                }
             }
         }