craft-native 0.0.341 → 0.0.345

package/dist/android/templates/CraftNativeCapabilities.kt.template

@@ -630,7 +630,10 @@ internal class CraftNativeCapabilities(
     private fun sweepFiles() {
         val cutoff = System.currentTimeMillis() - 24L * 60L * 60L * 1000L
         fileRoot.listFiles()?.forEach { file ->
-            if (file.lastModified() < cutoff) file.deleteRecursively()
+            // Voice captures have a separate launch lifetime; sweep only
+            // generic per-file UUID folders here.
+            val owned = runCatching { UUID.fromString(file.name).toString().equals(file.name, ignoreCase = true) }.getOrDefault(false)
+            if (owned && file.lastModified() < cutoff) file.deleteRecursively()
         }
     }
 

package/dist/android/templates/CraftNativeServices.kt.template

@@ -85,6 +85,7 @@ internal class CraftNativeServices(
 {{NATIVE_WALLET_FIELDS}}
 
     init {
+        prepareVoiceFiles(context, config.optBoolean("enableAudioRecording"))
         if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
             // Native screens must also hear a recording started by the page.
             // Keep this process sink independent from the page's listener.
@@ -629,7 +630,7 @@ internal class CraftNativeServices(
     private var voiceFile: File? = null
     private var pendingVoicePermission: ((Boolean) -> Unit)? = null
 
-    fun pauseVoice() { if (voiceRecorder != null) cancelVoice() }
+    fun pauseVoice() { if (voiceRecorder != null || voiceFile != null) cancelVoice() }
     private fun cancelVoice() {
         voiceOwner = null
         val recorder = voiceRecorder
@@ -676,7 +677,7 @@ internal class CraftNativeServices(
             if (voiceOwner != key) { done(failure("RECORDING_CANCELLED", "Recording was cancelled")); return@start }
             if (!allowed) { cancelVoice(); done(failure("PERMISSION_DENIED", "Microphone permission was refused")); return@start }
             try {
-                val folder = File(context.cacheDir, "craft-files/" + UUID.randomUUID()).apply { mkdirs() }
+                val folder = File(context.cacheDir, "craft-files/voice-recordings/" + UUID.randomUUID()).apply { mkdirs() }
                 val file = File(folder, "voice-feedback.m4a")
                 voiceFile = file
                 @Suppress("DEPRECATION")
@@ -816,6 +817,38 @@ internal class CraftNativeServices(
     private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
 
     companion object {
+        private var voiceFilesPrepared = false
+        private var legacyVoiceFilesPrepared = false
+
+        @Synchronized
+        private fun prepareVoiceFiles(context: Context, includeLegacy: Boolean) {
+            val root = File(context.cacheDir, "craft-files")
+            if (!voiceFilesPrepared) {
+                discardAbandonedVoiceFiles(root, false)
+                voiceFilesPrepared = true
+            }
+            if (includeLegacy && !legacyVoiceFilesPrepared) {
+                discardAbandonedVoiceFiles(root)
+                legacyVoiceFilesPrepared = true
+            }
+        }
+
+        internal fun discardAbandonedVoiceFiles(root: File, includeLegacy: Boolean = true) {
+            val base = root.canonicalFile
+            val voice = File(base, "voice-recordings")
+            for (scope in if (includeLegacy) listOf(base, voice) else listOf(voice)) {
+                if (scope.canonicalFile != scope.absoluteFile) continue
+                for (folder in scope.listFiles().orEmpty()) {
+                    val owned = runCatching { UUID.fromString(folder.name).toString().equals(folder.name, ignoreCase = true) }.getOrDefault(false)
+                    if (!owned || folder.canonicalFile != folder.absoluteFile) continue
+                    val file = File(folder, "voice-feedback.m4a")
+                    if (!file.isFile || file.canonicalFile != file.absoluteFile) continue
+                    file.delete()
+                    if (folder.listFiles()?.isEmpty() == true) folder.delete()
+                }
+            }
+        }
+
         const val PUSH_PERMISSION_REQUEST = 4207
         const val LOCATION_PERMISSION_REQUEST = 4208
     }

package/dist/cli.js

@@ -3022,7 +3022,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.341";
+var version = "0.0.345";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -375,7 +375,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.341";
+var version = "0.0.345";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -117,7 +117,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.341";
+var version = "0.0.345";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/templates/CraftHybrid.swift

@@ -1796,12 +1796,18 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
                 hybrid.openOutside(raw)
                 return
             }
-            open(CraftHybridRoutes.appPath(of: url))
+            open(CraftHybridRoutes.appPath(of: url), props: props)
             return
         }
         guard let path = CraftHybridRoutes.normalize(raw) else { return }
         if let tab = hybrid.tabIds.first(where: { CraftHybridRoutes.normalize($0) == path }) {
-            selectTabAsIfTapped(tab)
+            if hybrid.routes.match(raw) != nil, URLComponents(string: raw)?.query != nil || !props.isEmpty {
+                // A checkout/auth return targets the retained tab with new
+                // parameters. Selecting alone would discard that handoff.
+                showNative(path: raw, replace: false, props: props)
+            } else {
+                selectTabAsIfTapped(tab)
+            }
             return
         }
         if hybrid.routes.match(raw) != nil {

package/dist/ios/templates/CraftNativeFiles.swift

@@ -94,6 +94,9 @@ enum CraftNativeFiles {
         let dayAgo = Date().addingTimeInterval(-86_400)
         let folders = (try? fm.contentsOfDirectory(at: root, includingPropertiesForKeys: [.creationDateKey])) ?? []
         for folder in folders {
+            // Only generic per-file folders: private voice captures have their
+            // own launch lifetime and must not be swept during a live recording.
+            guard UUID(uuidString: folder.lastPathComponent) != nil else { continue }
             let created = (try? folder.resourceValues(forKeys: [.creationDateKey]))?.creationDate ?? .distantPast
             if created < dayAgo { try? fm.removeItem(at: folder) }
         }

package/dist/ios/templates/CraftNativeScreen.swift

@@ -5804,6 +5804,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         self.routeProps = routeProps
         self.isAppScript = isAppScript
         super.init(nibName: nil, bundle: nil)
+        CraftVoiceRecording.prepareForLaunch(includeLegacy: config.enableAudioRecording)
     }
 
     required init?(coder: NSCoder) {

package/dist/ios/templates/CraftVoiceRecording.swift

@@ -2,26 +2,133 @@ import AVFoundation
 import Foundation
 import UIKit
 
-/// One owner at a time, including the asynchronous permission prompt. A late
-/// permission answer cannot start recording after its screen/account left.
+protocol CraftVoiceRecorder: AnyObject {
+    func record(forDuration duration: TimeInterval) -> Bool
+    func stop()
+}
+extension AVAudioRecorder: CraftVoiceRecorder {}
+
+/// The main thread owns requests; audio and encoder work belong to one serial
+/// queue. Cancellation invalidates a request immediately, even while AVFoundation
+/// is starting, so a late permission/encoder answer cannot resurrect it.
 final class CraftVoiceRecording {
     static let shared = CraftVoiceRecording()
-    private var owner: String?
-    private var recorder: AVAudioRecorder?
-    private var file: URL?
+    private static let fileQueue = DispatchQueue(label: "craft.voice-recording-files", qos: .utility)
+    private static let launchCleanup: Void = discardAbandonedRecordings(includeLegacy: false)
+    private static let legacyCleanup: Void = discardAbandonedRecordings()
+    private static let folderName = "voice-recordings"
+
+    /// Temporary voice files have a launch lifetime, unlike picked files and
+    /// downloads. Run once across all screens, without touching audio hardware.
+    static func prepareForLaunch(includeLegacy: Bool = true) {
+        _ = launchCleanup
+        if includeLegacy { _ = legacyCleanup }
+    }
+
+    static func discardAbandonedRecordings(in root: URL = CraftNativeFiles.root, includeLegacy: Bool = true) {
+        let fm = FileManager.default
+        // Also migrate the recorder's earlier UUID folders at craft-files' root.
+        let voice = root.appendingPathComponent(folderName, isDirectory: true)
+        for scope in includeLegacy ? [root, voice] : [voice] {
+            guard (try? scope.resourceValues(forKeys: [.isSymbolicLinkKey]))?.isSymbolicLink != true else { continue }
+            let folders = (try? fm.contentsOfDirectory(at: scope, includingPropertiesForKeys: [.isSymbolicLinkKey])) ?? []
+            for folder in folders {
+                guard UUID(uuidString: folder.lastPathComponent) != nil,
+                      (try? folder.resourceValues(forKeys: [.isSymbolicLinkKey]))?.isSymbolicLink != true else { continue }
+                let file = folder.appendingPathComponent("voice-feedback.m4a")
+                let values = try? file.resourceValues(forKeys: [.isSymbolicLinkKey, .isRegularFileKey])
+                guard values?.isRegularFile == true, values?.isSymbolicLink != true else { continue }
+                try? fm.removeItem(at: file)
+                if (try? fm.contentsOfDirectory(atPath: folder.path).isEmpty) == true { try? fm.removeItem(at: folder) }
+            }
+        }
+    }
+
+    private static func newRecordingFile() throws -> URL {
+        prepareForLaunch()
+        let root = CraftNativeFiles.root.appendingPathComponent(folderName, isDirectory: true)
+        guard (try? root.resourceValues(forKeys: [.isSymbolicLinkKey]))?.isSymbolicLink != true else { throw CocoaError(.fileWriteNoPermission) }
+        let folder = root.appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        let file = folder.appendingPathComponent("voice-feedback.m4a")
+        do {
+            // An owned placeholder lets cancellation erase the path even when
+            // AVFoundation has not finished constructing its recorder yet.
+            try Data().write(to: file)
+            return file
+        } catch {
+            try? FileManager.default.removeItem(at: folder)
+            throw error
+        }
+    }
+    private final class Session {
+        let key: String
+        var file: URL?
+        var recorder: CraftVoiceRecorder? // audio queue only
+        var completion: ((Result<Any, CraftNativeActionError>) -> Void)? // main only
+        var deadline: DispatchWorkItem?
+        private let lock = NSLock()
+        private var cancelled = false
+        init(key: String, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+            self.key = key
+            self.completion = completion
+        }
+        var isCancelled: Bool { lock.withLock { cancelled } }
+        func invalidate() { lock.withLock { cancelled = true } }
+        func finish(_ result: Result<Any, CraftNativeActionError>) {
+            deadline?.cancel()
+            deadline = nil
+            let done = completion
+            completion = nil
+            done?(result)
+        }
+    }
+    private var current: Session?
+    private let audioQueue: DispatchQueue
+    private let permission: (@escaping (Bool) -> Void) -> Void
+    private let makeRecorder: (URL) throws -> CraftVoiceRecorder
+    private let deactivate: () -> Void
+    private let startupTimeout: TimeInterval
     private var backgroundObserver: NSObjectProtocol?
 
-    private init() {
+    init(audioQueue: DispatchQueue = DispatchQueue(label: "craft.voice-recording", qos: .userInitiated),
+         startupTimeout: TimeInterval = 15,
+         permission: @escaping (@escaping (Bool) -> Void) -> Void = { AVAudioSession.sharedInstance().requestRecordPermission($0) },
+         makeRecorder: @escaping (URL) throws -> CraftVoiceRecorder = { file in
+             let session = AVAudioSession.sharedInstance()
+             try session.setCategory(.record, mode: .measurement)
+             try session.setActive(true)
+             return try AVAudioRecorder(url: file, settings: [AVFormatIDKey: kAudioFormatMPEG4AAC, AVSampleRateKey: 16000, AVNumberOfChannelsKey: 1, AVEncoderBitRateKey: 32000])
+         },
+         deactivate: @escaping () -> Void = { try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation) }) {
+        Self.prepareForLaunch()
+        self.audioQueue = audioQueue
+        self.startupTimeout = startupTimeout
+        self.permission = permission
+        self.makeRecorder = makeRecorder
+        self.deactivate = deactivate
         backgroundObserver = NotificationCenter.default.addObserver(forName: UIApplication.didEnterBackgroundNotification, object: nil, queue: .main) { [weak self] _ in self?.clear() }
     }
 
-    private func clear() {
-        owner = nil
-        recorder?.stop()
-        recorder = nil
-        if let file { CraftNativeFiles.remove(file.path) }
-        file = nil
-        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+    deinit { if let backgroundObserver { NotificationCenter.default.removeObserver(backgroundObserver) } }
+
+    private func erase(_ session: Session) {
+        session.recorder?.stop()
+        session.recorder = nil
+        if let file = session.file { CraftNativeFiles.remove(file.path) }
+        deactivate()
+    }
+
+    private func clear(_ error: CraftNativeActionError = CraftNativeActionError(code: "RECORDING_CANCELLED", message: "Recording was cancelled")) {
+        guard let session = current else { return }
+        current = nil
+        session.invalidate()
+        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) }
+        }
+        audioQueue.async { self.erase(session) }
     }
 
     func perform(method: String, args: [Any], isActive: @escaping () -> Bool = { true }, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
@@ -32,43 +139,84 @@ final class CraftVoiceRecording {
         func fail(_ code: String, _ message: String) { completion(.failure(CraftNativeActionError(code: code, message: message))) }
         guard let key = args.first as? String, UUID(uuidString: key) != nil else { fail("INVALID_ARGUMENT", "A recording owner UUID is required"); return }
         if method == "cancel" {
-            if owner == key { clear() }
+            if current?.key == key { clear() }
             completion(.success(true))
             return
         }
         if method == "stop" {
-            guard owner == key, let file else { fail("RECORDING_NOT_FOUND", "This recording is no longer available"); return }
-            recorder?.stop()
-            recorder = nil
-            try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
-            guard let audio = try? AVAudioFile(forReading: file), audio.length > 0 else { clear(); fail("EMPTY_RECORDING", "The recording was empty"); return }
-            let duration = Double(audio.length) / audio.processingFormat.sampleRate
-            completion(.success(CraftNativeFiles.describe(file, type: "audio/mp4", extra: ["durationSeconds": duration])))
+            guard let session = current, session.key == key, let file = session.file else { fail("RECORDING_NOT_FOUND", "This recording is no longer available"); return }
+            audioQueue.async {
+                guard !session.isCancelled else { return DispatchQueue.main.async { fail("RECORDING_CANCELLED", "Recording was cancelled") } }
+                session.recorder?.stop()
+                session.recorder = nil
+                self.deactivate()
+                let result: Result<Any, CraftNativeActionError>
+                if let audio = try? AVAudioFile(forReading: file), audio.length > 0 {
+                    let duration = Double(audio.length) / audio.processingFormat.sampleRate
+                    result = .success(CraftNativeFiles.describe(file, type: "audio/mp4", extra: ["durationSeconds": duration]))
+                } else {
+                    result = .failure(CraftNativeActionError(code: "EMPTY_RECORDING", message: "The recording was empty"))
+                }
+                DispatchQueue.main.async {
+                    guard self.current === session, isActive(), !session.isCancelled else {
+                        if self.current === session { self.clear() }
+                        fail("RECORDING_CANCELLED", "Recording was cancelled")
+                        return
+                    }
+                    if case .failure = result { self.clear() }
+                    completion(result)
+                }
+            }
             return
         }
         guard method == "start" else { fail("UNKNOWN_ACTION", "Unknown voice recording action"); return }
         guard isActive() else { fail("RECORDING_CANCELLED", "The requesting screen has closed"); return }
-        guard owner == nil else { fail("RECORDING_BUSY", "Another microphone session is still active"); return }
+        guard current == nil else { fail("RECORDING_BUSY", "Another microphone session is still active"); return }
         let options = args.count > 1 ? args[1] as? [String: Any] ?? [:] : [:]
         let seconds = (options["maxSeconds"] as? NSNumber)?.doubleValue ?? 300
         guard seconds.isFinite, seconds >= 1, seconds <= 300 else { fail("INVALID_ARGUMENT", "Recordings are limited to five minutes"); return }
-        owner = key
-        AVAudioSession.sharedInstance().requestRecordPermission { allowed in
+        let session = Session(key: key, completion: completion)
+        current = session
+        permission { allowed in
             DispatchQueue.main.async {
-                guard self.owner == key, isActive() else { if self.owner == key { self.clear() }; fail("RECORDING_CANCELLED", "Recording was cancelled"); return }
-                guard allowed else { self.clear(); fail("PERMISSION_DENIED", "Microphone permission was refused"); return }
-                do {
-                    let session = AVAudioSession.sharedInstance()
-                    try session.setCategory(.record, mode: .measurement)
-                    try session.setActive(true)
-                    let file = try CraftNativeFiles.newFile(named: "voice-feedback.m4a")
-                    self.file = file
-                    let recorder = try AVAudioRecorder(url: file, settings: [AVFormatIDKey: kAudioFormatMPEG4AAC, AVSampleRateKey: 16000, AVNumberOfChannelsKey: 1, AVEncoderBitRateKey: 32000])
-                    self.recorder = recorder
-                    guard recorder.record(forDuration: max(0.5, seconds - 0.25)) else { throw CraftNativeActionError(code: "RECORDING_FAILED", message: "The microphone could not start") }
-                    completion(.success(true))
+                guard self.current === session, isActive() else {
+                    if self.current === session { self.clear() }
+                    session.finish(.failure(CraftNativeActionError(code: "RECORDING_CANCELLED", message: "Recording was cancelled")))
+                    return
+                }
+                guard allowed else { self.clear(CraftNativeActionError(code: "PERMISSION_DENIED", message: "Microphone permission was refused")); return }
+                do { session.file = try Self.newRecordingFile() }
+                catch { self.clear(CraftNativeActionError(code: "RECORDING_FAILED", message: "The recording file could not be created")); return }
+                guard let file = session.file else { return }
+                let deadline = DispatchWorkItem { [weak host = self] in
+                    guard let host, host.current === session else { return }
+                    host.clear(CraftNativeActionError(code: "RECORDING_TIMEOUT", message: "The microphone took too long to start. Please try again."))
+                }
+                session.deadline = deadline
+                DispatchQueue.main.asyncAfter(deadline: .now() + self.startupTimeout, execute: deadline)
+                self.audioQueue.async {
+                    do {
+                        guard !session.isCancelled else { return }
+                        session.recorder = try self.makeRecorder(file)
+                        guard !session.isCancelled else { self.erase(session); return }
+                        guard session.recorder?.record(forDuration: max(0.5, seconds - 0.25)) == true else {
+                            throw CraftNativeActionError(code: "RECORDING_FAILED", message: "The microphone could not start")
+                        }
+                        guard !session.isCancelled else { self.erase(session); return }
+                        DispatchQueue.main.async {
+                            guard self.current === session, isActive() else {
+                                if self.current === session { self.clear() }
+                                return
+                            }
+                            session.finish(.success(true))
+                        }
+                    }
+                    catch {
+                        DispatchQueue.main.async {
+                            if self.current === session { self.clear(CraftNativeActionError(code: "RECORDING_FAILED", message: "The microphone could not start")) }
+                        }
+                    }
                 }
-                catch { self.clear(); fail("RECORDING_FAILED", "The microphone could not start") }
             }
         }
     }

package/dist/ios/templates/testing/DriverTests.swift.template

@@ -64,7 +64,10 @@ final class DriverTests: XCTestCase {
     func get(_ path: String, timeout: Double = 15) -> Data? {
         var result: Data?
         let done = expectation(description: path)
-        URLSession.shared.dataTask(with: URL(string: control + path)!) { data, _, _ in result = data; done.fulfill() }.resume()
+        URLSession.shared.dataTask(with: URL(string: control + path)!) { data, response, error in
+            if error == nil, let response = response as? HTTPURLResponse, (200..<300).contains(response.statusCode) { result = data }
+            done.fulfill()
+        }.resume()
         wait(for: [done], timeout: timeout)
         return result
     }
@@ -332,7 +335,10 @@ final class DriverTests: XCTestCase {
         case "net": _ = get("/\(arg)"); note("net \(arg)")
         case "delay": _ = get("/delay?ms=\(arg)"); note("delay \(arg)ms")
         case "exec":
-            let out = get("/exec?name=\(arg)", timeout: 180).flatMap { String(data: $0, encoding: .utf8) } ?? "no answer"
+            guard let data = get("/exec?name=\(arg)", timeout: 180), let out = String(data: data, encoding: .utf8) else {
+                check(false, "exec \(arg): hook failed or returned no successful response")
+                return
+            }
             note("exec \(arg): \(out.trimmingCharacters(in: .whitespacesAndNewlines))")
         case "openurl":
             if let url = URL(string: arg) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.341",
+  "version": "0.0.345",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",