craft-native 0.0.395 → 0.0.408

package/dist/ios/templates/CraftApp.swift

@@ -288,6 +288,7 @@ final class CraftAppDelegate: NSObject, UIApplicationDelegate, UNUserNotificatio
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
         let config = CraftConfig.bundled()
         CraftInterfaceStyleController.configure(config)
+        CraftChromeFonts.configure(config)
         // First, so a crash anywhere in the rest of launch is reported too.
         CraftCrashReporter.shared.start(config)
         UNUserNotificationCenter.current().delegate = self
@@ -1791,6 +1792,12 @@ struct CraftConfig: Codable {
     var backgroundColor: String = "#1a1a2e"
     /// Default native control and selected-tab tint, independent of page chrome.
     var tintColor: String? = nil
+    /// CSS font stacks for the app's own chrome (navigation titles, tab and
+    /// bar button labels): the first family packaged with the app wins, and a
+    /// generic one (`system-ui`, `sans-serif`) keeps the system face.
+    var fontFamily: String? = nil
+    /// Navigation titles; `fontFamily` when unset.
+    var headingFontFamily: String? = nil
     /// The background while the phone is in Dark Mode; the light one if unset.
     var backgroundColorDark: String? = nil
     /// Edge-swipe back and forward through the page's history.
@@ -2331,6 +2338,28 @@ struct CraftWebView: UIViewRepresentable {
         private var isLocationRecordingPaused = false
         private var locationRecordingId: String?
         private var locationRecordingStartedAt: TimeInterval?
+        /// The power mode the recording was asked for: `default`, `saver` (a
+        /// long recording, an ultra, that trades fixes nobody needs for
+        /// battery) or `auto` (a saver while the device itself is saving
+        /// power). Set by `startRecording`, changed by `setRecordingPowerMode`
+        /// and kept in the state file. See `applyLocationRecordingPower`.
+        private var locationRecordingPowerMode = "default"
+        /// What the recorder is using: the mode, with `auto` resolved from the
+        /// device. Never true outside a recording.
+        private var locationRecordingPowerSaver: Bool {
+            guard isRecordingLocation else { return false }
+            switch locationRecordingPowerMode {
+            case "saver": return true
+            case "auto": return Self.deviceIsSavingPower
+            default: return false
+            }
+        }
+        /// The saver setting `applyLocationRecordingPower` last gave the manager.
+        private var locationRecordingAppliedSaver = false
+        private var locationRecordingPowerObservers: [NSObjectProtocol] = []
+        /// Recent fix speeds while saving power; steady ones relax the accuracy.
+        private var locationRecordingRecentSpeeds: [Double] = []
+        private var locationRecordingSteady = false
         private let recordingDirectory: URL?
         private var locationRecordingRestoreError: Error?
 
@@ -2580,7 +2609,7 @@ struct CraftWebView: UIViewRepresentable {
         /// `craft_ios_deliver_result` instead of evaluating JavaScript here —
         /// one reply path, owned by whichever side received the page's message.
         func dispatch(action: String, body: [String: Any], callbackId: String?) {
-            if ["startLocationRecording", "pauseLocationRecording", "resumeLocationRecording", "stopLocationRecording", "getLocationRecordingState", "readLocationRecording", "acknowledgeLocationRecording"].contains(action),
+            if ["startLocationRecording", "setLocationRecordingPowerMode", "pauseLocationRecording", "resumeLocationRecording", "stopLocationRecording", "getLocationRecordingState", "readLocationRecording", "acknowledgeLocationRecording"].contains(action),
                locationRecordingRestoreError != nil {
                 rejectCallback(callbackId, error: "Unable to restore recording data", code: "RECORDING_STORAGE_ERROR")
                 return
@@ -2799,6 +2828,14 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "Geolocation is disabled", code: "CAPABILITY_DISABLED")
                 }
+            case "setLocationRecordingPowerMode":
+                if !CraftZigRuntime.supportsRecordingPowerMode {
+                    rejectCallback(callbackId, error: "The linked runtime's recorder has no power modes", code: "RECORDING_POWER_MODE_UNSUPPORTED")
+                } else if config.enableGeolocation {
+                    if requireLocationRecordingOwner(body, callbackId: callbackId) { setLocationRecordingPowerMode(body: body, callbackId: callbackId) }
+                } else {
+                    rejectCallback(callbackId, error: "Geolocation is disabled", code: "CAPABILITY_DISABLED")
+                }
             case "pauseLocationRecording":
                 if requireLocationRecordingOwner(body, callbackId: callbackId) { pauseLocationRecording(callbackId: callbackId) }
             case "resumeLocationRecording":
@@ -2808,7 +2845,7 @@ struct CraftWebView: UIViewRepresentable {
             case "getLocationRecordingState":
                 getLocationRecordingState(callbackId: callbackId)
             case "readLocationRecording":
-                if requireLocationRecordingOwner(body, callbackId: callbackId) { readLocationRecording(callbackId: callbackId) }
+                if requireLocationRecordingOwner(body, callbackId: callbackId) { readLocationRecording(body: body, callbackId: callbackId) }
             case "acknowledgeLocationRecording":
                 _ = archivedLocationAction(action, body: body, callbackId: callbackId)
             // App Badge
@@ -4169,6 +4206,7 @@ struct CraftWebView: UIViewRepresentable {
                     crypto: true,
                     locationRecordingOwnership: \(config.enableGeolocation && CraftZigRuntime.supportsRecordingOwnership),
                     locationRecordingIntentIdentity: \(config.enableGeolocation && CraftZigRuntime.supportsRecordingIntentIdentity),
+                    locationRecordingPowerMode: \(config.enableGeolocation && CraftZigRuntime.supportsRecordingPowerMode),
                     backgroundLocation: \(config.enableBackgroundLocation),
                     healthKit: \(config.enableHealthKit),
                     liveActivities: \(config.enableLiveActivities),
@@ -5772,7 +5810,7 @@ struct CraftWebView: UIViewRepresentable {
                 };
                 craft._invoke = function(action, payload) {
                     var recordingOptions = action === 'heartRate' && payload && ['startRecording', 'pauseRecording', 'resumeRecording', 'stopRecording', 'readRecording', 'getRecordingState', 'acknowledgeRecording'].indexOf(payload.method) !== -1
-                        ? payload.options : ['startLocationRecording', 'pauseLocationRecording', 'resumeLocationRecording', 'stopLocationRecording', 'readLocationRecording', 'getLocationRecordingState', 'acknowledgeLocationRecording'].indexOf(action) !== -1 ? payload : null;
+                        ? payload.options : ['startLocationRecording', 'setLocationRecordingPowerMode', 'pauseLocationRecording', 'resumeLocationRecording', 'stopLocationRecording', 'readLocationRecording', 'getLocationRecordingState', 'acknowledgeLocationRecording'].indexOf(action) !== -1 ? payload : null;
                     if (recordingOptions && Object.prototype.hasOwnProperty.call(recordingOptions, 'recordingId') &&
                         (typeof recordingOptions.recordingId !== 'string' || !recordingOptions.recordingId.trim())) {
                         var invalidStart = new Error('recordingId must be a nonempty recording ID');
@@ -5950,6 +5988,7 @@ struct CraftWebView: UIViewRepresentable {
                         void stopLocationWatchIfUnused().catch(function() {});
                     },
                     startRecording: function(options) { return craft._invoke('startLocationRecording', options || {}); },
+                    setRecordingPowerMode: function(options) { return craft._invoke('setLocationRecordingPowerMode', options || {}); },
                     pauseRecording: function(options) { return craft._invoke('pauseLocationRecording', options || {}); },
                     resumeRecording: function(options) { return craft._invoke('resumeLocationRecording', options || {}); },
                     stopRecording: function(options) { return craft._invoke('stopLocationRecording', options || {}); },
@@ -6906,9 +6945,13 @@ struct CraftWebView: UIViewRepresentable {
                 return
             }
             manager.delegate = self
-            manager.desiredAccuracy = body["enableHighAccuracy"] as? Bool == true
-                ? kCLLocationAccuracyBest
-                : kCLLocationAccuracyHundredMeters
+            // A recording in progress owns the shared manager's accuracy: a
+            // one-off fix must neither coarsen it nor undo its power saving.
+            if !(isRecordingLocation && !isLocationRecordingPaused) {
+                manager.desiredAccuracy = body["enableHighAccuracy"] as? Bool == true
+                    ? kCLLocationAccuracyBest
+                    : kCLLocationAccuracyHundredMeters
+            }
 
             if let pendingCallbackId = singleLocationCallbackId {
                 finishSingleLocationRequest()
@@ -6974,7 +7017,113 @@ struct CraftWebView: UIViewRepresentable {
             singleLocationCallbackId = nil
             singleLocationAcquisitionStarted = false
             singleLocationAuthorizationRequested = false
-            locationManager?.desiredAccuracy = kCLLocationAccuracyBest
+            locationManager?.desiredAccuracy = recordingDesiredAccuracy
+        }
+
+        /// Fixes at least this far apart, metres, while saving power. A
+        /// filter of d metres spaces fixes d/v seconds apart at v m/s; the
+        /// route counts fixes more than 30 s apart as a pause, so d must stay
+        /// under 30 s at the slowest speed that still counts as moving (0.2
+        /// m/s on the server): 5 m is 25 s at 0.2 m/s.
+        static let powerSaverDistanceFilterM: CLLocationDistance = 5
+
+        /// Best, except while a power-saving recording holds a steady speed.
+        private var recordingDesiredAccuracy: CLLocationAccuracy {
+            locationRecordingPowerSaver && locationRecordingSteady ? kCLLocationAccuracyNearestTenMeters : kCLLocationAccuracyBest
+        }
+
+        /// The manager's filter and accuracy for the recording's power mode.
+        private func applyLocationRecordingPower() {
+            let saver = locationRecordingPowerSaver
+            locationRecordingAppliedSaver = saver
+            locationManager?.distanceFilter = saver ? Self.powerSaverDistanceFilterM : kCLDistanceFilterNone
+            if singleLocationCallbackId == nil || (isRecordingLocation && !isLocationRecordingPaused) {
+                locationManager?.desiredAccuracy = recordingDesiredAccuracy
+            }
+        }
+
+        /// A new mode, a resume or a change of the device's power state starts
+        /// the steady-pace history over: speeds seen under the old setting say
+        /// nothing about the new one.
+        private func resetLocationRecordingPace() {
+            locationRecordingRecentSpeeds.removeAll()
+            locationRecordingSteady = false
+        }
+
+        /// Under this charge, unplugged, `auto` saves power.
+        static let autoPowerSaverBatteryLevel: Float = 0.2
+
+        /// The device wants power saved: Low Power Mode, or a battery under
+        /// 20% that is not charging (`unplugged`; an unknown state, as in the
+        /// simulator, does not count).
+        static var deviceIsSavingPower: Bool {
+            if ProcessInfo.processInfo.isLowPowerModeEnabled { return true }
+            let device = UIDevice.current
+            return device.isBatteryMonitoringEnabled && device.batteryState == .unplugged
+                && device.batteryLevel >= 0 && device.batteryLevel < autoPowerSaverBatteryLevel
+        }
+
+        /// `auto` follows the platform's own change notifications, only while a
+        /// recording runs in that mode, so no other recording pays for them.
+        private func updateLocationRecordingPowerObservers() {
+            let wanted = isRecordingLocation && locationRecordingPowerMode == "auto"
+            guard wanted != !locationRecordingPowerObservers.isEmpty else { return }
+            let center = NotificationCenter.default
+            if !wanted {
+                locationRecordingPowerObservers.forEach { center.removeObserver($0) }
+                locationRecordingPowerObservers.removeAll()
+                UIDevice.current.isBatteryMonitoringEnabled = false
+                return
+            }
+            UIDevice.current.isBatteryMonitoringEnabled = true
+            let names: [Notification.Name] = [
+                .NSProcessInfoPowerStateDidChange,
+                UIDevice.batteryLevelDidChangeNotification,
+                UIDevice.batteryStateDidChangeNotification,
+            ]
+            locationRecordingPowerObservers = names.map { name in
+                center.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in
+                    self?.locationRecordingDeviceStateChanged()
+                }
+            }
+        }
+
+        /// The device's power state changed: re-resolve `auto`, and only touch
+        /// the manager when the answer is different.
+        private func locationRecordingDeviceStateChanged() {
+            guard isRecordingLocation, locationRecordingPowerMode == "auto",
+                  locationRecordingPowerSaver != locationRecordingAppliedSaver else { return }
+            resetLocationRecordingPace()
+            applyLocationRecordingPower()
+        }
+
+        static let recordingPowerModes = ["default", "saver", "auto"]
+
+        /// A mode the page may ask for; nil for anything else, `nil` included.
+        private static func recordingPowerMode(_ value: Any?) -> String? {
+            guard let mode = value as? String, recordingPowerModes.contains(mode) else { return nil }
+            return mode
+        }
+
+        /// Steady: the last ten fixes within a fifth of their mean speed, at
+        /// least a slow walk, each accurate to 10 m. Anything else (a change
+        /// of pace, a weak signal) goes straight back to Best.
+        private func noteLocationRecordingSpeed(_ location: CLLocation) {
+            guard locationRecordingPowerSaver else { return }
+            let usable = location.speed >= 0 && location.horizontalAccuracy >= 0 && location.horizontalAccuracy <= 10
+            if usable {
+                locationRecordingRecentSpeeds.append(location.speed)
+                if locationRecordingRecentSpeeds.count > 10 { locationRecordingRecentSpeeds.removeFirst(locationRecordingRecentSpeeds.count - 10) }
+            } else if location.horizontalAccuracy > 20 || location.horizontalAccuracy < 0 {
+                locationRecordingRecentSpeeds.removeAll()
+            }
+            let speeds = locationRecordingRecentSpeeds
+            let mean = speeds.isEmpty ? 0 : speeds.reduce(0, +) / Double(speeds.count)
+            let steady = speeds.count >= 10 && mean >= 0.8 && speeds.allSatisfy { abs($0 - mean) <= mean * 0.2 }
+            if steady != locationRecordingSteady {
+                locationRecordingSteady = steady
+                applyLocationRecordingPower()
+            }
         }
 
         private func locationData(_ location: CLLocation) -> [String: Any] {
@@ -7046,7 +7195,7 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         private func persistLocationRecordingState() throws {
-            let state: [String: Any] = ["active": isRecordingLocation, "paused": isLocationRecordingPaused, "id": locationRecordingId ?? NSNull(), "startedAt": locationRecordingStartedAt ?? NSNull()]
+            let state: [String: Any] = ["active": isRecordingLocation, "paused": isLocationRecordingPaused, "id": locationRecordingId ?? NSNull(), "startedAt": locationRecordingStartedAt ?? NSNull(), "powerMode": locationRecordingPowerMode]
             try CraftRecordingArchive.writeAtomically(JSONSerialization.data(withJSONObject: state), locationRecordingStateURL)
         }
 
@@ -7067,6 +7216,7 @@ struct CraftWebView: UIViewRepresentable {
             isLocationRecordingPaused = state["paused"] as? Bool ?? false
             locationRecordingId = state["id"] as? String
             locationRecordingStartedAt = state["startedAt"] as? TimeInterval
+            locationRecordingPowerMode = Self.recordingPowerMode(state["powerMode"]) ?? "default"
             if let id = locationRecordingId, try CraftRecordingArchive.isAcknowledged(recordingBaseDirectory, "location", id) {
                 try CraftRecordingArchive.acknowledge(recordingBaseDirectory, "location", id)
                 if FileManager.default.fileExists(atPath: locationRecordingTrackURL.path) { try FileManager.default.removeItem(at: locationRecordingTrackURL) }
@@ -7076,9 +7226,11 @@ struct CraftWebView: UIViewRepresentable {
                 isLocationRecordingPaused = false
                 try persistLocationRecordingState()
             }
+            updateLocationRecordingPowerObservers()
             if isRecordingLocation && !isLocationRecordingPaused {
                 locationManager?.delegate = self
                 configureBackgroundLocationIfNeeded()
+                applyLocationRecordingPower()
                 locationManager?.startUpdatingLocation()
             }
 
@@ -7161,6 +7313,14 @@ struct CraftWebView: UIViewRepresentable {
                 rejectCallback(callbackId, error: "A location recording is already active", code: "RECORDING_ALREADY_ACTIVE")
                 return
             }
+            var powerMode = "default"
+            if let requested = body["powerMode"], !(requested is NSNull) {
+                guard let mode = Self.recordingPowerMode(requested) else {
+                    rejectCallback(callbackId, error: "powerMode must be 'default', 'saver' or 'auto'", code: "INVALID_ARGUMENT")
+                    return
+                }
+                powerMode = mode
+            }
             let directory = locationRecordingTrackURL.deletingLastPathComponent()
             let id: String
             do {
@@ -7176,20 +7336,24 @@ struct CraftWebView: UIViewRepresentable {
                 rejectCallback(callbackId, error: "Unable to create the location recording", code: "RECORDING_STORAGE_ERROR")
                 return
             }
-            let previous = (locationRecordingId, locationRecordingStartedAt, isRecordingLocation, isLocationRecordingPaused)
+            let previous = (locationRecordingId, locationRecordingStartedAt, isRecordingLocation, isLocationRecordingPaused, locationRecordingPowerMode)
             locationRecordingId = id
             locationRecordingStartedAt = Date().timeIntervalSince1970 * 1000
             isRecordingLocation = true
             isLocationRecordingPaused = false
+            locationRecordingPowerMode = powerMode
+            resetLocationRecordingPace()
             do { try persistLocationRecordingState() }
             catch {
-                (locationRecordingId, locationRecordingStartedAt, isRecordingLocation, isLocationRecordingPaused) = previous
+                (locationRecordingId, locationRecordingStartedAt, isRecordingLocation, isLocationRecordingPaused, locationRecordingPowerMode) = previous
                 rejectCallback(callbackId, error: "Unable to persist the location recording", code: "RECORDING_STORAGE_ERROR")
                 return
             }
             locationManager?.delegate = self
             requestLocationAuthorization()
             configureBackgroundLocationIfNeeded()
+            updateLocationRecordingPowerObservers()
+            applyLocationRecordingPower()
             locationManager?.startUpdatingLocation()
             resolveCallback(callbackId, result: locationRecordingSummary())
 
@@ -7198,6 +7362,31 @@ struct CraftWebView: UIViewRepresentable {
             #endif
         }
 
+        /// Change the running recording's power mode. The state file carries it,
+        /// so a relaunch restores what was last asked for.
+        private func setLocationRecordingPowerMode(body: [String: Any], callbackId: String?) {
+            guard let mode = Self.recordingPowerMode(body["powerMode"]) else {
+                rejectCallback(callbackId, error: "powerMode must be 'default', 'saver' or 'auto'", code: "INVALID_ARGUMENT")
+                return
+            }
+            guard isRecordingLocation else {
+                rejectCallback(callbackId, error: "No active location recording", code: "NO_ACTIVE_RECORDING")
+                return
+            }
+            let previous = locationRecordingPowerMode
+            locationRecordingPowerMode = mode
+            do { try persistLocationRecordingState() }
+            catch {
+                locationRecordingPowerMode = previous
+                rejectCallback(callbackId, error: "Unable to persist the location recording", code: "RECORDING_STORAGE_ERROR")
+                return
+            }
+            resetLocationRecordingPace()
+            updateLocationRecordingPowerObservers()
+            applyLocationRecordingPower()
+            resolveCallback(callbackId, result: locationRecordingSummary())
+        }
+
         private func pauseLocationRecording(callbackId: String?) {
             guard isRecordingLocation else {
                 rejectCallback(callbackId, error: "No active location recording", code: "NO_ACTIVE_RECORDING")
@@ -7235,6 +7424,11 @@ struct CraftWebView: UIViewRepresentable {
             locationManager?.delegate = self
             requestLocationAuthorization()
             configureBackgroundLocationIfNeeded()
+            // The manager forgets nothing across a pause, but the pace seen
+            // before it says nothing about the pace after it, and a recording
+            // restored while paused never had its filter set at all.
+            resetLocationRecordingPace()
+            applyLocationRecordingPower()
             locationManager?.startUpdatingLocation()
             resolveCallback(callbackId, result: locationRecordingSummary())
 
@@ -7255,6 +7449,9 @@ struct CraftWebView: UIViewRepresentable {
                     locationManager?.stopUpdatingLocation()
                     locationManager?.allowsBackgroundLocationUpdates = false
                 }
+                resetLocationRecordingPace()
+                updateLocationRecordingPowerObservers()
+                applyLocationRecordingPower()
                 var summary = locationRecordingSummary()
                 summary["locations"] = locations
                 resolveCallback(callbackId, result: summary)
@@ -7267,8 +7464,18 @@ struct CraftWebView: UIViewRepresentable {
             resolveCallback(callbackId, result: summary)
         }
 
-        private func readLocationRecording(callbackId: String?) {
-            do { resolveCallback(callbackId, result: try loadRecordedLocationsStrict()) }
+        /// The recording's fixes, or with `since` (epoch ms) only those recorded
+        /// after it. A screen showing a long run reads every few seconds, and a
+        /// 20-hour track is ~72,000 lines: `since` reads the file's tail, not all
+        /// of it, so each read costs what the new fixes do.
+        private func readLocationRecording(body: [String: Any], callbackId: String?) {
+            do {
+                if let since = (body["since"] as? NSNumber)?.doubleValue, since.isFinite {
+                    resolveCallback(callbackId, result: try loadRecordedLocationsStrict(after: since))
+                } else {
+                    resolveCallback(callbackId, result: try loadRecordedLocationsStrict())
+                }
+            }
             catch { rejectCallback(callbackId, error: "Unable to read the location recording", code: "RECORDING_STORAGE_ERROR") }
         }
 
@@ -7278,6 +7485,8 @@ struct CraftWebView: UIViewRepresentable {
                 "active": isRecordingLocation,
                 "paused": isLocationRecordingPaused,
                 "startedAt": locationRecordingStartedAt ?? NSNull(),
+                "powerMode": locationRecordingPowerMode,
+                "effectivePowerMode": locationRecordingPowerSaver ? "saver" : "default",
             ]
         }
 
@@ -7306,6 +7515,39 @@ struct CraftWebView: UIViewRepresentable {
 
         private func loadRecordedLocations() -> [[String: Any]] { (try? loadRecordedLocationsStrict()) ?? [] }
 
+        /// The fixes recorded after `since` (epoch ms), oldest first, read from
+        /// the end of the track backwards: a window of the file's last bytes,
+        /// widened until it reaches a fix at or before `since` or the start.
+        /// Fixes are appended in time order, one JSON object per line.
+        private func loadRecordedLocationsStrict(after since: Double) throws -> [[String: Any]] {
+            if locationRecordingId == nil { return [] }
+            let handle = try FileHandle(forReadingFrom: locationRecordingTrackURL)
+            defer { try? handle.close() }
+            let size = try handle.seekToEnd()
+            var window: UInt64 = 64 * 1024
+            while true {
+                let start = size > window ? size - window : 0
+                try handle.seek(toOffset: start)
+                let data = try handle.readToEnd() ?? Data()
+                var lines = data.split(separator: 0x0A, omittingEmptySubsequences: true)
+                // Mid-file, the window's first line may be cut: it is older than
+                // every line after it, so it is never the one needed.
+                if start > 0, !lines.isEmpty { lines.removeFirst() }
+                var newer: [[String: Any]] = []
+                var reachedOlder = start == 0
+                for line in lines.reversed() {
+                    guard let fix = try? JSONSerialization.jsonObject(with: Data(line)) as? [String: Any] else { continue }
+                    if let time = (fix["timestamp"] as? NSNumber)?.doubleValue, time <= since {
+                        reachedOlder = true
+                        break
+                    }
+                    newer.append(fix)
+                }
+                if reachedOlder { return Array(newer.reversed()) }
+                window *= 4
+            }
+        }
+
         private func loadRecordedLocationsStrict() throws -> [[String: Any]] {
             if locationRecordingId == nil { return [] }
             let text = try String(contentsOf: locationRecordingTrackURL, encoding: .utf8)
@@ -7325,7 +7567,17 @@ struct CraftWebView: UIViewRepresentable {
             }
 
             if isRecordingLocation, let id = locationRecordingId { data["recordingId"] = id }
+            // In the background Core Location can hand over several fixes at
+            // once: the recording keeps each of them, not just the newest, or
+            // the route would have holes a pause is made of.
+            for earlier in locations.dropLast() {
+                var sample = locationData(earlier)
+                if isRecordingLocation, let id = locationRecordingId { sample["recordingId"] = id }
+                appendRecordedLocation(sample)
+                noteLocationRecordingSpeed(earlier)
+            }
             appendRecordedLocation(data)
+            noteLocationRecordingSpeed(location)
             if isWatchingLocation || isRecordingLocation {
                 sendToWeb("craftLocationUpdate", data: data)
             }
@@ -9843,6 +10095,10 @@ final class CraftZigRuntime: NSObject {
         return unsafeBitCast(symbol, to: RecordingOwnershipVersionFn.self)() >= 1
     }
 
+    /// Power modes belong to Swift's recorder. A linked Zig runtime owns the
+    /// recorder instead and has no power mode, so it must not be advertised.
+    static var supportsRecordingPowerMode: Bool { !isLinked }
+
     static var supportsRecordingIntentIdentity: Bool {
         if !isLinked { return true }
         guard performRecordingFn != nil,

package/dist/ios/templates/CraftHybrid.swift

@@ -1184,6 +1184,7 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
 #if compiler(>=6.2)
         if #available(iOS 26.0, *) { tabBarMinimizeBehavior = .never }
 #endif
+        CraftChromeFonts.apply(to: tabBar)
         accessoryButton.accessibilityIdentifier = "craft-tab-accessory"
         accessoryButton.addTarget(self, action: #selector(openTabAccessory), for: .touchUpInside)
         chromeSubscription = CraftChrome.shared.objectWillChange.sink { [weak self] in

package/dist/ios/templates/CraftNativeActions.swift

@@ -79,6 +79,7 @@ enum CraftNativeActions {
             values.append("geolocation")
             if CraftZigRuntime.supportsRecordingOwnership { values.append("locationRecordingOwnership") }
             if CraftZigRuntime.supportsRecordingIntentIdentity { values.append("locationRecordingIntentIdentity") }
+            if CraftZigRuntime.supportsRecordingPowerMode { values.append("locationRecordingPowerMode") }
         }
         // The Music app's song and transport are the coordinator's too.
         if config.enableAppleMusic { values.append("music") }
@@ -494,7 +495,8 @@ enum CraftNativeActions {
             }
             let actions = [
                 "getCurrentPosition": "getCurrentPosition", "watchPosition": "watchPosition", "clearWatch": "clearWatch",
-                "startRecording": "startLocationRecording", "pauseRecording": "pauseLocationRecording",
+                "startRecording": "startLocationRecording", "setRecordingPowerMode": "setLocationRecordingPowerMode",
+                "pauseRecording": "pauseLocationRecording",
                 "resumeRecording": "resumeLocationRecording", "stopRecording": "stopLocationRecording",
                 "getRecordingState": "getLocationRecordingState", "readRecording": "readLocationRecording",
                 "acknowledgeRecording": "acknowledgeLocationRecording",

package/dist/ios/templates/CraftNativeFlatList.swift

@@ -42,6 +42,10 @@ private final class CraftNativeFlatListLayout: UICollectionViewFlowLayout {
 /// The screen controller owns rendered row state; this view owns collection
 /// diffs, viewport state, and UICollectionView cell reuse.
 final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowLayout, UIGestureRecognizerDelegate {
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        craftPointerHitTest(point, with: event) { super.hitTest(point, with: event) }
+    }
+
     typealias RenderItem = (_ node: [String: Any], _ identity: String, _ previous: UIView?) -> UIView
 
     private final class Cell: UICollectionViewCell {

package/dist/ios/templates/CraftNativeMutation.swift

@@ -35,6 +35,9 @@ final class CraftNativeMutationDocument {
         var style: [String: Any]
         var events: [String: Any]
         var text: [String]
+        // Legacy snapshots may interleave bare text and native children.
+        // Keep each text fragment's slot among the child nodes on import.
+        var textPositions: [Int]? = nil
         var children: [String]
         var parent: String?
     }
@@ -43,6 +46,11 @@ final class CraftNativeMutationDocument {
     private var rootId: String?
     private(set) var revision = 0
 
+    /// The normalized committed tree, whose root need not be named "root".
+    var document: [String: Any]? {
+        rootId.flatMap { materialize($0, nodes: nodes) }
+    }
+
     func replace(with document: [String: Any]) {
         var replacement: [String: Node] = [:]
         let root = importNode(document, preferredId: "root", parent: nil, nodes: &replacement)
@@ -217,6 +225,7 @@ final class CraftNativeMutationDocument {
         if patch.keys.contains("events") { mergePatch(patch["events"], into: &node.events) }
         if patch.keys.contains("children") || patch.keys.contains("text") {
             node.text = try textChildren(patch["children"] ?? patch["text"])
+            node.textPositions = nil
         }
         nodes[id] = node
     }
@@ -422,9 +431,18 @@ final class CraftNativeMutationDocument {
             "events": node.events,
         ]
         if let key = node.key { value["key"] = key }
-        let text: [Any] = node.text
         let children: [Any] = node.children.compactMap { materialize($0, nodes: nodes) }
-        value["children"] = text + children
+        var content: [Any] = []
+        var textIndex = 0
+        for index in 0...children.count {
+            while textIndex < node.text.count,
+                  min(node.textPositions?[textIndex] ?? 0, children.count) == index {
+                content.append(node.text[textIndex])
+                textIndex += 1
+            }
+            if index < children.count { content.append(children[index]) }
+        }
+        value["children"] = content
         return value
     }
 
@@ -440,6 +458,12 @@ final class CraftNativeMutationDocument {
         var id = explicit ?? key.map { "\(parent ?? "root")/key:\($0)" } ?? preferredId
         if nodes[id] != nil { id = "\(preferredId)#\(nodes.count)" }
         let children = value["children"] as? [Any] ?? []
+        var textPositions: [Int] = []
+        var childCount = 0
+        for child in children {
+            if child is String { textPositions.append(childCount) }
+            else if child is [String: Any] { childCount += 1 }
+        }
         nodes[id] = Node(
             id: id,
             key: value["key"] as? String,
@@ -448,6 +472,7 @@ final class CraftNativeMutationDocument {
             style: dictionary(value["style"]),
             events: dictionary(value["events"]),
             text: children.compactMap { $0 as? String },
+            textPositions: textPositions,
             children: [],
             parent: parent
         )