@craft-native/ios 0.0.396 → 0.0.409

package/dist/index.d.ts

@@ -46,6 +46,13 @@ export interface CraftConfig {
     backgroundColor?: string;
     /** Default tint for native controls and selected tabs, as #RRGGBB. */
     tintColor?: string;
+    /**
+     * CSS font stack for the native chrome's labels (tab bar, bar buttons); the
+     * first family packaged in `nativeFonts` wins, a generic one keeps the system face.
+     */
+    fontFamily?: string;
+    /** CSS font stack for navigation titles; `fontFamily` when unset. */
+    headingFontFamily?: string;
     /** The launch and webview background while the phone is in Dark Mode. */
     backgroundColorDark?: string;
     /** Edge-swipe back and forward through the page's history, pushState entries included. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/ios",
-  "version": "0.0.396",
+  "version": "0.0.409",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/ios#readme",
   "repository": {
     "type": "git",

package/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/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/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/templates/CraftNativeScreen.swift

@@ -7629,6 +7629,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         appearance.configureWithOpaqueBackground()
         appearance.backgroundColor = screenBackgroundColor ?? config.resolvedBackgroundColor
         appearance.shadowColor = .clear
+        CraftChromeFonts.apply(to: appearance)
         navigationItem.standardAppearance = appearance
         navigationItem.scrollEdgeAppearance = appearance
         navigationItem.compactAppearance = appearance

package/templates/CraftNativeUI.swift

@@ -517,6 +517,95 @@ enum CraftSymbols {
 /// controller, which offers no way to say which style it wants, so the first
 /// call teaches that controller's class to answer from here. Only that exact
 /// class is touched, and only once.
+/// The app's typefaces on UIKit's own chrome. A screen's text follows the
+/// stx tree's `fontFamily`; the navigation bar, the tab bar and bar button
+/// labels are UIKit's, outside that tree, so a branded app drew them in the
+/// system face beside screens in its own. `fontFamily` / `headingFontFamily`
+/// (CSS stacks, as the screens use) put the same faces there, through the
+/// appearance proxies every bar starts from.
+enum CraftChromeFonts {
+    /// The packaged family a body or heading stack resolved to; nil keeps the system face.
+    private(set) static var body: String?
+    private(set) static var heading: String?
+
+    /// The first family of a CSS stack the app can draw. A generic family
+    /// ahead of any packaged one means the system face: nil.
+    static func family(_ stack: String?) -> String? {
+        guard let stack else { return nil }
+        for part in stack.split(separator: ",") {
+            let name = part.trimmingCharacters(in: .whitespacesAndNewlines).trimmingCharacters(in: CharacterSet(charactersIn: "\"'"))
+            switch name.lowercased() {
+            case "": continue
+            case "sans-serif", "ui-sans-serif", "system-ui", "-apple-system", "serif", "ui-serif", "monospace", "ui-monospace": return nil
+            default: if UIFont(name: name, size: 12) != nil { return name }
+            }
+        }
+        return nil
+    }
+
+    /// `family` at a chrome size, bold for a heavy weight and scaled with Dynamic Type.
+    static func font(_ family: String?, size: CGFloat, weight: UIFont.Weight, textStyle: UIFont.TextStyle) -> UIFont? {
+        guard let family, let custom = UIFont(name: family, size: size) else { return nil }
+        var traits = custom.fontDescriptor.symbolicTraits
+        if weight >= .semibold { traits.insert(.traitBold) }
+        let descriptor = custom.fontDescriptor.withSymbolicTraits(traits) ?? custom.fontDescriptor
+        return UIFontMetrics(forTextStyle: textStyle).scaledFont(for: UIFont(descriptor: descriptor, size: size))
+    }
+
+    static var titleFont: UIFont? { font(heading, size: 17, weight: .semibold, textStyle: .headline) }
+    static var largeTitleFont: UIFont? { font(heading, size: 34, weight: .bold, textStyle: .largeTitle) }
+    static var tabLabelFont: UIFont? { font(body, size: 10, weight: .medium, textStyle: .caption2) }
+    static var barButtonFont: UIFont? { font(body, size: 17, weight: .regular, textStyle: .body) }
+
+    static func configure(_ config: CraftConfig) {
+        body = family(config.fontFamily)
+        heading = family(config.headingFontFamily) ?? body
+        if let title = titleFont, let large = largeTitleFont {
+            let bar = UINavigationBar.appearance()
+            bar.titleTextAttributes = [.font: title]
+            bar.largeTitleTextAttributes = [.font: large]
+        }
+        if let label = tabLabelFont {
+            for state in [UIControl.State.normal, .selected] {
+                UITabBarItem.appearance().setTitleTextAttributes([.font: label], for: state)
+            }
+        }
+        if let button = barButtonFont {
+            for state in [UIControl.State.normal, .highlighted, .disabled] {
+                UIBarButtonItem.appearance().setTitleTextAttributes([.font: button], for: state)
+            }
+        }
+    }
+
+    /// The label face on a tab bar. The Liquid Glass bar reads its labels from
+    /// its own appearance and ignores UITabBarItem's proxy, so the face goes on
+    /// a copy of the bar's appearance, which keeps its material untouched.
+    static func apply(to tabBar: UITabBar) {
+        guard let label = tabLabelFont else { return }
+        func labelled(_ appearance: UITabBarAppearance) -> UITabBarAppearance {
+            let copy = appearance.copy()
+            for layout in [copy.stackedLayoutAppearance, copy.inlineLayoutAppearance, copy.compactInlineLayoutAppearance] {
+                for state in [layout.normal, layout.selected, layout.focused, layout.disabled] {
+                    state.titleTextAttributes[.font] = label
+                }
+            }
+            return copy
+        }
+        tabBar.standardAppearance = labelled(tabBar.standardAppearance)
+        if let edge = tabBar.scrollEdgeAppearance { tabBar.scrollEdgeAppearance = labelled(edge) }
+    }
+
+    /// The title faces on a bar appearance a screen builds itself (an opaque bar).
+    static func apply(to appearance: UINavigationBarAppearance) {
+        if let title = titleFont { appearance.titleTextAttributes[.font] = title }
+        if let large = largeTitleFont { appearance.largeTitleTextAttributes[.font] = large }
+        if let button = barButtonFont {
+            appearance.buttonAppearance.normal.titleTextAttributes[.font] = button
+            appearance.doneButtonAppearance.normal.titleTextAttributes[.font] = button
+        }
+    }
+}
+
 enum CraftStatusBar {
     static var style: UIStatusBarStyle = .default
     private static var taught = Set<ObjectIdentifier>()

package/templates/testing/DriverTests.swift.template

@@ -17,7 +17,7 @@ import Darwin
 ///   openurl <url>         opens a link through the system, answering "Open in the app?"
 ///   universallink <https-url> waits up to 60s for an OS-verified link; never opens a browser
 ///   shot <name>           screenshot → shots/<name>.png
-///   tree <name>           accessibility tree → shots/<name>.txt
+///   tree <name>           accessibility tree + identified snapshot values → shots/<name>.txt / <name>-values.json
 ///   tap <text>            first hittable element whose label contains text
 ///   tapif <text>          tap it when it is on screen, else carry on (the big timer's "Show the controls")
 ///   tapid <identifier>
@@ -367,6 +367,22 @@ final class DriverTests: XCTestCase {
             post("/save?name=\(arg).png", shot.pngRepresentation)
         case "tree":
             post("/save?name=\(arg).txt", Data(app.debugDescription.utf8))
+            // debugDescription abbreviates values further than the snapshot.
+            // Retain snapshot values separately; long receipts chunk themselves.
+            do {
+                var values: [[String: String]] = []
+                func collect(_ node: XCUIElementSnapshot) {
+                    if !node.identifier.isEmpty, let value = node.value as? String {
+                        values.append(["id": node.identifier, "label": node.label, "value": value])
+                    }
+                    for child in node.children { collect(child) }
+                }
+                collect(try app.snapshot())
+                let data = try JSONSerialization.data(withJSONObject: values, options: [.sortedKeys])
+                post("/save?name=\(arg)-values.json", data)
+            } catch {
+                XCTFail("Could not retain accessibility values: \(error)")
+            }
         case "tap":
             if let target = waitFor(arg, 10) { press(target); note("tap \(arg): ok") }
             else { XCTFail("Element not found"); note("FAIL tap \(arg): NOT FOUND") }