craft-native 0.0.435 → 0.0.442

package/dist/ios/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/dist/ios/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/dist/ios/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/dist/ios/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 {

package/dist/macos/src/index.js

@@ -43,7 +43,7 @@ import process from "process";
 var macosToolchain = {
   zig: "0.18.0-dev.252+86dc5ce25",
   sources: {
-    "zig-js": { repository: "zig-utils/zig-js", revision: "59497a090677aeb317e52ac55329e6a680457727", paths: ["src", "include", "tests", "tools", "docs", "bench", "conformance"] },
+    "zig-js": { repository: "zig-utils/zig-js", revision: "95d835edcbad55a7456cff76a9bb7ef6cdf265fc", paths: ["src", "include", "tests", "tools", "docs", "bench", "conformance"] },
     "zig-regex": { repository: "zig-utils/zig-regex", revision: "fdd9c2e333ea6ac2fd06d080d939ef7f11d61b1b", paths: ["src"] },
     "zig-gc": { repository: "zig-utils/zig-gc", revision: "73c802e05768a729614e9c4296abb118aa06faf9", paths: ["src"] }
   }

package/dist/macos/src/toolchain.d.ts

@@ -9,7 +9,7 @@ export declare const macosToolchain: {
     readonly sources: {
         readonly 'zig-js': {
             readonly repository: 'zig-utils/zig-js';
-            readonly revision: '59497a090677aeb317e52ac55329e6a680457727';
+            readonly revision: '95d835edcbad55a7456cff76a9bb7ef6cdf265fc';
             readonly paths: readonly ['src', 'include', 'tests', 'tools', 'docs', 'bench', 'conformance'];
         };
         readonly 'zig-regex': {