@craft-native/ios 0.0.435 → 0.0.442

package/dist/cli.js

@@ -24,7 +24,7 @@ function iosPermissions(config) {
     contacts: config.enableContacts,
     calendar: config.enableCalendar,
     bluetooth: config.enableBluetooth || config.enableHeartRate,
-    motion: config.enableMotionSensors || config.enableShakeGesture,
+    motion: config.enableMotionSensors || config.enableShakeGesture || config.enableBarometer || config.enablePedometer,
     biometric: config.enableBiometric,
     music: config.enableAppleMusic,
     health: config.enableHealthKit,
@@ -504,11 +504,16 @@ var DEFAULT_CONFIG = {
   enableAudioRecording: false,
   enableVideoRecording: false,
   enableMotionSensors: false,
+  enableBarometer: false,
+  enablePedometer: false,
   enableShakeGesture: false,
   enableLocalDatabase: false,
   enableBluetooth: false,
   enableNFC: false,
   enableHealthKit: false,
+  enableHealthKitBackground: false,
+  healthKitBackgroundTypes: [],
+  healthKitBackgroundFrequency: "hourly",
   enableWallet: false,
   enableLiveActivities: false,
   enableWatchApp: false,
@@ -565,7 +570,7 @@ function renderUsageDescriptions(config) {
     [config.enableContacts, "NSContactsUsageDescription", `${config.appName} accesses contacts only when you choose a contact feature.`],
     [config.enableCalendar, "NSCalendarsUsageDescription", `${config.appName} accesses your calendar only when you choose a calendar feature.`],
     [config.enableBluetooth || config.enableHeartRate, "NSBluetoothAlwaysUsageDescription", config.enableHeartRate ? `${config.appName} connects to your heart-rate monitor over Bluetooth to show and record your heart rate during a workout.` : `${config.appName} uses Bluetooth to connect to nearby devices.`],
-    [config.enableMotionSensors, "NSMotionUsageDescription", `${config.appName} uses motion data for activity features.`],
+    [config.enableMotionSensors || config.enableBarometer || config.enablePedometer, "NSMotionUsageDescription", `${config.appName} uses motion data for activity features.`],
     [config.enableNFC, "NFCReaderUsageDescription", `${config.appName} reads NFC tags when you start a scan.`],
     [config.enableLocalNetwork, "NSLocalNetworkUsageDescription", `${config.appName} connects to your own devices on this network.`],
     [config.enableHealthKit, "NSHealthShareUsageDescription", `${config.appName} reads health data you choose to share.`],
@@ -674,8 +679,24 @@ ${plistArray([identifier])}
 function associatedDomainEntries(domains) {
   return [...new Set((domains ?? []).map((value) => value.trim()).filter(Boolean).map((value) => /^[a-z]+:/i.test(value) ? value : `applinks:${value}`))];
 }
+function validateHealthKitBackground(config) {
+  if (!config.enableHealthKitBackground)
+    return;
+  if (!config.enableHealthKit)
+    throw new Error("enableHealthKitBackground requires enableHealthKit");
+  const types = config.healthKitBackgroundTypes;
+  const supported = ["steps", "heartRate", "restingHeartRate", "heartRateVariability", "activeEnergy", "distance", "bodyMass", "sleep", "workouts"];
+  if (!Array.isArray(types) || !types.length || types.some((type) => !supported.includes(type)))
+    throw new Error("healthKitBackgroundTypes must declare supported HealthKit sample types");
+  if (!["immediate", "hourly", "daily", "weekly"].includes(config.healthKitBackgroundFrequency ?? "hourly"))
+    throw new Error("healthKitBackgroundFrequency must be immediate, hourly, daily or weekly");
+}
 function renderEntitlements(config) {
+  validateHealthKitBackground(config);
   const entries = [];
+  if (config.enableHealthKitBackground)
+    entries.push(`    <key>com.apple.developer.healthkit.background-delivery</key>
+    <true/>`);
   const associatedDomains = associatedDomainEntries(config.associatedDomains);
   if (associatedDomains.length) {
     entries.push(`    <key>com.apple.developer.associated-domains</key>
@@ -1145,6 +1166,8 @@ function writeShell(output, config) {
   writeSource(join4(output, "Sources", "CraftNativeScreen.swift"), readFileSync2(join4(TEMPLATES_DIR, "CraftNativeScreen.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftNativeFlatList.swift"), readFileSync2(join4(TEMPLATES_DIR, "CraftNativeFlatList.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftNativeActions.swift"), readFileSync2(join4(TEMPLATES_DIR, "CraftNativeActions.swift"), "utf8"));
+  writeSource(join4(output, "Sources", "CraftNativePedometer.swift"), readFileSync2(join4(TEMPLATES_DIR, "CraftNativePedometer.swift"), "utf8"));
+  writeSource(join4(output, "Sources", "CraftHealthBackground.swift"), readFileSync2(join4(TEMPLATES_DIR, "CraftHealthBackground.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftHealth.swift"), readFileSync2(join4(TEMPLATES_DIR, "CraftHealth.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftMusic.swift"), readFileSync2(join4(TEMPLATES_DIR, "CraftMusic.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftBluetooth.swift"), readFileSync2(join4(TEMPLATES_DIR, "CraftBluetooth.swift"), "utf8"));
@@ -1211,6 +1234,7 @@ async function init(options) {
     teamId: teamId || "",
     ...given
   };
+  validateHealthKitBackground(config);
   if (config.renderer !== "web" && config.renderer !== "native") {
     throw new Error(`Unknown iOS renderer: ${config.renderer}. Expected web or native.`);
   }

package/dist/index.d.ts

@@ -84,12 +84,20 @@ export interface CraftConfig {
     enableAudioRecording?: boolean;
     enableVideoRecording?: boolean;
     enableMotionSensors?: boolean;
+    /** Core Motion relative altitude and pressure; includes the motion usage description. */
+    enableBarometer?: boolean;
+    /** Core Motion interval steps, cadence and seven-day device history. */
+    enablePedometer?: boolean;
     /** Shaking the phone raises a `shake` event. Arms the accelerometer while the app is in front. */
     enableShakeGesture?: boolean;
     enableLocalDatabase?: boolean;
     enableBluetooth?: boolean;
     enableNFC?: boolean;
     enableHealthKit?: boolean;
+    /** Observe declared HealthKit types on background wakes; requires enableHealthKit. */
+    enableHealthKitBackground?: boolean;
+    healthKitBackgroundTypes?: Array<'steps' | 'heartRate' | 'restingHeartRate' | 'heartRateVariability' | 'activeEnergy' | 'distance' | 'bodyMass' | 'sleep' | 'workouts'>;
+    healthKitBackgroundFrequency?: 'immediate' | 'hourly' | 'daily' | 'weekly';
     /** Native Apple Wallet pass presentation and lookup for native screens. */
     enableWallet?: boolean;
     enableLiveActivities?: boolean;
@@ -361,6 +369,8 @@ export declare function hybridConfigProblems(config: Pick<CraftConfig, 'renderer
  * well as the one-file bundle, and the app runs each screen from its own
  * route's file. Stacks asks for route bundles only when this is true.
  */
+/** Build-time proof for Stacks capability mappings, including unreleased source builds. */
+export declare const nativeSensorCapabilities: readonly ['barometer', 'pedometer', 'healthKitBackground'];
 export declare const nativeRouteBundles = true;
 /**
  * The app evaluates stx's shared runtime (`__runtime.js`, stx's

package/dist/index.js

@@ -18,7 +18,7 @@ function iosPermissions(config) {
     contacts: config.enableContacts,
     calendar: config.enableCalendar,
     bluetooth: config.enableBluetooth || config.enableHeartRate,
-    motion: config.enableMotionSensors || config.enableShakeGesture,
+    motion: config.enableMotionSensors || config.enableShakeGesture || config.enableBarometer || config.enablePedometer,
     biometric: config.enableBiometric,
     music: config.enableAppleMusic,
     health: config.enableHealthKit,
@@ -618,6 +618,7 @@ function hybridConfigProblems(config) {
     problems.push(`nativeScriptThread "${String(config.nativeScriptThread)}" must be "main" or "background".`);
   return problems;
 }
+var nativeSensorCapabilities = ["barometer", "pedometer", "healthKitBackground"];
 var nativeRouteBundles = true;
 var nativeRouteRuntime = true;
 var nativeMessages = true;
@@ -701,11 +702,16 @@ var DEFAULT_CONFIG = {
   enableAudioRecording: false,
   enableVideoRecording: false,
   enableMotionSensors: false,
+  enableBarometer: false,
+  enablePedometer: false,
   enableShakeGesture: false,
   enableLocalDatabase: false,
   enableBluetooth: false,
   enableNFC: false,
   enableHealthKit: false,
+  enableHealthKitBackground: false,
+  healthKitBackgroundTypes: [],
+  healthKitBackgroundFrequency: "hourly",
   enableWallet: false,
   enableLiveActivities: false,
   enableWatchApp: false,
@@ -762,7 +768,7 @@ function renderUsageDescriptions(config) {
     [config.enableContacts, "NSContactsUsageDescription", `${config.appName} accesses contacts only when you choose a contact feature.`],
     [config.enableCalendar, "NSCalendarsUsageDescription", `${config.appName} accesses your calendar only when you choose a calendar feature.`],
     [config.enableBluetooth || config.enableHeartRate, "NSBluetoothAlwaysUsageDescription", config.enableHeartRate ? `${config.appName} connects to your heart-rate monitor over Bluetooth to show and record your heart rate during a workout.` : `${config.appName} uses Bluetooth to connect to nearby devices.`],
-    [config.enableMotionSensors, "NSMotionUsageDescription", `${config.appName} uses motion data for activity features.`],
+    [config.enableMotionSensors || config.enableBarometer || config.enablePedometer, "NSMotionUsageDescription", `${config.appName} uses motion data for activity features.`],
     [config.enableNFC, "NFCReaderUsageDescription", `${config.appName} reads NFC tags when you start a scan.`],
     [config.enableLocalNetwork, "NSLocalNetworkUsageDescription", `${config.appName} connects to your own devices on this network.`],
     [config.enableHealthKit, "NSHealthShareUsageDescription", `${config.appName} reads health data you choose to share.`],
@@ -871,8 +877,24 @@ ${plistArray([identifier])}
 function associatedDomainEntries(domains) {
   return [...new Set((domains ?? []).map((value) => value.trim()).filter(Boolean).map((value) => /^[a-z]+:/i.test(value) ? value : `applinks:${value}`))];
 }
+function validateHealthKitBackground(config) {
+  if (!config.enableHealthKitBackground)
+    return;
+  if (!config.enableHealthKit)
+    throw new Error("enableHealthKitBackground requires enableHealthKit");
+  const types = config.healthKitBackgroundTypes;
+  const supported = ["steps", "heartRate", "restingHeartRate", "heartRateVariability", "activeEnergy", "distance", "bodyMass", "sleep", "workouts"];
+  if (!Array.isArray(types) || !types.length || types.some((type) => !supported.includes(type)))
+    throw new Error("healthKitBackgroundTypes must declare supported HealthKit sample types");
+  if (!["immediate", "hourly", "daily", "weekly"].includes(config.healthKitBackgroundFrequency ?? "hourly"))
+    throw new Error("healthKitBackgroundFrequency must be immediate, hourly, daily or weekly");
+}
 function renderEntitlements(config) {
+  validateHealthKitBackground(config);
   const entries = [];
+  if (config.enableHealthKitBackground)
+    entries.push(`    <key>com.apple.developer.healthkit.background-delivery</key>
+    <true/>`);
   const associatedDomains = associatedDomainEntries(config.associatedDomains);
   if (associatedDomains.length) {
     entries.push(`    <key>com.apple.developer.associated-domains</key>
@@ -1358,6 +1380,8 @@ function writeShell(output, config) {
   writeSource(join4(output, "Sources", "CraftNativeScreen.swift"), readFileSync3(join4(TEMPLATES_DIR, "CraftNativeScreen.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftNativeFlatList.swift"), readFileSync3(join4(TEMPLATES_DIR, "CraftNativeFlatList.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftNativeActions.swift"), readFileSync3(join4(TEMPLATES_DIR, "CraftNativeActions.swift"), "utf8"));
+  writeSource(join4(output, "Sources", "CraftNativePedometer.swift"), readFileSync3(join4(TEMPLATES_DIR, "CraftNativePedometer.swift"), "utf8"));
+  writeSource(join4(output, "Sources", "CraftHealthBackground.swift"), readFileSync3(join4(TEMPLATES_DIR, "CraftHealthBackground.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftHealth.swift"), readFileSync3(join4(TEMPLATES_DIR, "CraftHealth.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftMusic.swift"), readFileSync3(join4(TEMPLATES_DIR, "CraftMusic.swift"), "utf8"));
   writeSource(join4(output, "Sources", "CraftBluetooth.swift"), readFileSync3(join4(TEMPLATES_DIR, "CraftBluetooth.swift"), "utf8"));
@@ -1424,6 +1448,7 @@ async function init(options) {
     teamId: teamId || "",
     ...given
   };
+  validateHealthKitBackground(config);
   if (config.renderer !== "web" && config.renderer !== "native") {
     throw new Error(`Unknown iOS renderer: ${config.renderer}. Expected web or native.`);
   }
@@ -1784,6 +1809,7 @@ export {
   nativeMessages,
   nativeRouteBundles,
   nativeRouteRuntime,
+  nativeSensorCapabilities,
   nativeStartPath,
   normalizeNativePath,
   open,

package/package.json

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

package/templates/CraftApp.swift

@@ -299,6 +299,15 @@ final class CraftAppDelegate: NSObject, UIApplicationDelegate, UNUserNotificatio
         // push, a refresh, a route recording's location) draws nothing, and
         // its events still need someone to hear them.
         CraftHybrid.shared.configure(config)
+        CraftHealthBackground.shared.emit = { type in
+            let detail: [String: Any] = ["type": type]
+            CraftEventManager.shared.sendToWeb("craftHealthBackground", data: detail)
+            NotificationCenter.default.post(name: CraftWebServices.event, object: nil,
+                userInfo: ["event": "craftHealthBackground", "detail": detail])
+        }
+        CraftHealthBackground.shared.configure(types: config.enableHealthKit && config.enableHealthKitBackground ? config.healthKitBackgroundTypes : [],
+            frequency: config.healthKitBackgroundFrequency)
+
         if let shortcuts = config.appShortcuts {
             application.shortcutItems = shortcuts.prefix(4).map { shortcut in
                 UIApplicationShortcutItem(type: shortcut.id, localizedTitle: shortcut.title, localizedSubtitle: shortcut.subtitle,
@@ -1830,6 +1839,8 @@ struct CraftConfig: Codable {
     var enableAudioRecording: Bool = false
     var enableVideoRecording: Bool = false
     var enableMotionSensors: Bool = false
+    var enableBarometer: Bool = false
+    var enablePedometer: Bool = false
     /// Shaking the phone raises a `shake` event, for a report-a-problem
     /// gesture. Its own flag rather than a corner of `enableMotionSensors`,
     /// because it arms the accelerometer for as long as the app is in front:
@@ -1839,6 +1850,9 @@ struct CraftConfig: Codable {
     var enableBluetooth: Bool = false
     var enableNFC: Bool = false
     var enableHealthKit: Bool = false
+    var enableHealthKitBackground: Bool = false
+    var healthKitBackgroundTypes: [String] = []
+    var healthKitBackgroundFrequency: String = "hourly"
     /// Apple Wallet pass presentation and lookup for native screens.
     var enableWallet: Bool = false
     var enableLiveActivities: Bool = false

package/templates/CraftHealth.swift

@@ -227,6 +227,7 @@ final class CraftHealth {
         if readOnly { shareTypes.removeAll() }
         healthStore.requestAuthorization(toShare: shareTypes, read: readTypes) { [weak self] success, error in
             if success {
+                DispatchQueue.main.async { CraftHealthBackground.shared.refresh() }
                 completion(.success(true))
             } else {
                 completion(.failure(CraftHealthError(message: error?.localizedDescription ?? "Authorization failed")))
@@ -401,7 +402,7 @@ final class CraftHealth {
 
     /// The quantity behind each health data type, its unit, and the one
     /// statistic that type supports.
-    private static func healthQuantity(_ type: String) -> (type: HKQuantityType?, unit: HKUnit, options: HKStatisticsOptions)? {
+    static func healthQuantity(_ type: String) -> (type: HKQuantityType?, unit: HKUnit, options: HKStatisticsOptions)? {
         let bpm = HKUnit.count().unitDivided(by: .minute())
         switch type {
         case "steps": return (HKQuantityType.quantityType(forIdentifier: .stepCount), .count(), .cumulativeSum)

package/templates/CraftHealthBackground.swift

@@ -0,0 +1,308 @@
+import Foundation
+#if CRAFT_PERMISSION_HEALTH
+import HealthKit
+#endif
+
+struct CraftHealthBackgroundSample: Codable {
+    let id: String
+    let startDate: Double
+    let endDate: Double
+    var value: Double?
+    var unit: String?
+    var category: Int?
+    var workoutActivity: UInt?
+    var durationSeconds: Double?
+}
+
+struct CraftHealthBackgroundPage {
+    let anchor: Data
+    let samples: [CraftHealthBackgroundSample]
+    let deleted: [String]
+    let more: Bool
+}
+
+struct CraftHealthBackgroundBatch: Codable {
+    let id: String
+    let type: String
+    let samples: [CraftHealthBackgroundSample]
+    let deleted: [String]
+}
+
+struct CraftHealthBackgroundState: Codable {
+    var anchors: [String: Data] = [:]
+    var observedTypes: [String]? = nil
+    var batches: [CraftHealthBackgroundBatch] = []
+}
+
+/// An atomic snapshot keeps a new anchor inseparable from its unconsumed delta.
+protocol CraftHealthBackgroundPersistence {
+    func load() throws -> CraftHealthBackgroundState
+    func save(_ state: CraftHealthBackgroundState) throws
+}
+
+final class CraftHealthBackgroundFile: CraftHealthBackgroundPersistence {
+    private let url: URL
+    init(url: URL) { self.url = url }
+    func load() throws -> CraftHealthBackgroundState {
+        guard FileManager.default.fileExists(atPath: url.path) else { return CraftHealthBackgroundState() }
+        return try JSONDecoder().decode(CraftHealthBackgroundState.self, from: Data(contentsOf: url))
+    }
+    func save(_ state: CraftHealthBackgroundState) throws {
+        let data = try JSONEncoder().encode(state)
+        guard data.count <= 8 * 1024 * 1024 else { throw CraftHealthBackgroundError.outboxFull }
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true,
+            attributes: [.protectionKey: FileProtectionType.completeUntilFirstUserAuthentication])
+        try data.write(to: url, options: [.atomic, .completeFileProtectionUntilFirstUserAuthentication])
+        var excluded = url
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = true
+        try excluded.setResourceValues(values)
+    }
+}
+
+enum CraftHealthBackgroundError: Error { case unavailable, outboxFull, invalidAnchor, missingAnchor }
+
+/// All callbacks and ownership transitions are serialized on the main queue.
+protocol CraftHealthBackgroundSource {
+    func observe(type: String, update: @escaping (Error?, @escaping () -> Void) -> Void) -> () -> Void
+    func enable(type: String, frequency: String, completion: @escaping (Error?) -> Void)
+    func disable(type: String)
+    func read(type: String, anchor: Data?, completion: @escaping (Result<CraftHealthBackgroundPage, Error>) -> Void) -> () -> Void
+}
+
+final class CraftHealthBackground {
+    static let shared: CraftHealthBackground = {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first!
+        #if CRAFT_PERMISSION_HEALTH
+        let source: CraftHealthBackgroundSource = CraftHealthKitBackgroundSource()
+        #else
+        let source: CraftHealthBackgroundSource = CraftUnavailableHealthBackgroundSource()
+        #endif
+        return CraftHealthBackground(source: source, persistence: CraftHealthBackgroundFile(url: base.appendingPathComponent("craft-health/delivery.json")))
+    }()
+
+    private final class Read {
+        var completions: [() -> Void] = []
+        var cancel: (() -> Void)?
+        var deadline: DispatchWorkItem?
+        var dirty = false
+    }
+    private let readTimeout: TimeInterval
+    private let source: CraftHealthBackgroundSource
+    private let persistence: CraftHealthBackgroundPersistence
+    private var state = CraftHealthBackgroundState()
+    private var loaded = false
+    private var observers: [String: () -> Void] = [:]
+    private var reads: [String: Read] = [:]
+    private var types: [String] = []
+    private var frequency = "hourly"
+    private var generation = UUID()
+    private(set) var errors: [String: String] = [:]
+    var emit: (String) -> Void = { _ in }
+
+    init(source: CraftHealthBackgroundSource, persistence: CraftHealthBackgroundPersistence, readTimeout: TimeInterval = 20) {
+        self.source = source
+        self.persistence = persistence
+        self.readTimeout = readTimeout
+    }
+
+    func configure(types: [String], frequency: String) {
+        stop()
+        self.types = Array(Set(types)).sorted()
+        self.frequency = frequency
+        refresh()
+    }
+
+    func refresh() {
+        if !loaded {
+            do { state = try persistence.load(); loaded = true }
+            catch { errors["storage"] = "Health delivery state could not be read"; return }
+        }
+        errors.removeValue(forKey: "storage")
+        let current = generation
+        let observed = Set(state.observedTypes ?? []).union(state.anchors.keys).union(types)
+        if Set(state.observedTypes ?? []) != observed {
+            do {
+                var next = state
+                next.observedTypes = observed.sorted()
+                try persistence.save(next)
+                state = next
+            } catch { errors["storage"] = "Health registration intent could not be persisted"; return }
+        }
+        // Keep retired declarations so a temporarily unavailable store can
+        // retry disabling them on a later launch, even before its first delta.
+        for old in observed where !types.contains(old) { source.disable(type: old) }
+        for type in types {
+            if observers[type] == nil {
+                observers[type] = source.observe(type: type) { [weak self] error, acknowledge in
+                    guard let self, self.generation == current else { acknowledge(); return }
+                    if error != nil { self.errors[type] = "HealthKit observer failed"; acknowledge(); return }
+                    self.changed(type, acknowledge: acknowledge)
+                }
+            }
+            source.enable(type: type, frequency: frequency) { [weak self] error in
+                guard let self, self.generation == current else { return }
+                if error != nil { self.errors["\(type).registration"] = "Background delivery registration failed" }
+                else { self.errors.removeValue(forKey: "\(type).registration"); self.changed(type, acknowledge: {}) }
+            }
+        }
+    }
+
+    private func changed(_ type: String, acknowledge: @escaping () -> Void) {
+        if let read = reads[type] { read.completions.append(acknowledge); read.dirty = true; return }
+        let read = Read()
+        read.completions.append(acknowledge)
+        reads[type] = read
+        // Never strand HealthKit's completion waiting for an unavailable store,
+        // a locked device, an unresponsive query or JavaScript consumption.
+        let deadline = DispatchWorkItem { [weak self, weak read] in
+            guard let self, let read, self.reads[type] === read else { return }
+            self.errors[type] = "HealthKit read timed out; anchor retained for retry"
+            self.finish(type, read)
+        }
+        read.deadline = deadline
+        DispatchQueue.main.asyncAfter(deadline: .now() + readTimeout, execute: deadline)
+        next(type, read)
+    }
+
+    private func next(_ type: String, _ read: Read) {
+        read.dirty = false
+        read.cancel = source.read(type: type, anchor: state.anchors[type]) { [weak self, weak read] answer in
+            guard let self, let read, self.reads[type] === read else { return }
+            read.cancel = nil
+            switch answer {
+            case .failure:
+                self.errors[type] = "HealthKit read failed; anchor retained for retry"
+                self.finish(type, read)
+            case .success(let page):
+                do {
+                    var next = self.state
+                    if !page.samples.isEmpty || !page.deleted.isEmpty {
+                        next.batches.append(CraftHealthBackgroundBatch(id: UUID().uuidString, type: type, samples: page.samples, deleted: page.deleted))
+                    }
+                    next.anchors[type] = page.anchor
+                    try self.persistence.save(next)
+                    self.state = next
+                    self.errors.removeValue(forKey: type)
+                    if !page.samples.isEmpty || !page.deleted.isEmpty { self.emit(type) }
+                    if page.more || read.dirty { self.next(type, read) }
+                    else { self.finish(type, read) }
+                } catch {
+                    self.errors[type] = "Health delivery could not be persisted; anchor retained for retry"
+                    self.finish(type, read)
+                }
+            }
+        }
+    }
+
+    private func finish(_ type: String, _ read: Read) {
+        guard reads[type] === read else { return }
+        reads.removeValue(forKey: type)
+        read.deadline?.cancel()
+        read.cancel?()
+        let completions = read.completions
+        read.completions.removeAll()
+        completions.forEach { $0() }
+    }
+
+    func stop() {
+        generation = UUID()
+        observers.values.forEach { $0() }
+        observers.removeAll()
+        for (type, read) in reads { finish(type, read) }
+    }
+
+    func perform(method: String, args: [Any], completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        if !loaded { refresh() }
+        guard loaded else { completion(.failure(CraftNativeActionError(code: "STORAGE_ERROR", message: "Health delivery state is unavailable"))); return }
+        do {
+            switch method {
+            case "status": completion(.success(["types": types, "frequency": frequency, "pendingBatches": state.batches.count, "errors": errors]))
+            case "refresh": refresh(); completion(.success(true))
+            case "pending":
+                let data = try JSONEncoder().encode(Array(state.batches.prefix(20)))
+                completion(.success(try JSONSerialization.jsonObject(with: data)))
+            case "acknowledge":
+                guard let ids = args.first as? [String], ids.count <= 20 else {
+                    completion(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "acknowledge needs up to 20 batch ids"))); return
+                }
+                var next = state
+                let acknowledged = Set(ids)
+                next.batches.removeAll { acknowledged.contains($0.id) }
+                try persistence.save(next)
+                state = next
+                refresh()
+                completion(.success(true))
+            default: completion(.failure(CraftNativeActionError(code: "UNKNOWN_ACTION", message: "Unknown HealthBackground action")))
+            }
+        } catch { completion(.failure(CraftNativeActionError(code: "STORAGE_ERROR", message: "Health delivery state could not be saved"))) }
+    }
+}
+
+private final class CraftUnavailableHealthBackgroundSource: CraftHealthBackgroundSource {
+    func disable(type: String) {}
+    func observe(type: String, update: @escaping (Error?, @escaping () -> Void) -> Void) -> () -> Void { {} }
+    func enable(type: String, frequency: String, completion: @escaping (Error?) -> Void) { completion(CraftHealthBackgroundError.unavailable) }
+    func read(type: String, anchor: Data?, completion: @escaping (Result<CraftHealthBackgroundPage, Error>) -> Void) -> () -> Void { completion(.failure(CraftHealthBackgroundError.unavailable)); return {} }
+}
+
+#if CRAFT_PERMISSION_HEALTH
+private final class CraftHealthKitBackgroundSource: CraftHealthBackgroundSource {
+    private var store: HKHealthStore? { CraftHealth.shared.healthStore }
+    private func sampleType(_ name: String) -> HKSampleType? {
+        if name == "sleep" { return HKCategoryType.categoryType(forIdentifier: .sleepAnalysis) }
+        if name == "workouts" { return HKObjectType.workoutType() }
+        return CraftHealth.healthQuantity(name)?.type
+    }
+    func disable(type: String) {
+        guard let store, let sample = sampleType(type) else { return }
+        store.disableBackgroundDelivery(for: sample) { _, _ in }
+    }
+    func observe(type: String, update: @escaping (Error?, @escaping () -> Void) -> Void) -> () -> Void {
+        guard let store, let sample = sampleType(type) else { return {} }
+        let query = HKObserverQuery(sampleType: sample, predicate: nil) { _, completion, error in
+            DispatchQueue.main.async { update(error, completion) }
+        }
+        store.execute(query)
+        return { store.stop(query) }
+    }
+    func enable(type: String, frequency: String, completion: @escaping (Error?) -> Void) {
+        guard let store, let sample = sampleType(type) else { completion(CraftHealthBackgroundError.unavailable); return }
+        let value: HKUpdateFrequency = ["immediate": .immediate, "hourly": .hourly, "daily": .daily, "weekly": .weekly][frequency] ?? .hourly
+        store.enableBackgroundDelivery(for: sample, frequency: value) { success, error in
+            DispatchQueue.main.async { completion(success ? nil : error ?? CraftHealthBackgroundError.unavailable) }
+        }
+    }
+    func read(type: String, anchor: Data?, completion: @escaping (Result<CraftHealthBackgroundPage, Error>) -> Void) -> () -> Void {
+        guard let store, let sample = sampleType(type) else { completion(.failure(CraftHealthBackgroundError.unavailable)); return {} }
+        let saved: HKQueryAnchor?
+        do {
+            saved = try anchor.map { data in
+                guard let value = try NSKeyedUnarchiver.unarchivedObject(ofClass: HKQueryAnchor.self, from: data) else { throw CraftHealthBackgroundError.invalidAnchor }
+                return value
+            }
+        } catch { completion(.failure(error)); return {} }
+        let query = HKAnchoredObjectQuery(type: sample, predicate: nil, anchor: saved, limit: 250) { _, samples, deleted, anchor, error in
+            let answer: Result<CraftHealthBackgroundPage, Error>
+            do {
+                if let error { throw error }
+                guard let anchor else { throw CraftHealthBackgroundError.missingAnchor }
+                let data = try NSKeyedArchiver.archivedData(withRootObject: anchor, requiringSecureCoding: true)
+                let records = (samples ?? []).map { sample -> CraftHealthBackgroundSample in
+                    var record = CraftHealthBackgroundSample(id: sample.uuid.uuidString, startDate: sample.startDate.timeIntervalSince1970 * 1000, endDate: sample.endDate.timeIntervalSince1970 * 1000)
+                    if let quantity = sample as? HKQuantitySample, let spec = CraftHealth.healthQuantity(type) {
+                        record.value = quantity.quantity.doubleValue(for: spec.unit)
+                        record.unit = spec.unit.unitString
+                    } else if let category = sample as? HKCategorySample { record.category = category.value }
+                    else if let workout = sample as? HKWorkout { record.workoutActivity = workout.workoutActivityType.rawValue; record.durationSeconds = workout.duration }
+                    return record
+                }
+                answer = .success(CraftHealthBackgroundPage(anchor: data, samples: records, deleted: (deleted ?? []).map { $0.uuid.uuidString }, more: records.count + (deleted?.count ?? 0) >= 250))
+            } catch { answer = .failure(error) }
+            DispatchQueue.main.async { completion(answer) }
+        }
+        store.execute(query)
+        return { store.stop(query) }
+    }
+}
+#endif

package/templates/CraftNativeActions.swift

@@ -1,4 +1,7 @@
 import Foundation
+#if CRAFT_PERMISSION_MOTION
+import CoreMotion
+#endif
 import AuthenticationServices
 #if CRAFT_PERMISSION_BIOMETRIC
 import LocalAuthentication
@@ -60,6 +63,9 @@ enum CraftNativeActions {
         if config.enableDeepLinks { values.append("deepLinks") }
         if config.enableLocalNotifications { values.append("notifications") }
         if config.enableHealthKit { values.append("health") }
+        if config.enableHealthKit && config.enableHealthKitBackground { values.append("healthBackground") }
+        if config.enableBarometer { values.append("barometer") }
+        if config.enablePedometer { values.append("pedometer") }
         if config.enableWallet { values.append("wallet") }
         if config.enableLiveActivities { values.append("liveActivities") }
         // The in-app browser and the system's web sign-in sheet (CraftBrowser).
@@ -405,6 +411,17 @@ enum CraftNativeActions {
                 complete(requestToken, result, completion)
             }
             return
+        case ("HealthBackground", _):
+            guard config.enableHealthKit && config.enableHealthKitBackground else {
+                complete(requestToken, failure("CAPABILITY_DISABLED", "HealthKit background delivery is disabled"), completion)
+                return
+            }
+            DispatchQueue.main.async {
+                CraftHealthBackground.shared.perform(method: method, args: args) { result in
+                    complete(requestToken, result, completion)
+                }
+            }
+            return
         case ("Health", _):
             // Apple Health, the same as a page's `craft.health` (CraftHealth.swift).
             guard config.enableHealthKit else {
@@ -1999,3 +2016,139 @@ enum CraftHaptics {
         return generator
     }
 }
+
+// MARK: - Route-owned barometer
+
+struct CraftBarometerSample {
+    let pressureHpa: Double
+    let relativeAltitudeMeters: Double
+    let timestampMs: Double
+}
+
+protocol CraftBarometerSource: AnyObject {
+    var available: Bool { get }
+    var denied: Bool { get }
+    func start(_ receive: @escaping (Result<CraftBarometerSample, Error>) -> Void) throws
+    func stop()
+}
+
+#if CRAFT_PERMISSION_MOTION
+private final class CraftCoreMotionBarometer: CraftBarometerSource {
+    private let altimeter = CMAltimeter()
+    var available: Bool { CMAltimeter.isRelativeAltitudeAvailable() }
+    var denied: Bool { [.denied, .restricted].contains(CMAltimeter.authorizationStatus()) }
+    func start(_ receive: @escaping (Result<CraftBarometerSample, Error>) -> Void) throws {
+        altimeter.startRelativeAltitudeUpdates(to: .main) { data, error in
+            if let error { receive(.failure(error)); return }
+            guard let data else { return }
+            receive(.success(CraftBarometerSample(pressureHpa: data.pressure.doubleValue * 10,
+                relativeAltitudeMeters: data.relativeAltitude.doubleValue, timestampMs: data.timestamp * 1000)))
+        }
+    }
+    func stop() { altimeter.stopRelativeAltitudeUpdates() }
+}
+#endif
+
+private final class CraftUnavailableBarometer: CraftBarometerSource {
+    var available: Bool { false }
+    var denied: Bool { false }
+    func start(_ receive: @escaping (Result<CraftBarometerSample, Error>) -> Void) throws {}
+    func stop() {}
+}
+
+final class CraftNativeBarometer {
+    private final class Stream {
+        let source: CraftBarometerSource
+        var lastTimestamp: Double?
+        init(_ source: CraftBarometerSource) { self.source = source }
+    }
+    private let makeSource: () -> CraftBarometerSource
+    private var stream: Stream?
+    private var closed = false
+    var emit: ([String: Any]) -> Void = { _ in }
+
+    init(makeSource: (() -> CraftBarometerSource)? = nil) {
+        self.makeSource = makeSource ?? {
+            #if CRAFT_PERMISSION_MOTION
+            return CraftCoreMotionBarometer()
+            #else
+            return CraftUnavailableBarometer()
+            #endif
+        }
+    }
+
+    func perform(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
+        guard !closed else { return failure("HOST_CLOSED", "Barometer host is closed") }
+        switch method {
+        case "getAvailability":
+            let source = makeSource()
+            return .success(["relativeAltitude": source.available, "absoluteAltitude": false,
+                "background": false, "permissionDenied": source.denied])
+        case "start": return start(args)
+        case "stop": return .success(stop(reason: "requested"))
+        default: return failure("UNKNOWN_ACTION", "Unsupported Barometer method")
+        }
+    }
+
+    private func start(_ args: [Any]) -> Result<Any, CraftNativeActionError> {
+        guard args.isEmpty || args.first is [String: Any] else { return failure("INVALID_ARGUMENT", "Barometer.start needs an options object") }
+        let options = args.first as? [String: Any] ?? [:]
+        if let background = options["background"] {
+            guard let flag = background as? NSNumber, CFGetTypeID(flag) == CFBooleanGetTypeID() else {
+                return failure("INVALID_ARGUMENT", "background must be boolean")
+            }
+            if flag.boolValue { return failure("UNSUPPORTED", "Background barometer recording is not supported") }
+        }
+        let value = options["intervalMs"] ?? 100
+        guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID(),
+              number.doubleValue.isFinite, number.doubleValue >= 5, number.doubleValue <= 60000,
+              number.doubleValue.rounded() == number.doubleValue else {
+            return failure("INVALID_ARGUMENT", "intervalMs must be an integer from 5 through 60000")
+        }
+        let source = makeSource()
+        guard source.available else { return failure("UNAVAILABLE", "Barometer is not present") }
+        guard !source.denied else { return failure("PERMISSION_DENIED", "Motion access was denied or restricted") }
+        let next = Stream(source)
+        do {
+            try source.start { [weak self, weak next] result in
+                guard let self, let next, !self.closed, self.stream === next else { return }
+                switch result {
+                case .failure:
+                    self.stop(reason: next.source.denied ? "permissionDenied" : "sensorError")
+                case .success(let sample):
+                    guard sample.pressureHpa.isFinite, sample.pressureHpa > 0,
+                          sample.relativeAltitudeMeters.isFinite, sample.timestampMs.isFinite else {
+                        self.stop(reason: "sensorError")
+                        return
+                    }
+                    // Core Motion chooses its own cadence. A requested slower
+                    // output rate never invents or interpolates sensor readings.
+                    if let last = next.lastTimestamp, sample.timestampMs - last < number.doubleValue { return }
+                    next.lastTimestamp = sample.timestampMs
+                    self.emit(["state": "sample", "pressureHpa": sample.pressureHpa,
+                        "relativeAltitudeMeters": sample.relativeAltitudeMeters, "timestampMs": sample.timestampMs])
+                }
+            }
+        } catch {
+            source.stop()
+            return failure("SENSOR_ERROR", error.localizedDescription)
+        }
+        let previous = stream
+        stream = next
+        previous?.source.stop()
+        return .success(true)
+    }
+
+    @discardableResult func stop(reason: String) -> Bool {
+        guard let previous = stream else { return false }
+        stream = nil
+        previous.source.stop()
+        emit(["state": "stopped", "reason": reason])
+        return true
+    }
+    func close() { closed = true; stop(reason: "disposed"); emit = { _ in } }
+    deinit { stream?.source.stop() }
+    private func failure(_ code: String, _ message: String) -> Result<Any, CraftNativeActionError> {
+        .failure(CraftNativeActionError(code: code, message: message))
+    }
+}

package/templates/CraftNativeMutation.swift

@@ -18,10 +18,22 @@ struct CraftNativeMutationFailure: Error, Equatable {
 struct CraftNativeMutationResult {
     let batchId: String
     let revision: Int
-    let document: [String: Any]?
     let updatedNodeIds: [String]
     let affectedNodeIds: [String]
     let requiresFullRender: Bool
+    private let materialize: () -> [String: Any]?
+    /// The committed tree, built when asked for: a host that redraws only the
+    /// nodes a batch touched never needs the whole tree.
+    var document: [String: Any]? { materialize() }
+
+    init(batchId: String, revision: Int, document: @escaping () -> [String: Any]?, updatedNodeIds: [String], affectedNodeIds: [String], requiresFullRender: Bool) {
+        self.batchId = batchId
+        self.revision = revision
+        self.materialize = document
+        self.updatedNodeIds = updatedNodeIds
+        self.affectedNodeIds = affectedNodeIds
+        self.requiresFullRender = requiresFullRender
+    }
 }
 
 /// Validates and applies versioned native-tree mutations without touching UIKit.
@@ -91,6 +103,8 @@ final class CraftNativeMutationDocument {
         var updatedNodeIds: [String] = []
         var affectedNodeIds: [String] = []
         var requiresFullRender = false
+        // Only an operation that adds, moves or removes nodes can leave one unreachable.
+        var reshaped = false
         for (index, value) in operations.enumerated() {
             guard let operation = value as? [String: Any], let name = operation["op"] as? String else {
                 throw CraftNativeMutationFailure(
@@ -99,6 +113,7 @@ final class CraftNativeMutationDocument {
                     operationIndex: index
                 )
             }
+            if name != "updateNode" { reshaped = true }
             do {
                 switch name {
                 case "createNode":
@@ -147,7 +162,7 @@ final class CraftNativeMutationDocument {
             guard let root = candidateNodes[candidateRoot], root.parent == nil else {
                 throw CraftNativeMutationFailure("INVALID_TREE", "root node must not have a parent")
             }
-            guard descendants(of: candidateRoot, nodes: candidateNodes).count + 1 == candidateNodes.count else {
+            guard !reshaped || descendants(of: candidateRoot, nodes: candidateNodes).count + 1 == candidateNodes.count else {
                 throw CraftNativeMutationFailure("INVALID_TREE", "all nodes must be reachable from the root")
             }
         }
@@ -158,7 +173,7 @@ final class CraftNativeMutationDocument {
         return CraftNativeMutationResult(
             batchId: batchId,
             revision: nextRevision,
-            document: candidateRoot.flatMap { materialize($0, nodes: candidateNodes) },
+            document: { [candidateRoot, candidateNodes, weak self] in candidateRoot.flatMap { self?.materialize($0, nodes: candidateNodes) } },
             updatedNodeIds: updatedNodeIds,
             affectedNodeIds: affectedNodeIds,
             requiresFullRender: requiresFullRender

package/templates/CraftNativePedometer.swift

@@ -0,0 +1,181 @@
+import Foundation
+#if CRAFT_PERMISSION_MOTION
+import CoreMotion
+#endif
+
+struct CraftPedometerSample {
+    let startDate: Double
+    let endDate: Double
+    let steps: Int
+    var distanceMeters: Double?
+    var cadenceStepsPerSecond: Double?
+    var paceSecondsPerMeter: Double?
+    var averageActivePaceSecondsPerMeter: Double?
+    var floorsAscended: Int?
+    var floorsDescended: Int?
+
+    var payload: [String: Any] {
+        var value: [String: Any] = ["state": "sample", "kind": "interval", "startDate": startDate, "endDate": endDate, "steps": steps]
+        if let distanceMeters { value["distanceMeters"] = distanceMeters }
+        if let cadenceStepsPerSecond { value["cadenceStepsPerSecond"] = cadenceStepsPerSecond }
+        if let paceSecondsPerMeter { value["paceSecondsPerMeter"] = paceSecondsPerMeter }
+        if let averageActivePaceSecondsPerMeter { value["averageActivePaceSecondsPerMeter"] = averageActivePaceSecondsPerMeter }
+        if let floorsAscended { value["floorsAscended"] = floorsAscended }
+        if let floorsDescended { value["floorsDescended"] = floorsDescended }
+        return value
+    }
+}
+
+protocol CraftPedometerSource: AnyObject {
+    var availability: [String: Bool] { get }
+    var permission: String { get }
+    func start(from: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void)
+    func query(from: Date, to: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void)
+    func stop()
+}
+
+#if CRAFT_PERMISSION_MOTION
+private final class CraftCoreMotionPedometer: CraftPedometerSource {
+    private let pedometer = CMPedometer()
+    var availability: [String: Bool] {
+        ["steps": CMPedometer.isStepCountingAvailable(), "distance": CMPedometer.isDistanceAvailable(),
+         "floors": CMPedometer.isFloorCountingAvailable(), "cadence": CMPedometer.isCadenceAvailable(),
+         "pace": CMPedometer.isPaceAvailable(), "history": CMPedometer.isStepCountingAvailable(), "background": false]
+    }
+    var permission: String {
+        switch CMPedometer.authorizationStatus() {
+        case .authorized: return "granted"
+        case .denied: return "denied"
+        case .restricted: return "restricted"
+        case .notDetermined: return "notDetermined"
+        @unknown default: return "unavailable"
+        }
+    }
+    private func handler(_ receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) -> CMPedometerHandler {
+        { data, error in
+            let result: Result<CraftPedometerSample, Error>
+            if let error { result = .failure(error) }
+            else if let data {
+                result = .success(CraftPedometerSample(startDate: data.startDate.timeIntervalSince1970 * 1000,
+                    endDate: data.endDate.timeIntervalSince1970 * 1000, steps: data.numberOfSteps.intValue,
+                    distanceMeters: data.distance?.doubleValue, cadenceStepsPerSecond: data.currentCadence?.doubleValue,
+                    paceSecondsPerMeter: data.currentPace?.doubleValue, averageActivePaceSecondsPerMeter: data.averageActivePace?.doubleValue,
+                    floorsAscended: data.floorsAscended?.intValue, floorsDescended: data.floorsDescended?.intValue))
+            } else { result = .failure(NSError(domain: "CraftPedometer", code: 1, userInfo: [NSLocalizedDescriptionKey: "Pedometer returned no data"])) }
+            DispatchQueue.main.async { receive(result) }
+        }
+    }
+    func start(from: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) {
+        pedometer.startUpdates(from: from, withHandler: handler(receive))
+    }
+    func query(from: Date, to: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) {
+        pedometer.queryPedometerData(from: from, to: to, withHandler: handler(receive))
+    }
+    func stop() { pedometer.stopUpdates() }
+}
+#endif
+
+private final class CraftUnavailablePedometer: CraftPedometerSource {
+    var availability: [String: Bool] { ["steps": false, "distance": false, "floors": false, "cadence": false, "pace": false, "history": false, "background": false] }
+    var permission: String { "unavailable" }
+    func start(from: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) {}
+    func query(from: Date, to: Date, receive: @escaping (Result<CraftPedometerSample, Error>) -> Void) {}
+    func stop() {}
+}
+
+/// Interval counts are never relabelled as Android's counter since boot.
+final class CraftNativePedometer {
+    typealias Completion = (Result<Any, CraftNativeActionError>) -> Void
+    private let makeSource: () -> CraftPedometerSource
+    private let now: () -> Date
+    private var live: CraftPedometerSource?
+    private var pending = [String: CraftPedometerSource]()
+    private var closed = false
+    var emit: ([String: Any]) -> Void = { _ in }
+
+    init(makeSource: (() -> CraftPedometerSource)? = nil, now: @escaping () -> Date = Date.init) {
+        self.now = now
+        self.makeSource = makeSource ?? {
+            #if CRAFT_PERMISSION_MOTION
+            return CraftCoreMotionPedometer()
+            #else
+            return CraftUnavailablePedometer()
+            #endif
+        }
+    }
+
+    func perform(method: String, args: [Any], token: String, completion: @escaping Completion) {
+        guard !closed else { return completion(failure("HOST_CLOSED", "Pedometer host is closed")) }
+        if method == "stop" { completion(.success(stop(reason: "requested"))); return }
+        let source = makeSource()
+        if method == "getAvailability" { completion(.success(source.availability)); return }
+        if method == "getPermissionStatus" { completion(.success(source.permission)); return }
+        guard ["start", "query", "requestPermission"].contains(method) else { return completion(failure("UNKNOWN_ACTION", "Unsupported Pedometer method")) }
+        guard source.availability["steps"] == true else { return completion(failure("UNAVAILABLE", "Step counting is not present")) }
+        if method == "requestPermission", ["granted", "denied", "restricted"].contains(source.permission) {
+            completion(.success(source.permission)); return
+        }
+        guard !["denied", "restricted"].contains(source.permission) else { return completion(failure("PERMISSION_DENIED", "Motion access was denied or restricted")) }
+        guard args.isEmpty || args.first is [String: Any] else { return completion(failure("INVALID_ARGUMENT", "Pedometer options must be an object")) }
+        let options = args.first as? [String: Any] ?? [:]
+        if let background = options["background"] {
+            guard let flag = background as? NSNumber, CFGetTypeID(flag) == CFBooleanGetTypeID() else { return completion(failure("INVALID_ARGUMENT", "background must be boolean")) }
+            if flag.boolValue { return completion(failure("UNSUPPORTED", "Background pedometer streaming is not supported")) }
+        }
+        let current = now().timeIntervalSince1970 * 1000
+        let first: Double, last: Double
+        if method == "requestPermission" { first = current - 1000; last = current }
+        else {
+            guard let start = date(options["startDate"] ?? (method == "start" ? current : NSNull())),
+                  let end = date(options["endDate"] ?? current), start >= current - 7 * 86400 * 1000,
+                  start <= current, end <= current, (method == "start" ? start <= end : start < end) else {
+                return completion(failure("INVALID_ARGUMENT", "Dates must describe an interval within the last seven days"))
+            }
+            first = start; last = end
+        }
+        if method == "start" {
+            let previous = live
+            live = source
+            source.start(from: Date(timeIntervalSince1970: first / 1000)) { [weak self, weak source] result in
+                guard let self, let source, !self.closed, self.live === source else { return }
+                switch result {
+                case .success(let sample): self.emit(sample.payload)
+                case .failure: self.stop(reason: ["denied", "restricted"].contains(source.permission) ? "permissionDenied" : "sensorError")
+                }
+            }
+            previous?.stop()
+            completion(.success(true))
+        } else {
+            pending[token] = source
+            source.query(from: Date(timeIntervalSince1970: first / 1000), to: Date(timeIntervalSince1970: last / 1000)) { [weak self, weak source] result in
+                guard let self, let source, !self.closed, self.pending[token] === source else { return }
+                self.pending.removeValue(forKey: token)
+                if method == "requestPermission", ["granted", "denied", "restricted"].contains(source.permission) {
+                    completion(.success(source.permission)); return
+                }
+                switch result {
+                case .success(let sample): completion(.success(method == "requestPermission" ? source.permission as Any : sample.payload))
+                case .failure(let error): completion(self.failure(["denied", "restricted"].contains(source.permission) ? "PERMISSION_DENIED" : "SENSOR_ERROR", error.localizedDescription))
+                }
+            }
+        }
+    }
+
+    private func date(_ value: Any) -> Double? {
+        guard let value = value as? NSNumber, CFGetTypeID(value) != CFBooleanGetTypeID(), value.doubleValue.isFinite else { return nil }
+        return value.doubleValue
+    }
+    func cancel(_ token: String) { pending.removeValue(forKey: token) }
+    @discardableResult func stop(reason: String) -> Bool {
+        guard let previous = live else { return false }
+        live = nil
+        previous.stop()
+        emit(["state": "stopped", "reason": reason])
+        return true
+    }
+    func close() { closed = true; pending.removeAll(); stop(reason: "disposed"); emit = { _ in } }
+    deinit { live?.stop() }
+    private func failure(_ code: String, _ message: String) -> Result<Any, CraftNativeActionError> {
+        .failure(CraftNativeActionError(code: code, message: message))
+    }
+}

package/templates/CraftNativeScreen.swift

@@ -6191,6 +6191,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var inputIdentities: [ObjectIdentifier: String] = [:]
     private var inputDrafts: [String: String] = [:]
     private var longPressHandlers: [ObjectIdentifier: String] = [:]
+    private var accessibilityActionHandlers: [ObjectIdentifier: String] = [:]
     private var textMaxLengths: [ObjectIdentifier: Int] = [:]
     private var scrollHandlers: [ObjectIdentifier: String] = [:]
     private var scrollBeginHandlers: [ObjectIdentifier: String] = [:]
@@ -6259,6 +6260,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private let audio = CraftWebAudio()
     /// `craft.audio`'s sounds and the streaming responses this screen reads.
     private let sounds = CraftNativeSounds()
+    private let barometer = CraftNativeBarometer()
+    private let pedometer = CraftNativePedometer()
     private let streams = CraftNativeEventStreams()
     /// A request a screen-owned module answers, by request token, and how to
     /// call it off when it times out or is cancelled.
@@ -6595,6 +6598,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         audio.close()
         sounds.close()
+        barometer.close()
+        pedometer.close()
         streams.close()
         screenRequestCancellers.values.forEach { $0() }
         screenRequestCancellers.removeAll()
@@ -8037,6 +8042,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             guard let name = notification.userInfo?["event"] as? String else { return }
             self?.send(type: "CRAFT_EVENT", payload: ["event": name, "detail": notification.userInfo?["detail"] ?? [:]])
         })
+        pedometer.emit = { [weak self] detail in self?.send(type: "CRAFT_EVENT", payload: ["event": "craftPedometerUpdate", "detail": detail]) }
+        barometer.emit = { [weak self] detail in self?.send(type: "CRAFT_EVENT", payload: ["event": "craftBarometerUpdate", "detail": detail]) }
         sounds.emit = { [weak self] payload in self?.send(type: "SOUND_EVENT", payload: payload) }
         streams.emit = { [weak self] payload in self?.send(type: "NETWORK_STREAM", payload: payload) }
         sendAppState(CraftNativeActions.currentAppState())
@@ -8201,6 +8208,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func sendAppState(_ state: String) {
+        if state != "active" { barometer.stop(reason: "background"); pedometer.stop(reason: "background") }
         // A screen hears it while it is on top of its stack; the app script,
         // which is on no stack, always.
         guard isAppScript || navigationController?.topViewController === self else { return }
@@ -8412,6 +8420,29 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         let id = args.first as? String ?? ""
         switch (module, method) {
+        case ("Pedometer", _):
+            if !config.enablePedometer {
+                reply(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Pedometer is disabled")))
+            } else if isAppScript {
+                reply(.failure(CraftNativeActionError(code: "NEEDS_ACTIVITY", message: "Pedometer needs a visible app")))
+            } else if ["start", "requestPermission"].contains(method) && UIApplication.shared.applicationState != .active {
+                reply(.failure(CraftNativeActionError(code: "APP_INACTIVE", message: "Pedometer needs a foreground app")))
+            } else {
+                screenRequestCancellers[requestToken] = { [weak self] in self?.pedometer.cancel(requestToken) }
+                pedometer.perform(method: method, args: args, token: requestToken, completion: reply)
+            }
+            return true
+        case ("Barometer", _):
+            if !config.enableBarometer {
+                reply(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Barometer is disabled")))
+            } else if isAppScript {
+                reply(.failure(CraftNativeActionError(code: "NEEDS_ACTIVITY", message: "Barometer needs a visible app")))
+            } else if method == "start" && UIApplication.shared.applicationState != .active {
+                reply(.failure(CraftNativeActionError(code: "APP_INACTIVE", message: "Barometer needs a foreground app")))
+            } else {
+                reply(barometer.perform(method: method, args: args))
+            }
+            return true
         case ("AudioRecording", _):
             guard config.enableAudioRecording else {
                 reply(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Audio recording is disabled")))
@@ -9400,6 +9431,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         result.craftPointerEvents = CraftNativePointerEvents.resolve(props: props, style: style)
         applyAccessibility(props, type: type, to: result)
+        // After applyAccessibility: it settles whether the view is an element
+        // at all, and an action on a non-element is unreachable.
+        updateAccessibilityActions(props["accessibilityActions"], handler: props["disabled"] as? Bool == true ? nil : events["onAccessibilityAction"], for: result)
         (result as? CraftNativeFlowView)?.configureCelebration(props["celebration"])
         return current
     }
@@ -9882,6 +9916,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         inputEventCounts.removeValue(forKey: id)
         if node.type == "TextInput" && !preservingInputDrafts { inputDrafts.removeValue(forKey: node.identity) }
         longPressHandlers.removeValue(forKey: id)
+        accessibilityActionHandlers.removeValue(forKey: id)
         textMaxLengths.removeValue(forKey: id)
         scrollHandlers.removeValue(forKey: id)
         scrollBeginHandlers.removeValue(forKey: id)
@@ -10099,6 +10134,47 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
     }
 
+    /// What a hold offers, published where the rotor can reach it.
+    ///
+    /// A long press is invisible to VoiceOver: nothing announces that it is
+    /// there and nothing can perform it, so an action living only behind a
+    /// hold does not exist for anyone driving the screen by assistive
+    /// technology. A thread that holds a message for Copy and Report is the
+    /// case this was written for; without this the honest mitigation is a
+    /// permanently visible button under every message.
+    ///
+    /// Shape follows the rest of the accessibility props: `name` identifies
+    /// the action to the handler, `label` is what a person hears, and the
+    /// event says which one ran so one handler can serve them all.
+    private func updateAccessibilityActions(_ raw: Any?, handler: String?, for view: UIView) {
+        let id = ObjectIdentifier(view)
+        let entries = (raw as? [[String: Any]] ?? []).compactMap { entry -> (name: String, label: String)? in
+            guard let name = entry["name"] as? String, !name.isEmpty else { return nil }
+            return (name, (entry["label"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? name)
+        }
+        guard let handler, !handler.isEmpty, !entries.isEmpty else {
+            accessibilityActionHandlers.removeValue(forKey: id)
+            view.accessibilityCustomActions = nil
+            return
+        }
+        accessibilityActionHandlers[id] = handler
+        view.accessibilityCustomActions = entries.map { entry in
+            UIAccessibilityCustomAction(name: entry.label) { [weak self, weak view] _ in
+                // Read the handler at firing time: a reconcile can rename it
+                // while the rotor sits on the element.
+                guard let self, let view, let current = self.accessibilityActionHandlers[ObjectIdentifier(view)] else { return false }
+                self.send(type: "EVENT", payload: ["handlerName": current, "nativeEvent": ["actionName": entry.name]])
+                return true
+            }
+        }
+        // The rotor only lands on an element, and actions on a view it walks
+        // straight through are actions nobody can get to. A bubble whose own
+        // label is its text is exactly that case.
+        if !view.isAccessibilityElement && view.accessibilityElements == nil && view.accessibilityLabel != nil {
+            view.isAccessibilityElement = true
+        }
+    }
+
     /// Legacy runtimes echo values without a revision. Keep their bounded
     /// history on either script thread; bridge delivery may still be delayed.
     private var unechoedText: [ObjectIdentifier: [String]] = [:]

package/templates/testing/DriverTests.swift.template

@@ -285,8 +285,15 @@ final class DriverTests: XCTestCase {
         return (parts[0], parts.count > 1 ? Double(parts[1]) ?? 10 : 10)
     }
 
-    /// A tap that never fails the run: an element covered a moment (the big
-    /// timer coming up) is tapped where it is, and the check after says.
+    /// A switch reports "0" or "1". Any other value is not a switch state to
+    /// wait on, so the tap stands as it would for any other control.
+    func switchFlipped(from before: String?, to after: String?) -> Bool {
+        let states: Set<String> = ["0", "1"]
+        guard let before, let after, states.contains(before), states.contains(after) else { return true }
+        return before != after
+    }
+
+    /// Deliver one gesture; the command's observation determines success.
     func press(_ element: XCUIElement) {
         if element.isHittable { element.tap() }
         else { element.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5)).tap() }
@@ -438,8 +445,21 @@ final class DriverTests: XCTestCase {
             else { XCTFail("Element not found"); note("FAIL tapexact \(arg): NOT FOUND") }
         case "tapid":
             let target = identified(arg)
-            if target.waitForExistence(timeout: 10) { press(target); note("tapid \(arg): ok") }
-            else { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
+            if !target.waitForExistence(timeout: 10) { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
+            else if target.elementType == .switch {
+                // Observe one physical gesture. Retapping could conceal a
+                // renderer or hit-testing failure (HQ agreement job 7570).
+                let before = target.value as? String
+                press(target)
+                let settle = Date().addingTimeInterval(1.5)
+                var flipped = false
+                repeat {
+                    flipped = switchFlipped(from: before, to: target.value as? String)
+                    if !flipped { Thread.sleep(forTimeInterval: 0.25) }
+                } while !flipped && Date() < settle
+                check(flipped, "tapid \(arg) flips the switch")
+            }
+            else { press(target); note("tapid \(arg): ok") }
         case "longpressid":
             let target = identified(arg)
             guard target.waitForExistence(timeout: 10), target.isHittable else {