@craft-native/ios 0.0.451 → 0.0.467

package/templates/CraftNativeScreen.swift

@@ -13,6 +13,92 @@ import Security
 import SwiftUI
 import UIKit
 
+/// A menu belongs to its native view, not to coordinates in a web page.
+final class CraftNativeContextMenu: NSObject, UIContextMenuInteractionDelegate {
+    private(set) var items: [[String: Any]] = []
+    private var dispatch: ((String) -> Void)?
+    private weak var view: UIView?
+    private(set) lazy var interaction = UIContextMenuInteraction(delegate: self)
+    private var revision = 0
+    private var handlerIdentity: String?
+
+    init(view: UIView) {
+        self.view = view
+        super.init()
+        view.addInteraction(interaction)
+    }
+
+    static func entries(_ raw: Any?) -> [[String: Any]] {
+        var seen = Set<String>()
+        return (raw as? [[String: Any]] ?? []).filter {
+            guard let id = $0["id"] as? String, !id.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+                  let title = $0["title"] as? String, !title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return false }
+            return seen.insert(id).inserted
+        }
+    }
+
+    func update(_ entries: [[String: Any]], handler: String? = nil, dispatch: @escaping (String) -> Void) {
+        if let handler, handler == handlerIdentity, NSArray(array: items).isEqual(to: entries) {
+            self.dispatch = dispatch
+            return
+        }
+        handlerIdentity = handler
+        revision += 1
+        interaction.dismissMenu()
+        items = entries
+        self.dispatch = dispatch
+    }
+
+    func detach() {
+        revision += 1
+        dispatch = nil
+        items = []
+        interaction.dismissMenu()
+        view?.removeInteraction(interaction)
+    }
+
+    /// Captured actions from an open menu cannot target a reconciled row.
+    func selection(_ id: String) -> () -> Void {
+        let expected = revision
+        return { [weak self] in
+            guard let self, self.revision == expected,
+                  let item = self.items.first(where: { $0["id"] as? String == id }),
+                  item["disabled"] as? Bool != true else { return }
+            self.dispatch?(id)
+        }
+    }
+
+    func menu() -> UIMenu {
+        UIMenu(children: items.map { item in
+            var attributes: UIMenuElement.Attributes = []
+            if item["disabled"] as? Bool == true { attributes.insert(.disabled) }
+            if item["destructive"] as? Bool == true { attributes.insert(.destructive) }
+            let chosen = selection(item["id"] as! String)
+            return UIAction(title: item["title"] as! String,
+                            image: (item["symbol"] as? String).flatMap { UIImage(systemName: $0) },
+                            attributes: attributes) { _ in chosen() }
+        })
+    }
+
+    func menuProvider() -> UIContextMenuActionProvider {
+        // UIKit asks for contents when presentation begins, after configuration
+        // was requested. A reconciled node must not supply a different menu to
+        // an interaction that started against its previous items or handler.
+        let expected = revision
+        return { [weak self] _ in
+            guard let self, self.revision == expected,
+                  self.dispatch != nil, !self.items.isEmpty else { return nil }
+            return self.menu()
+        }
+    }
+
+    func contextMenuInteraction(_ interaction: UIContextMenuInteraction,
+                                configurationForMenuAtLocation location: CGPoint) -> UIContextMenuConfiguration? {
+        guard dispatch != nil, !items.isEmpty else { return nil }
+        return UIContextMenuConfiguration(identifier: nil, previewProvider: nil, actionProvider: menuProvider())
+    }
+}
+
 private let craftNativeCapabilityTimeoutMilliseconds = 30_000
 
 /// A retained JavaScript context must lose storage and snapshot access when
@@ -4376,6 +4462,7 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate, U
 
     private func configureSheet(_ controller: CraftNativeSheetController) {
         controller.isModalInPresentation = onRequestClose == nil
+        controller.view.accessibilityViewIsModal = true
         guard let sheet = controller.sheetPresentationController else { return }
         let choices = sheetDetents.filter { $0 == "medium" || $0 == "large" }
         let values = choices.isEmpty ? ["large"] : Array(Set(choices)).sorted { $0 == "medium" && $1 == "large" }
@@ -4432,6 +4519,7 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate, U
         guard let controller = presentationController.presentedViewController as? CraftNativeSheetController else { return }
         restoreSheetContent(controller)
         renderedVisible = false
+        accessibilityViewIsModal = false
         onRequestClose?("swipe")
     }
 
@@ -4443,7 +4531,10 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate, U
     /// screen-level overlay but lets hit testing fall through outside its
     /// interactive content.
     var blocksBackground = true {
-        didSet { blocker.isUserInteractionEnabled = blocksBackground }
+        didSet {
+            blocker.isUserInteractionEnabled = blocksBackground
+            accessibilityViewIsModal = blocksBackground && renderedVisible
+        }
     }
     /// An opt-in non-modal dismissal policy. The default popup remains
     /// pass-through; when enabled, an outside tap is consumed and routed to
@@ -4471,6 +4562,7 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate, U
     /// press bookkeeping once turned that off for a view with no handler of
     /// its own, and a shown modal let every tap through to the screen behind.
     func setVisible(_ visible: Bool, opacity: CGFloat, animationType: String?) {
+        accessibilityViewIsModal = blocksBackground && visible
         if blocksBackground && (presentationStyle == "pageSheet" || presentationStyle == "formSheet") {
             setSheetVisible(visible, animated: animationType != "none")
             return
@@ -4528,6 +4620,7 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate, U
 
     func resetForTeardown() {
         renderedVisible = false
+        accessibilityViewIsModal = false
         sheetPresenter = nil
         if let controller = sheetController {
             controller.dismiss(animated: false)
@@ -6404,7 +6497,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var inputIdentities: [ObjectIdentifier: String] = [:]
     private var inputDrafts: [String: String] = [:]
     private var longPressHandlers: [ObjectIdentifier: String] = [:]
+    private var contextMenus: [ObjectIdentifier: CraftNativeContextMenu] = [:]
     private var accessibilityActionHandlers: [ObjectIdentifier: String] = [:]
+    private var accessibilityActionRevisions: [ObjectIdentifier: UUID] = [:]
     private var textMaxLengths: [ObjectIdentifier: Int] = [:]
     private var scrollHandlers: [ObjectIdentifier: String] = [:]
     private var scrollBeginHandlers: [ObjectIdentifier: String] = [:]
@@ -7420,6 +7515,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 // DOM fallback even though this screen can present UIKit.
                 function installNativeDialog() {
                     var craft = globalThis.craft = globalThis.craft || {};
+                    craft.accessibility = {
+                        announce: function(text, options) { return request('Accessibility', 'announce', [text, options == null ? {} : options]).then(function() {}); }
+                    };
                     if (Array.isArray(bridge.capabilities) && bridge.capabilities.indexOf('dialog') >= 0) {
                         craft.dialog = {
                             alert: function(options) { return request('Dialog', 'alert', [options || {}], true).then(function() {}); },
@@ -9203,7 +9301,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             field.textColor = color(style["color"]) ?? .label
             field.font = textFont(style, default: .systemFont(ofSize: 16))
             field.textAlignment = textAlignment(style["textAlign"])
-            field.defaultTextAttributes = inputTextAttributes(style, font: field.font ?? .systemFont(ofSize: 16), alignment: field.textAlignment)
+            field.defaultTextAttributes = inputTextAttributes(style, font: field.font ?? .systemFont(ofSize: 16), alignment: field.textAlignment, singleLine: true)
             let desiredKeyboardType = keyboardType(props["keyboardType"])
             if field.keyboardType != desiredKeyboardType { field.keyboardType = desiredKeyboardType }
             let desiredReturnKeyType = returnKeyType(props["returnKeyType"])
@@ -9626,7 +9724,15 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             configureStack(stack, style: style)
             reconcileChildren(children, in: stack, parent: current, path: path, style: style)
         }
-        updateLongPressHandler(props["disabled"] as? Bool == true ? nil : events["onLongPress"], for: result)
+        let menuDisabled = props["disabled"] as? Bool == true || (props["accessibilityState"] as? [String: Any])?["disabled"] as? Bool == true
+        // STX's HTML parser lowercases unknown bound props and maps
+        // @contextmenu to onLongPress. Keep that authored path usable too.
+        let menuEntries = menuDisabled ? [] : CraftNativeContextMenu.entries(props["contextMenu"] ?? props["contextmenu"])
+        let menuHandler = nonEmptyHandler(events["onContextMenuAction"]) ?? nonEmptyHandler(events["onLongPress"])
+        let hasMenu = !menuEntries.isEmpty && menuHandler != nil
+        // A menu owns the hold when both are authored; never open an action
+        // sheet from onLongPress underneath UIKit's menu.
+        updateLongPressHandler(menuDisabled || hasMenu ? nil : events["onLongPress"], for: result)
         if type != "Button" && type != "Link" && type != "Checkbox" && type != "TextInput" && type != "Picker" && type != "SegmentedControl" && type != "DatePicker" && type != "Modal" && type != "Switch" && type != "Slider" && type != "ActivityIndicator" && type != "StatusBar" && type != "RefreshControl" && type != "Map" {
             let disabled = props["disabled"] as? Bool == true
             updatePressHandler(disabled ? nil : nonEmptyHandler(events["onPress"]) ?? nonEmptyHandler(events["onClick"]), for: result)
@@ -9646,7 +9752,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         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)
+        updateAccessibilityActions(props["accessibilityActions"], handler: menuDisabled ? nil : events["onAccessibilityAction"], for: result)
+        let menuID = ObjectIdentifier(result)
+        if hasMenu, let menuHandler {
+            let menu = contextMenus[menuID] ?? CraftNativeContextMenu(view: result)
+            contextMenus[menuID] = menu
+            menu.update(menuEntries, handler: menuHandler) { [weak self] itemID in
+                self?.send(type: "EVENT", payload: ["handlerName": menuHandler, "nativeEvent": ["id": itemID]])
+            }
+            result.isUserInteractionEnabled = true
+        } else {
+            contextMenus.removeValue(forKey: menuID)?.detach()
+        }
         (result as? CraftNativeFlowView)?.configureCelebration(props["celebration"])
         return current
     }
@@ -10129,7 +10246,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         inputEventCounts.removeValue(forKey: id)
         if node.type == "TextInput" && !preservingInputDrafts { inputDrafts.removeValue(forKey: node.identity) }
         longPressHandlers.removeValue(forKey: id)
+        contextMenus.removeValue(forKey: id)?.detach()
         accessibilityActionHandlers.removeValue(forKey: id)
+        accessibilityActionRevisions.removeValue(forKey: id)
+        node.view.accessibilityCustomActions = nil
         textMaxLengths.removeValue(forKey: id)
         scrollHandlers.removeValue(forKey: id)
         scrollBeginHandlers.removeValue(forKey: id)
@@ -10367,15 +10487,19 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         guard let handler, !handler.isEmpty, !entries.isEmpty else {
             accessibilityActionHandlers.removeValue(forKey: id)
+            accessibilityActionRevisions.removeValue(forKey: id)
             view.accessibilityCustomActions = nil
             return
         }
         accessibilityActionHandlers[id] = handler
+        let revision = UUID()
+        accessibilityActionRevisions[id] = revision
         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 }
+                guard let self, let view, self.accessibilityActionRevisions[ObjectIdentifier(view)] == revision,
+                      let current = self.accessibilityActionHandlers[ObjectIdentifier(view)] else { return false }
                 self.send(type: "EVENT", payload: ["handlerName": current, "nativeEvent": ["actionName": entry.name]])
                 return true
             }
@@ -10806,7 +10930,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func inputTextAttributes(
         _ style: [String: Any],
         font: UIFont,
-        alignment: NSTextAlignment
+        alignment: NSTextAlignment,
+        singleLine: Bool = false
     ) -> [NSAttributedString.Key: Any] {
         var attributes: [NSAttributedString.Key: Any] = [
             .foregroundColor: color(style["color"]) ?? .label,
@@ -10816,6 +10941,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // UIKit otherwise resets the field's alignment to natural when these attributes are applied.
         let paragraph = NSMutableParagraphStyle()
         paragraph.alignment = alignment
+        // The default paragraph wraps even inside a UITextField. A long URL
+        // then paints a second line outside the field instead of scrolling.
+        if singleLine { paragraph.lineBreakMode = .byClipping }
         if let lineHeight = number(style["lineHeight"]) {
             paragraph.minimumLineHeight = lineHeight
             paragraph.maximumLineHeight = lineHeight
@@ -11230,6 +11358,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         view.accessibilityLabel = (props["accessibilityLabel"] as? String)
             ?? ((type == "Image" || type == "ImageBackground") ? props["alt"] as? String : nil)
         view.accessibilityHint = props["accessibilityHint"] as? String
+        let language = (props["accessibilityLanguage"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+        view.accessibilityLanguage = language?.isEmpty == false ? language : nil
         if let value = props["accessibilityValue"] {
             view.accessibilityValue = (value as? String) ?? (value as? NSNumber)?.stringValue
             authoredAccessibilityValues.insert(id)

package/templates/CraftNotificationService.swift

@@ -0,0 +1,199 @@
+import Foundation
+import ImageIO
+import UserNotifications
+
+/// A separate extension process: no app runtime, shared container or JS required.
+final class CraftNotificationService: UNNotificationServiceExtension {
+    private let lock = NSLock()
+    private var delivery: CraftRemoteNotificationDelivery?
+
+    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
+        let next = CraftRemoteNotificationDelivery()
+        lock.lock()
+        let previous = delivery
+        delivery = next
+        lock.unlock()
+        previous?.expire()
+        next.start(request.content, completion: contentHandler)
+    }
+
+    override func serviceExtensionTimeWillExpire() {
+        lock.lock()
+        let current = delivery
+        lock.unlock()
+        current?.expire()
+    }
+}
+
+/// Serial streaming downloads bound both disk use and the extension's lifetime.
+/// Any failure returns the original alert, without partially attached media.
+final class CraftRemoteNotificationDelivery: NSObject, URLSessionDataDelegate {
+    static let maximumBytes = 10 * 1024 * 1024
+    private let queue = DispatchQueue(label: "craft.notification-service")
+    private let configuration: URLSessionConfiguration
+    private let root: URL
+    private let timeout: TimeInterval
+    private var session: URLSession?
+    private var task: URLSessionDataTask?
+    private var deadline: DispatchWorkItem?
+    private var original: UNNotificationContent?
+    private var handler: ((UNNotificationContent) -> Void)?
+    private var expired = false
+    private var entries: [(String, URL)] = []
+    private var attachments: [UNNotificationAttachment] = []
+    private var folder: URL?
+    private var file: URL?
+    private var stream: FileHandle?
+    private var received = 0
+
+    init(configuration: URLSessionConfiguration = .ephemeral,
+         root: URL = FileManager.default.temporaryDirectory.appendingPathComponent("craft-remote-notifications", isDirectory: true),
+         timeout: TimeInterval = 25) {
+        self.configuration = configuration
+        self.root = root
+        self.timeout = timeout
+        super.init()
+    }
+
+    static func permitted(_ url: URL) -> Bool {
+        url.scheme?.lowercased() == "https" && url.host?.isEmpty == false && url.user == nil && url.password == nil
+    }
+
+    func start(_ content: UNNotificationContent, completion: @escaping (UNNotificationContent) -> Void) {
+        queue.async {
+            self.original = content
+            self.handler = completion
+            guard !self.expired, let raw = content.userInfo["craftAttachments"] as? [[String: Any]],
+                  !raw.isEmpty, raw.count <= 10 else { self.finish(false); return }
+            var ids = Set<String>()
+            for item in raw {
+                guard let id = item["id"] as? String, !id.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+                      id.utf8.count <= 128, ids.insert(id).inserted,
+                      let string = item["url"] as? String, let url = URL(string: string), Self.permitted(url) else {
+                    self.finish(false); return
+                }
+                self.entries.append((id, url))
+            }
+            do {
+                try FileManager.default.createDirectory(at: self.root, withIntermediateDirectories: true)
+                // Successful handoffs must outlive the handler: iOS validates and
+                // moves their files AFTER the extension finishes. Sweep only old
+                // UUID folders, never another delivery still in flight.
+                for url in try FileManager.default.contentsOfDirectory(at: self.root, includingPropertiesForKeys: [.creationDateKey]) {
+                    if UUID(uuidString: url.lastPathComponent) != nil,
+                       let created = try url.resourceValues(forKeys: [.creationDateKey]).creationDate,
+                       created < Date().addingTimeInterval(-86_400) {
+                        try? FileManager.default.removeItem(at: url)
+                    }
+                }
+                let folder = self.root.appendingPathComponent(UUID().uuidString, isDirectory: true)
+                try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+                self.folder = folder
+            } catch { self.finish(false); return }
+            self.configuration.httpCookieStorage = nil
+            self.configuration.httpShouldSetCookies = false
+            self.configuration.urlCredentialStorage = nil
+            self.configuration.urlCache = nil
+            self.configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
+            self.configuration.timeoutIntervalForRequest = self.timeout
+            self.configuration.timeoutIntervalForResource = self.timeout
+            self.session = URLSession(configuration: self.configuration, delegate: self, delegateQueue: nil)
+            let deadline = DispatchWorkItem { [weak self] in self?.finish(false) }
+            self.deadline = deadline
+            self.queue.asyncAfter(deadline: .now() + self.timeout, execute: deadline)
+            self.downloadNext()
+        }
+    }
+
+    func expire() {
+        queue.async { self.expired = true; self.finish(false) }
+    }
+
+    private func downloadNext() {
+        guard attachments.count < entries.count else { finish(true); return }
+        file = nil
+        task = session?.dataTask(with: entries[attachments.count].1)
+        task?.resume()
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse,
+                    newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) {
+        queue.async {
+            guard self.handler != nil, let url = request.url, Self.permitted(url) else {
+                completionHandler(nil); self.finish(false); return
+            }
+            completionHandler(request)
+        }
+    }
+
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse,
+                    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+        queue.async {
+            let formats = ["image/jpeg": "jpg", "image/png": "png", "image/gif": "gif",
+                           "audio/mpeg": "mp3", "audio/mp4": "m4a", "audio/wav": "wav", "audio/x-wav": "wav",
+                           "audio/aiff": "aiff", "audio/x-aiff": "aiff", "video/mp4": "mp4", "video/mpeg": "mpeg", "video/x-msvideo": "avi"]
+            guard self.handler != nil, let http = response as? HTTPURLResponse, http.statusCode == 200,
+                  let url = response.url, Self.permitted(url),
+                  let suffix = formats[response.mimeType?.lowercased() ?? ""], let folder = self.folder,
+                  response.expectedContentLength <= Int64(Self.maximumBytes - self.received) else {
+                completionHandler(.cancel); self.finish(false); return
+            }
+            let file = folder.appendingPathComponent(UUID().uuidString).appendingPathExtension(suffix)
+            do {
+                guard FileManager.default.createFile(atPath: file.path, contents: nil) else { throw CocoaError(.fileWriteUnknown) }
+                self.file = file
+                self.stream = try FileHandle(forWritingTo: file)
+                completionHandler(.allow)
+            } catch { completionHandler(.cancel); self.finish(false) }
+        }
+    }
+
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        // Backpressure the delegate queue: do not retain an unbounded queue of
+        // Data chunks from a fast/chunked server while disk writes catch up.
+        queue.sync {
+            guard self.handler != nil else { return }
+            guard data.count <= Self.maximumBytes - self.received, let stream = self.stream else { self.finish(false); return }
+            do { try stream.write(contentsOf: data); self.received += data.count }
+            catch { self.finish(false) }
+        }
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        queue.async {
+            guard self.handler != nil else { return }
+            do {
+                try self.stream?.close()
+                self.stream = nil
+                guard error == nil, let file = self.file else { self.finish(false); return }
+                if ["jpg", "png", "gif"].contains(file.pathExtension) {
+                    guard let image = CGImageSourceCreateWithURL(file as CFURL, nil), CGImageSourceGetCount(image) > 0,
+                          CGImageSourceGetStatus(image) == .statusComplete else { self.finish(false); return }
+                }
+                let attachment = try UNNotificationAttachment(identifier: self.entries[self.attachments.count].0, url: file, options: nil)
+                self.attachments.append(attachment)
+                self.downloadNext()
+            } catch { self.finish(false) }
+        }
+    }
+
+    private func finish(_ success: Bool) {
+        guard let handler, let original else { return }
+        self.handler = nil
+        deadline?.cancel()
+        deadline = nil
+        task?.cancel()
+        session?.invalidateAndCancel()
+        session = nil
+        try? stream?.close()
+        stream = nil
+        if success, let content = original.mutableCopy() as? UNMutableNotificationContent {
+            content.attachments = original.attachments + attachments
+            handler(content)
+            // No acknowledgement exists here. Leave successful files for iOS.
+        } else {
+            if let folder { try? FileManager.default.removeItem(at: folder) }
+            handler(original)
+        }
+    }
+}

package/templates/CraftVoiceRecording.swift

@@ -105,11 +105,21 @@ final class CraftVoiceRecording {
     private var generation = 0
     private let startupTimeout: TimeInterval
     private let stopTimeout: TimeInterval
+    struct FileRemovalReceipt: Encodable {
+        let queueMilliseconds: Double
+        let removalMilliseconds: Double
+        let ownedBefore: Bool
+        let removed: Bool
+        let existsAfter: Bool
+    }
+    // Internal observation of the real deletion, not a replacement filesystem.
+    private let fileRemovalObserved: ((FileRemovalReceipt) -> Void)?
     private var backgroundObserver: NSObjectProtocol?
 
     init(audioQueue: DispatchQueue = DispatchQueue(label: "craft.voice-recording", qos: .userInitiated),
          startupTimeout: TimeInterval = 15,
          stopTimeout: TimeInterval = 10,
+         fileRemovalObserved: ((FileRemovalReceipt) -> Void)? = nil,
          permission: @escaping (@escaping (Bool) -> Void) -> Void = { answer in
              #if CRAFT_PERMISSION_MICROPHONE
              AVAudioSession.sharedInstance().requestRecordPermission(answer)
@@ -132,6 +142,7 @@ final class CraftVoiceRecording {
         self.audioQueue = audioQueue
         self.startupTimeout = startupTimeout
         self.stopTimeout = stopTimeout
+        self.fileRemovalObserved = fileRemovalObserved
         self.permission = permission
         self.makeRecorder = makeRecorder
         self.deactivate = deactivate
@@ -164,7 +175,24 @@ final class CraftVoiceRecording {
         session.finish(.failure(error))
         if let file = session.file {
             // A stalled encoder must not hold deletion behind its audio queue.
-            Self.fileQueue.async { CraftNativeFiles.remove(file.path) }
+            let queued = ProcessInfo.processInfo.systemUptime
+            let observed = fileRemovalObserved
+            Self.trace("cancel \(session.key.prefix(8)): file removal queued")
+            Self.fileQueue.async {
+                let began = ProcessInfo.processInfo.systemUptime
+                let owned = CraftNativeFiles.owned(file.path) != nil
+                let removed = CraftNativeFiles.remove(file.path)
+                let receipt = FileRemovalReceipt(
+                    queueMilliseconds: (began - queued) * 1000,
+                    removalMilliseconds: (ProcessInfo.processInfo.systemUptime - began) * 1000,
+                    ownedBefore: owned, removed: removed,
+                    existsAfter: FileManager.default.fileExists(atPath: file.path))
+                // No path or recording content is included in diagnostics.
+                if let json = try? JSONEncoder().encode(receipt), let text = String(data: json, encoding: .utf8) {
+                    Self.trace("cancel \(session.key.prefix(8)): file removal \(text)")
+                }
+                observed?(receipt)
+            }
         }
         audioQueue.async { self.erase(session) }
     }

package/templates/testing/DriverTests.swift.template

@@ -61,6 +61,8 @@ final class DriverTests: XCTestCase {
     let tabs: [String] = {{TABS}}
     let tabIdentifiers: [String: String] = {{TAB_IDENTIFIERS}}
     private var bundledJourney = false
+    private var lastTappedInput: XCUIElement?
+    private var lastBooleanTap: [String: Any]?
 
     func get(_ path: String, timeout: Double = 15) -> Data? {
         var result: Data?
@@ -293,8 +295,6 @@ final class DriverTests: XCTestCase {
         return (parts[0], parts.count > 1 ? Double(parts[1]) ?? 10 : 10)
     }
 
-    /// 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.
     /// The switch answers `/exec` with 200 whatever the hook did, its first
     /// word the hook's exit code: only `exit 0` is a hook that worked.
     func hookSucceeded(_ answer: String) -> Bool {
@@ -308,16 +308,26 @@ final class DriverTests: XCTestCase {
         return fields.count >= 2 && fields[1] == "0"
     }
 
+    /// UIKit and Craft's solid toggle both publish "0" or "1", regardless
+    /// of the accessibility element type that XCTest assigns to them.
     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 }
+        // A lost accessibility value is missing evidence, not a successful tap.
+        guard let before, let after, states.contains(before), states.contains(after) else { return false }
         return before != after
     }
 
     /// Deliver one gesture; the command's observation determines success.
     func press(_ element: XCUIElement) {
+        // Resolve this before activation: a menu item can disappear as soon
+        // as its gesture completes (for example Select All).
+        let input = [.textField, .secureTextField, .textView, .searchField].contains(element.elementType)
+            ? element : nil
         if element.isHittable { element.tap() }
         else { element.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5)).tap() }
+        // A tap on a read-only text view need not open the keyboard. Only a
+        // following type command observes whether this target took focus.
+        lastTappedInput = input
     }
 
     func answerOpenPrompt() {
@@ -353,6 +363,11 @@ final class DriverTests: XCTestCase {
         let parts = line.split(separator: " ", maxSplits: 1).map(String.init)
         let command = parts[0]
         let arg = parts.count > 1 ? parts[1] : ""
+        // Context changes can move focus without going through press().
+        if ["launch", "activate", "terminate", "home", "background", "openurl", "universallink",
+            "back", "return", "tab", "tapxy", "edge", "notifications", "systemtap", "longpressid", "exec"].contains(command) {
+            lastTappedInput = nil
+        }
         if bundledJourney && ["net", "delay", "exec"].contains(command) {
             check(false, "\(command) requires a control-server journey")
             return
@@ -470,12 +485,15 @@ final class DriverTests: XCTestCase {
             if let target = poll(10, { exact(arg) }) { press(target); note("tapexact \(arg): ok") }
             else { XCTFail("Element not found"); note("FAIL tapexact \(arg): NOT FOUND") }
         case "tapid":
+            lastBooleanTap = nil
             let target = identified(arg)
             if !target.waitForExistence(timeout: 10) { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
-            else if target.elementType == .switch {
+            else if target.elementType == .switch || ["0", "1"].contains(target.value as? String ?? "") {
                 // Observe one physical gesture. Retapping could conceal a
                 // renderer or hit-testing failure (HQ agreement job 7570).
                 let before = target.value as? String
+                let enabledBefore = target.isEnabled
+                let frameBefore = target.frame
                 press(target)
                 let settle = Date().addingTimeInterval(1.5)
                 var flipped = false
@@ -483,6 +501,15 @@ final class DriverTests: XCTestCase {
                     flipped = switchFlipped(from: before, to: target.value as? String)
                     if !flipped { Thread.sleep(forTimeInterval: 0.25) }
                 } while !flipped && Date() < settle
+                let observation: [String: Any] = [
+                    "id": arg, "gestures": 1, "flipped": flipped,
+                    "enabledBefore": enabledBefore, "enabledAfter": target.isEnabled,
+                    "valueBefore": before ?? "unknown", "valueAfter": target.value as? String ?? "unknown",
+                    "frameBefore": [frameBefore.origin.x, frameBefore.origin.y, frameBefore.width, frameBefore.height],
+                ]
+                lastBooleanTap = observation
+                if let data = try? JSONSerialization.data(withJSONObject: observation, options: [.sortedKeys]),
+                   let json = String(data: data, encoding: .utf8) { note("BOOLEAN_TAP \(json)") }
                 check(flipped, "tapid \(arg) flips the switch")
             }
             else { press(target); note("tapid \(arg): ok") }
@@ -596,9 +623,20 @@ final class DriverTests: XCTestCase {
                 start.press(forDuration: 0.05, thenDragTo: app.coordinate(withNormalizedOffset: CGVector(dx: 0.8, dy: 0.5)))
                 note("back: edge swipe")
             }
-        case "type": app.typeText(arg)
+        case "type":
+            let target = lastTappedInput ?? app
+            lastTappedInput = nil
+            // A returned gesture is not proof of keyboard focus. Observe the
+            // one gesture before typing, including WebKit/cold-keyboard focus
+            // delivery. Never retap and conceal a dropped input event.
+            guard poll(15, { self.hasKeyboardFocus(target) ? target : nil }) != nil else {
+                check(false, "type into \(target.label) takes keyboard focus")
+                return
+            }
+            app.typeText(arg)
         case "return": app.typeText(XCUIKeyboardKey.return.rawValue); note("return")
         case "typeid":
+            lastTappedInput = nil
             let idParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
             let target = identified(idParts[0])
             if target.waitForExistence(timeout: 10) {
@@ -627,6 +665,7 @@ final class DriverTests: XCTestCase {
             let target = XCUIApplication(bundleIdentifier: bundle)
             check(target.wait(for: .runningForeground, timeout: seconds), "expectapp \(bundle)")
         case "field":
+            lastTappedInput = nil
             let fieldParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
             let index = Int(fieldParts[0]) ?? 0
             let fields = app.textFields.allElementsBoundByIndex + app.secureTextFields.allElementsBoundByIndex