@craft-native/ios 0.0.319 → 0.0.329

package/dist/cli.js

@@ -6,6 +6,7 @@ import { parseArgs } from "util";
 import { resolve as resolve2 } from "path";
 
 // src/index.ts
+import { gzipSync } from "zlib";
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync as readdirSync2, rmSync, statSync, writeFileSync } from "fs";
 import { dirname as dirname2, extname, join as join3, resolve, sep as sep2 } from "path";
 var {$ } = globalThis.Bun;
@@ -117,6 +118,21 @@ import { dirname, join as join2 } from "path";
 var templates = join2(dirname(import.meta.dir), "templates/testing");
 
 // src/index.ts
+function compressNativeSources(target) {
+  if (statSync(target).isDirectory()) {
+    for (const entry of readdirSync2(target))
+      compressNativeSources(join3(target, entry));
+    return;
+  }
+  if (!/\.(?:js|json)$/.test(target))
+    return;
+  const bytes = readFileSync(target);
+  if (bytes.length < 1024 || bytes[0] === 31 && bytes[1] === 139)
+    return;
+  const packed = gzipSync(bytes, { level: 9 });
+  if (packed.length < bytes.length)
+    writeFileSync(target, packed);
+}
 function syncNativeFonts(fonts, output) {
   const destination = join3(output, "NativeFonts");
   const names = new Set;
@@ -315,11 +331,13 @@ function installNativeBundle(source, output) {
       rmSync(routes, { recursive: true, force: true });
       cpSync(source, routes, { recursive: true });
     }
+    compressNativeSources(routes);
     rmSync(single, { force: true });
     return;
   }
   if (resolve(source) !== resolve(single))
     cpSync(source, single);
+  compressNativeSources(single);
   rmSync(routes, { recursive: true, force: true });
 }
 function hasInstalledNativeBundle(output) {
@@ -1010,6 +1028,7 @@ function writeShell(output, config) {
   cpSync(join3(TEMPLATES_DIR, "CraftNativeUI.swift"), join3(output, "Sources", "CraftNativeUI.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftNativeServices.swift"), join3(output, "Sources", "CraftNativeServices.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftNativeFiles.swift"), join3(output, "Sources", "CraftNativeFiles.swift"));
+  cpSync(join3(TEMPLATES_DIR, "CraftVoiceRecording.swift"), join3(output, "Sources", "CraftVoiceRecording.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftWebAudio.swift"), join3(output, "Sources", "CraftWebAudio.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHybrid.swift"), join3(output, "Sources", "CraftHybrid.swift"));
   writeFileSync(join3(output, "Sources", "CraftCrashReporter.swift"), readFileSync(join3(TEMPLATES_DIR, "CraftCrashReporter.swift"), "utf-8").replace(/\{\{CRAFT_VERSION\}\}/g, CRAFT_VERSION));

package/dist/index.d.ts

@@ -1,8 +1,5 @@
-/**
- * Craft iOS Builder
- *
- * Generates native iOS apps from web content using WKWebView.
- */
+/** Store large native source assets compressed; the host decodes each once on demand. */
+export declare function compressNativeSources(target: string): void;
 import { type CraftAppShortcut } from './app-shortcuts.js';
 /** Package custom fonts and their licenses; removed fonts cannot linger in the app. */
 export declare function syncNativeFonts(fonts: CraftConfig['nativeFonts'], output: string): string[];

package/dist/index.js

@@ -1,5 +1,6 @@
 // @bun
 // src/index.ts
+import { gzipSync } from "zlib";
 import { cpSync, existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname2, extname, join as join3, resolve, sep as sep2 } from "path";
 var {$ } = globalThis.Bun;
@@ -306,6 +307,21 @@ function createNativeMutationValidator() {
 }
 
 // src/index.ts
+function compressNativeSources(target) {
+  if (statSync(target).isDirectory()) {
+    for (const entry of readdirSync2(target))
+      compressNativeSources(join3(target, entry));
+    return;
+  }
+  if (!/\.(?:js|json)$/.test(target))
+    return;
+  const bytes = readFileSync2(target);
+  if (bytes.length < 1024 || bytes[0] === 31 && bytes[1] === 139)
+    return;
+  const packed = gzipSync(bytes, { level: 9 });
+  if (packed.length < bytes.length)
+    writeFileSync2(target, packed);
+}
 function syncNativeFonts(fonts, output) {
   const destination = join3(output, "NativeFonts");
   const names = new Set;
@@ -507,11 +523,13 @@ function installNativeBundle(source, output) {
       rmSync2(routes, { recursive: true, force: true });
       cpSync(source, routes, { recursive: true });
     }
+    compressNativeSources(routes);
     rmSync2(single, { force: true });
     return;
   }
   if (resolve(source) !== resolve(single))
     cpSync(source, single);
+  compressNativeSources(single);
   rmSync2(routes, { recursive: true, force: true });
 }
 function hasInstalledNativeBundle(output) {
@@ -1215,6 +1233,7 @@ function writeShell(output, config) {
   cpSync(join3(TEMPLATES_DIR, "CraftNativeUI.swift"), join3(output, "Sources", "CraftNativeUI.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftNativeServices.swift"), join3(output, "Sources", "CraftNativeServices.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftNativeFiles.swift"), join3(output, "Sources", "CraftNativeFiles.swift"));
+  cpSync(join3(TEMPLATES_DIR, "CraftVoiceRecording.swift"), join3(output, "Sources", "CraftVoiceRecording.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftWebAudio.swift"), join3(output, "Sources", "CraftWebAudio.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHybrid.swift"), join3(output, "Sources", "CraftHybrid.swift"));
   writeFileSync2(join3(output, "Sources", "CraftCrashReporter.swift"), readFileSync2(join3(TEMPLATES_DIR, "CraftCrashReporter.swift"), "utf-8").replace(/\{\{CRAFT_VERSION\}\}/g, CRAFT_VERSION));
@@ -1585,6 +1604,7 @@ export {
   backgroundRefreshIdentifier,
   bootSimulator,
   build,
+  compressNativeSources,
   createNativeMutationValidator,
   findApplicationSwiftSources,
   hasNativeRoutes,

package/package.json

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

package/templates/CraftActivityAttributes.swift

@@ -2,20 +2,27 @@ import ActivityKit
 
 @available(iOS 16.1, *)
 struct CraftActivityAttributes: ActivityAttributes {
+    struct Transition: Codable, Hashable {
+        let at: Double
+        let detail: String
+        let duration: Double?
+    }
     struct ContentState: Codable, Hashable {
-        let status: String
+        var status: String
         let distanceMeters: Double
         let durationSeconds: Double
-        let progress: Double
+        var progress: Double
         var staleStatus: String?
         var detail: String?
         /// Epoch milliseconds. SwiftUI advances these timers without app updates.
+        var sessionStartedAt: Double?
         var timerStartedAt: Double?
         var timerEndsAt: Double?
         var paused: Bool?
         var remainingSeconds: Double?
         var heartRate: Double?
         var showsDistance: Bool?
+
     }
 
     let activityId: String
@@ -24,3 +31,23 @@ struct CraftActivityAttributes: ActivityAttributes {
     var deepLink: String?
     var tint: String?
 }
+
+
+/// The whole plan stays in the app process. Only ContentState crosses
+/// ActivityKit's 4 KB payload boundary, regardless of the workout's length.
+@available(iOS 16.1, *)
+struct CraftActivityTimeline {
+    var pending: [CraftActivityAttributes.Transition]
+
+    mutating func advance(_ state: inout CraftActivityAttributes.ContentState, to milliseconds: Double) {
+        let due = pending.prefix { $0.at <= milliseconds }
+        guard let next = due.last else { return }
+        pending.removeFirst(due.count)
+        state.detail = next.detail
+        state.timerStartedAt = next.duration == nil ? state.sessionStartedAt : next.at
+        state.timerEndsAt = next.duration.map { next.at + $0 * 1000 }
+        state.remainingSeconds = next.duration.map { max(0, $0 - (milliseconds - next.at) / 1000) }
+        state.progress = 0
+        if next.duration == 0 { state.status = next.detail; state.paused = true; state.progress = 1 }
+    }
+}

package/templates/CraftApp.swift

@@ -8281,7 +8281,7 @@ struct CraftWebView: UIViewRepresentable {
         // MARK: - Live Activities
         private func liveActivity(method: String, args: [Any], callbackId: String?) {
             let token = armDeadline(Coordinator.liveActivityDeadline, callbackId: callbackId, error: "Live Activity request timed out")
-            CraftLiveActivities.perform(method: method, args: args, enabled: config.enableLiveActivities, appName: config.appName) { [weak self] result in
+            CraftLiveActivities.perform(method: method, args: args, enabled: config.enableLiveActivities, appName: config.appName, healthEnabled: config.enableHealthKit) { [weak self] result in
                 guard let self, self.claimDeadline(token) else { return }
                 switch result {
                 case .success(let value): self.resolveCallback(callbackId, result: value)

package/templates/CraftHealth.swift

@@ -1011,6 +1011,17 @@ final class CraftHealth {
         }
     }
 
+    /// Only the Live Activity that started this runtime can release it. HQ
+    /// persists its own final result, so collecting here must not duplicate it.
+    func discardActivityWorkout(expectedID: String) {
+        guard #available(iOS 26.0, *), liveWorkoutID == expectedID,
+              let session = liveWorkoutSession as? HKWorkoutSession,
+              let builder = liveWorkoutBuilder as? HKLiveWorkoutBuilder else { return }
+        session.end()
+        builder.discardWorkout()
+        clearLiveWorkout()
+    }
+
     private func clearLiveWorkout() {
         liveWorkoutSession = nil
         liveWorkoutBuilder = nil
@@ -1052,6 +1063,9 @@ final class CraftHealth {
         case "elliptical": return .elliptical
         case "strength": return .traditionalStrengthTraining
         case "hiit": return .highIntensityIntervalTraining
+        case "flexibility": return .flexibility
+        case "yoga": return .yoga
+        case "other": return .other
         default: return nil
         }
     }

package/templates/CraftLiveActivities.swift

@@ -1,10 +1,16 @@
 import ActivityKit
 import Foundation
+import HealthKit
 
 /// ActivityKit belongs to the process, not a web view or a retained STX screen.
 /// A stable application activityId reattaches after a screen or app restart.
 enum CraftLiveActivities {
-    static func perform(method: String, args: [Any], enabled: Bool, appName: String, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+    private static var scheduled: [String: Task<Void, Never>] = [:]
+    private static var watching: [String: Task<Void, Never>] = [:]
+    private static var workoutOwner: (key: String, id: String)?
+    private static var startingWorkout: String?
+
+    static func perform(method: String, args: [Any], enabled: Bool, appName: String, healthEnabled: Bool = false, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
         guard enabled else {
             if method == "isAvailable" { completion(.success(false)); return }
             completion(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Live Activities are disabled")))
@@ -33,11 +39,17 @@ enum CraftLiveActivities {
                     let state = content(body)
                     if let existing = activities.first(where: { $0.attributes.activityId == key }) {
                         await existing.update(ActivityContent(state: state, staleDate: staleDate(body)))
+                        watch(existing)
+                        schedule(existing, plan: plan(body))
+                        startWorkout(existing, body: body, enabled: healthEnabled)
                         completion(.success(["id": existing.id]))
                         return
                     }
                     let attributes = CraftActivityAttributes(activityId: key, title: String(title.prefix(160)), symbol: body["symbol"] as? String, deepLink: safeURL(body["deepLink"] as? String), tint: body["tint"] as? String)
                     let activity = try Activity.request(attributes: attributes, content: ActivityContent(state: state, staleDate: staleDate(body)), pushType: nil)
+                    watch(activity)
+                    schedule(activity, plan: plan(body))
+                    startWorkout(activity, body: body, enabled: healthEnabled)
                     completion(.success(["id": activity.id]))
                 case "update", "end":
                     let id = args.first as? String
@@ -47,12 +59,21 @@ enum CraftLiveActivities {
                         throw CraftNativeActionError(code: "NOT_FOUND", message: "No matching Live Activity is running")
                     }
                     let body = args.count > 1 ? args[1] as? [String: Any] ?? [:] : [:]
-                    let state = content(body, previous: activity.content.state)
+                    let previous = activity.content.state
+                    let state = content(body, previous: previous)
                     if method == "end" {
+                        watching.removeValue(forKey: activity.id)?.cancel()
+                        scheduled.removeValue(forKey: activity.id)?.cancel()
+                        stopWorkout(activity.attributes.activityId)
                         await activity.end(ActivityContent(state: state, staleDate: nil), dismissalPolicy: .immediate)
                         completion(.success(["ended": true]))
                     } else {
                         await activity.update(ActivityContent(state: state, staleDate: staleDate(body)))
+                        schedule(activity, plan: plan(body))
+                        if let owner = workoutOwner, owner.key == activity.attributes.activityId, previous.paused != state.paused {
+                            if state.paused == true { CraftHealth.shared.pauseWorkout { _ in } }
+                            else { CraftHealth.shared.resumeWorkout { _ in } }
+                        }
                         completion(.success(["updated": true]))
                     }
                 default: throw CraftNativeActionError(code: "UNKNOWN_ACTION", message: "Unsupported Live Activities method")
@@ -62,6 +83,88 @@ enum CraftLiveActivities {
         }
     }
 
+    /// Dismissing a Live Activity must release its own background workout
+    /// runtime as well, even though it no longer appears in the active list.
+    @available(iOS 16.2, *)
+    @MainActor private static func watch(_ activity: Activity<CraftActivityAttributes>) {
+        guard watching[activity.id] == nil else { return }
+        watching[activity.id] = Task { @MainActor in
+            for await state in activity.activityStateUpdates {
+                if Task.isCancelled { return }
+                if state == .ended || state == .dismissed {
+                    scheduled.removeValue(forKey: activity.id)?.cancel()
+                    stopWorkout(activity.attributes.activityId)
+                    watching.removeValue(forKey: activity.id)
+                    return
+                }
+            }
+        }
+    }
+
+    /// The real HealthKit workout owns background execution on iOS 26. It
+    /// collects while training; the caller's existing save path writes the
+    /// final workout once. Never stop an unrelated HealthKit session.
+    @available(iOS 16.2, *)
+    @MainActor private static func startWorkout(_ activity: Activity<CraftActivityAttributes>, body: [String: Any], enabled: Bool) {
+        guard enabled, #available(iOS 26.0, *), let type = body["workoutType"] as? String,
+              workoutOwner == nil, startingWorkout == nil,
+              HKHealthStore().authorizationStatus(for: .workoutType()) == .sharingAuthorized else { return }
+        let key = activity.attributes.activityId
+        startingWorkout = key
+        CraftHealth.shared.startWorkout(body: ["type": type]) { result in
+            Task { @MainActor in
+                startingWorkout = nil
+                guard case .success(let value) = result, let value = value as? [String: Any], let id = value["id"] as? String else { return }
+                guard activity.activityState == .active || activity.activityState == .stale else {
+                    CraftHealth.shared.discardActivityWorkout(expectedID: id)
+                    return
+                }
+                workoutOwner = (key, id)
+                if activity.content.state.paused == true { CraftHealth.shared.pauseWorkout { _ in } }
+            }
+        }
+    }
+
+    @MainActor private static func stopWorkout(_ key: String) {
+        guard let owner = workoutOwner, owner.key == key else { return }
+        workoutOwner = nil
+        CraftHealth.shared.discardActivityWorkout(expectedID: owner.id)
+    }
+
+    /// Step boundaries, independently of a retained screen or JS timer.
+    /// HealthKit, GPS and BLE use their documented background execution;
+    /// without permission iOS may suspend updates until the next app wake.
+    @available(iOS 16.2, *)
+    @MainActor private static func schedule(_ activity: Activity<CraftActivityAttributes>, plan: [CraftActivityAttributes.Transition]) {
+        scheduled.removeValue(forKey: activity.id)?.cancel()
+        guard activity.content.state.paused != true, !plan.isEmpty else { return }
+        scheduled[activity.id] = Task { @MainActor in
+            var timeline = CraftActivityTimeline(pending: plan)
+            while !Task.isCancelled, let next = timeline.pending.first {
+                let delay = max(0, next.at / 1000 - Date().timeIntervalSince1970)
+                do { try await Task.sleep(nanoseconds: UInt64(min(delay, 86400) * 1_000_000_000)) }
+                catch { return }
+                guard !Task.isCancelled, activity.activityState == .active || activity.activityState == .stale else { return }
+                var state = activity.content.state
+                timeline.advance(&state, to: Date().timeIntervalSince1970 * 1000)
+                if state.paused == true { stopWorkout(activity.attributes.activityId) }
+                await activity.update(ActivityContent(state: state, staleDate: timeline.pending.last.map { Date(timeIntervalSince1970: $0.at / 1000 + ($0.duration ?? 8 * 3600) + 1) }))
+            }
+            scheduled.removeValue(forKey: activity.id)
+        }
+    }
+
+    @available(iOS 16.1, *)
+    private static func plan(_ body: [String: Any]) -> [CraftActivityAttributes.Transition] {
+        let steps = (body["transitions"] as? [[String: Any]] ?? []).prefix(1000).compactMap { item -> CraftActivityAttributes.Transition? in
+            guard let at = finite(item, "at"), let detail = item["detail"] as? String else { return nil }
+            return .init(at: at, detail: String(detail.prefix(96)), duration: finite(item, "duration"))
+        }.sorted { $0.at < $1.at }
+        // An untimed exercise waits for the athlete. Never infer its completion.
+        if let stop = steps.firstIndex(where: { $0.duration == nil || $0.duration == 0 }) { return Array(steps.prefix(stop + 1)) }
+        return steps
+    }
+
     private static func safeURL(_ value: String?) -> String? {
         guard let value, let url = URL(string: value), let scheme = url.scheme?.lowercased(),
               !["javascript", "data", "file"].contains(scheme) else { return nil }
@@ -87,6 +190,7 @@ enum CraftLiveActivities {
             progress: min(finite(body, "progress", previous?.progress) ?? 0, 1),
             staleStatus: body["staleStatus"] as? String ?? previous?.staleStatus,
             detail: body["detail"] as? String ?? previous?.detail,
+            sessionStartedAt: finite(body, "sessionStartedAt", previous?.sessionStartedAt),
             timerStartedAt: finite(body, "timerStartedAt", previous?.timerStartedAt),
             timerEndsAt: finite(body, "timerEndsAt", previous?.timerEndsAt),
             paused: body["paused"] as? Bool ?? previous?.paused,

package/templates/CraftLiveActivityWidget.swift.template

@@ -61,7 +61,7 @@ struct CraftLiveActivityWidget: Widget {
             } compactLeading: {
                 activityIcon(context)
             } compactTrailing: {
-                timer(context).monospacedDigit().frame(maxWidth: 64, alignment: .trailing)
+                timer(context).monospacedDigit().frame(width: 64, alignment: .trailing)
             } minimal: {
                 activityIcon(context)
             }

package/templates/CraftNativeActions.swift

@@ -95,6 +95,7 @@ enum CraftNativeActions {
         // which the native Video element plays in place of the address.
         values.append("media")
         if config.enableCamera { values.append("camera") }
+        if config.enableAudioRecording { values.append("audioRecording") }
         // craft.crashReporter: the app's crash and error reporter (bughq).
         if config.crashReporting?.key.isEmpty == false { values.append("crashReporter") }
         return values
@@ -373,7 +374,7 @@ enum CraftNativeActions {
             }
             return
         case ("LiveActivities", _):
-            CraftLiveActivities.perform(method: method, args: args, enabled: config.enableLiveActivities, appName: config.appName) { result in
+            CraftLiveActivities.perform(method: method, args: args, enabled: config.enableLiveActivities, appName: config.appName, healthEnabled: config.enableHealthKit) { result in
                 complete(requestToken, result, completion)
             }
             return
@@ -555,6 +556,13 @@ enum CraftNativeActions {
                 CraftNativeShare.share(options) { complete(requestToken, $0, completion) }
             }
             return
+        case ("AudioRecording", _):
+            guard config.enableAudioRecording else {
+                complete(requestToken, failure("CAPABILITY_DISABLED", "Audio recording is disabled"), completion)
+                return
+            }
+            CraftVoiceRecording.shared.perform(method: method, args: args) { result in complete(requestToken, result, completion) }
+            return
         case ("Speech", "speak"):
             // Settles when the words have been said (true) or were cut off
             // (false), as the page's `craft.speech.speak` does.

package/templates/CraftNativeScreen.swift

@@ -1,4 +1,5 @@
 import Foundation
+import zlib
 import CoreFoundation
 import ImageIO
 import AVFoundation
@@ -5550,10 +5551,36 @@ enum CraftNativeBundle {
         return read(url)
     }
 
+    /// gzip assets are immutable, decoded lazily and held in the same bounded cache.
+    private static func unpack(_ bytes: Data) -> Data? {
+        guard bytes.starts(with: [0x1f, 0x8b]) else { return bytes }
+        return bytes.withUnsafeBytes { raw -> Data? in
+            var stream = z_stream()
+            guard inflateInit2_(&stream, 15 + 32, ZLIB_VERSION, Int32(MemoryLayout<z_stream>.size)) == Z_OK else { return nil }
+            defer { inflateEnd(&stream) }
+            stream.next_in = UnsafeMutablePointer<Bytef>(mutating: raw.bindMemory(to: Bytef.self).baseAddress)
+            stream.avail_in = uInt(bytes.count)
+            var result = Data()
+            var chunk = [UInt8](repeating: 0, count: 32768)
+            var status = Z_OK
+            repeat {
+                status = chunk.withUnsafeMutableBytes { output in
+                    stream.next_out = output.bindMemory(to: Bytef.self).baseAddress
+                    stream.avail_out = uInt(output.count)
+                    return inflate(&stream, Z_NO_FLUSH)
+                }
+                guard status == Z_OK || status == Z_STREAM_END else { return nil }
+                result.append(contentsOf: chunk.prefix(chunk.count - Int(stream.avail_out)))
+                guard result.count <= 64 << 20 else { return nil }
+            } while status != Z_STREAM_END
+            return result
+        }
+    }
+
     private static func read(_ url: URL) -> (source: String, url: URL)? {
         let key = url.path as NSString
         if let cached = sources.object(forKey: key) { return (cached as String, url) }
-        guard let text = try? String(contentsOf: url, encoding: .utf8) else { return nil }
+        guard let bytes = try? Data(contentsOf: url), let decoded = unpack(bytes), let text = String(data: decoded, encoding: .utf8) else { return nil }
         sources.setObject(text as NSString, forKey: key, cost: text.utf8.count)
         return (text, url)
     }
@@ -5700,6 +5727,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// itself to be in front and acts on it: a sign-in guard on a prepared
     /// Record tab pushed Login over the Feed at launch.
     private var reportedVisible: Bool?
+    private var voiceRecordingOwner: String?
     private let capabilityScope = UUID().uuidString
     private var pendingCapabilityRequests = Set<String>()
     private var pendingCapabilityDeadlines: [String: DispatchWorkItem] = [:]
@@ -5970,6 +5998,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func disposeRuntime() {
         guard !runtimeDisposed else { return }
         runtimeDisposed = true
+        if let owner = voiceRecordingOwner {
+            voiceRecordingOwner = nil
+            CraftVoiceRecording.shared.perform(method: "cancel", args: [owner]) { _ in }
+        }
         frameWanted = false
         CraftNativeFrameClock.shared.cancel(self)
         disposeRenderedTree()
@@ -7674,6 +7706,24 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         let id = args.first as? String ?? ""
         switch (module, method) {
+        case ("AudioRecording", _):
+            guard config.enableAudioRecording else {
+                reply(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "Audio recording is disabled")))
+                return true
+            }
+            if method == "start" {
+                guard voiceRecordingOwner == nil else {
+                    reply(.failure(CraftNativeActionError(code: "RECORDING_BUSY", message: "This screen already owns a recording")))
+                    return true
+                }
+                voiceRecordingOwner = id
+            }
+            if method == "cancel", voiceRecordingOwner == id { voiceRecordingOwner = nil }
+            CraftVoiceRecording.shared.perform(method: method, args: args, isActive: { [weak self] in self?.runtimeDisposed == false }) { [weak self] result in
+                if case .failure = result, self?.voiceRecordingOwner == id { self?.voiceRecordingOwner = nil }
+                reply(result)
+            }
+            return true
         case ("View", "focus"):
             let options = args.first as? [String: Any]
             let nodeId = options?["nodeId"] as? String ?? (args.first as? String) ?? ""

package/templates/CraftVoiceRecording.swift

@@ -0,0 +1,75 @@
+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.
+final class CraftVoiceRecording {
+    static let shared = CraftVoiceRecording()
+    private var owner: String?
+    private var recorder: AVAudioRecorder?
+    private var file: URL?
+    private var backgroundObserver: NSObjectProtocol?
+
+    private init() {
+        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)
+    }
+
+    func perform(method: String, args: [Any], isActive: @escaping () -> Bool = { true }, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        DispatchQueue.main.async { self.performOnMain(method: method, args: args, isActive: isActive, completion: completion) }
+    }
+
+    private func performOnMain(method: String, args: [Any], isActive: @escaping () -> Bool, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        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() }
+            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])))
+            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 }
+        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
+            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))
+                }
+                catch { self.clear(); fail("RECORDING_FAILED", "The microphone could not start") }
+            }
+        }
+    }
+}

package/templates/project.yml.template

@@ -14,6 +14,12 @@ settings:
       CRAFT_APNS_ENVIRONMENT: development
     release:
       CRAFT_APNS_ENVIRONMENT: production
+      SWIFT_OPTIMIZATION_LEVEL: "-O"
+      SWIFT_COMPILATION_MODE: wholemodule
+      GCC_OPTIMIZATION_LEVEL: s
+      DEAD_CODE_STRIPPING: YES
+      STRIP_INSTALLED_PRODUCT: YES
+      COPY_PHASE_STRIP: YES
 targets:
   {{APP_NAME}}:
     type: application