craft-native 0.0.436 → 0.0.443

package/dist/ios/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/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/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: "44a0a2ba814a911ac701c44073bd8d7d8ff6a22d", 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: '44a0a2ba814a911ac701c44073bd8d7d8ff6a22d';
+            readonly revision: '95d835edcbad55a7456cff76a9bb7ef6cdf265fc';
             readonly paths: readonly ['src', 'include', 'tests', 'tools', 'docs', 'bench', 'conformance'];
         };
         readonly 'zig-regex': {