craft-native 0.0.396 → 0.0.408

package/dist/index.js

@@ -117,7 +117,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.396";
+var version = "0.0.408";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -5247,6 +5247,7 @@ var secureStorage = {
     Object.keys(localStorage).filter((k) => k.startsWith("secure_")).forEach((k) => localStorage.removeItem(k));
   }
 };
+var RECORDING_POWER_MODES = ["default", "saver", "auto"];
 function storageHost(method) {
   const host = getCraftRoot()?.storage;
   if (typeof host?.[method] !== "function")
@@ -5310,6 +5311,23 @@ function recordingIntentSupported(namespace) {
   const advertised = Array.isArray(caps) ? caps.includes(flag) : caps?.[flag] === true;
   return advertised && recordingOwnershipSupported(namespace) && typeof root?.[namespace]?.startRecording === "function";
 }
+function recordingPowerModeSupported() {
+  const root = getCraftRoot();
+  const caps = root?.capabilities;
+  const advertised = Array.isArray(caps) ? caps.includes("locationRecordingPowerMode") : caps?.locationRecordingPowerMode === true;
+  return advertised && recordingOwnershipSupported("location") && typeof root?.location?.setRecordingPowerMode === "function";
+}
+function validatePowerMode(value) {
+  if (typeof value !== "string" || !RECORDING_POWER_MODES.includes(value))
+    throw Object.assign(new Error("powerMode must be 'default', 'saver' or 'auto'"), { code: "INVALID_ARGUMENT" });
+  return value;
+}
+function validateRecordingPowerStart(options) {
+  if (!Object.prototype.hasOwnProperty.call(options, "powerMode") || options.powerMode === undefined)
+    return;
+  if (validatePowerMode(options.powerMode) === "auto" && getCraftRoot() && !recordingPowerModeSupported())
+    throw Object.assign(new Error("This app build cannot start a recording in powerMode 'auto'"), { code: "RECORDING_POWER_MODE_UNSUPPORTED" });
+}
 function validateRecordingStart(namespace, options) {
   if (!Object.prototype.hasOwnProperty.call(options, "recordingId"))
     return;
@@ -5340,10 +5358,20 @@ var webLocationRecording = {
   startedAt: null,
   locations: []
 };
+var webLocationPowerMode = "default";
+function webLocationRecordingState() {
+  return {
+    ...webLocationRecording,
+    sampleCount: webLocationRecording.locations.length,
+    powerMode: webLocationPowerMode,
+    effectivePowerMode: webLocationRecording.active && webLocationPowerMode === "saver" ? "saver" : "default"
+  };
+}
 var webLocationRecordingWatchId = null;
 var location = {
   supportsRecordingOwnership: () => recordingOwnershipSupported("location"),
   supportsRecordingIntentIdentity: () => recordingIntentSupported("location"),
+  supportsRecordingPowerMode: () => recordingPowerModeSupported(),
   async getCurrentPosition(options = {}) {
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location) {
@@ -5393,6 +5421,7 @@ var location = {
   },
   async startRecording(options = {}) {
     validateRecordingStart("location", options);
+    validateRecordingPowerStart(options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.startRecording)
       return verifyRecordingStart(options, await craft.location.startRecording(options));
@@ -5407,11 +5436,27 @@ var location = {
       startedAt: Date.now(),
       locations: []
     };
+    webLocationPowerMode = options.powerMode ?? "default";
     webLocationRecordingWatchId = location.watchPosition((position) => {
       if (!webLocationRecording.paused)
         webLocationRecording.locations.push(position);
     }, options);
-    return { ...webLocationRecording, sampleCount: 0 };
+    return webLocationRecordingState();
+  },
+  async setRecordingPowerMode(options) {
+    if (!options || !Object.prototype.hasOwnProperty.call(options, "expectedId"))
+      throw Object.assign(new Error("setRecordingPowerMode needs expectedId"), { code: "INVALID_ARGUMENT" });
+    validateRecordingOwnership("location", options);
+    const powerMode = validatePowerMode(options.powerMode);
+    if (getCraftRoot() && !recordingPowerModeSupported())
+      throw Object.assign(new Error("This app build cannot change the recording power mode"), { code: "RECORDING_POWER_MODE_UNSUPPORTED" });
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.location?.setRecordingPowerMode)
+      return craft.location.setRecordingPowerMode({ expectedId: options.expectedId, powerMode });
+    if (!webLocationRecording.active)
+      throw Object.assign(new Error("No active location recording"), { code: "NO_ACTIVE_RECORDING" });
+    webLocationPowerMode = powerMode;
+    return webLocationRecordingState();
   },
   async pauseRecording(options) {
     validateRecordingOwnership("location", options);
@@ -5419,7 +5464,7 @@ var location = {
     if (typeof window !== "undefined" && craft?.location?.pauseRecording)
       return craft.location.pauseRecording(options);
     webLocationRecording.paused = true;
-    return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
+    return webLocationRecordingState();
   },
   async resumeRecording(options) {
     validateRecordingOwnership("location", options);
@@ -5427,7 +5472,7 @@ var location = {
     if (typeof window !== "undefined" && craft?.location?.resumeRecording)
       return craft.location.resumeRecording(options);
     webLocationRecording.paused = false;
-    return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
+    return webLocationRecordingState();
   },
   async stopRecording(options) {
     validateRecordingOwnership("location", options);
@@ -5440,14 +5485,14 @@ var location = {
     }
     webLocationRecording.active = false;
     webLocationRecording.paused = false;
-    return { ...webLocationRecording, locations: [...webLocationRecording.locations] };
+    return { ...webLocationRecordingState(), locations: [...webLocationRecording.locations] };
   },
   async getRecordingState(options) {
     validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.getRecordingState)
       return craft.location.getRecordingState(options);
-    return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
+    return webLocationRecordingState();
   },
   async acknowledgeRecording(options) {
     if (!options || !Object.prototype.hasOwnProperty.call(options, "expectedId"))
@@ -5459,6 +5504,7 @@ var location = {
     if (webLocationRecording.active)
       throw Object.assign(new Error("The recording is still active"), { code: "RECORDING_ALREADY_ACTIVE" });
     webLocationRecording = { id: null, active: false, paused: false, startedAt: null, locations: [] };
+    webLocationPowerMode = "default";
     return true;
   },
   async readRecording(options) {
@@ -5466,7 +5512,8 @@ var location = {
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.readRecording)
       return craft.location.readRecording(options);
-    return [...webLocationRecording.locations];
+    const since = options?.since;
+    return typeof since === "number" && Number.isFinite(since) ? webLocationRecording.locations.filter((location) => location.timestamp > since) : [...webLocationRecording.locations];
   }
 };
 var share = {

package/dist/ios/src/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/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",