craft-native 0.0.319 → 0.0.329

package/dist/index.cjs

@@ -375,7 +375,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.319";
+var version = "0.0.329";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -677,6 +677,12 @@ async function packageMacOS(config, outDir) {
   } catch (error) {
     return [{ success: false, platform: "macos", format: "app", error: error.message }];
   }
+  if (opts.notarize && !opts.appStore) {
+    const notarized = await notarizeIfRequested(opts, appBundlePath, "app");
+    results.push(...notarized);
+    if (notarized.some((result) => !result.success))
+      return results;
+  }
   results.push({ success: true, platform: "macos", format: "app", outputPath: appBundlePath });
   if (opts.dmg !== false) {
     const outputPath = import_path.join(outDir, `${name}-${version}.dmg`);
@@ -725,24 +731,36 @@ async function notarizeIfRequested(opts, artifactPath, format) {
       error: "Notarization requires a keychain profile, API key, or Apple ID/password/team ID"
     }];
   }
-  const submitted = await runTool("xcrun", notarytoolArguments({
-    artifactPath,
-    appleId: opts.appleId,
-    applePassword: opts.applePassword,
-    teamId: opts.teamId,
-    keychainProfile: opts.notaryKeychainProfile,
-    apiKey: opts.notaryApiKey
-  }));
-  if (!submitted.success)
-    return [{ success: false, platform: "macos", format: `${format} (notarize)`, error: submitted.error }];
-  const stapled = await runTool("xcrun", ["stapler", "staple", artifactPath]);
-  return [{
-    success: stapled.success,
-    platform: "macos",
-    format: `${format} (notarize)`,
-    outputPath: stapled.success ? artifactPath : undefined,
-    error: stapled.success ? undefined : stapled.error
-  }];
+  const scratch = format === "app" ? createTempDir("craft-notarize-") : undefined;
+  try {
+    const submission = scratch ? import_path.join(scratch, "app.zip") : artifactPath;
+    if (scratch) {
+      const zipped = await runTool("ditto", ["-c", "-k", "--keepParent", artifactPath, submission]);
+      if (!zipped.success)
+        return [{ success: false, platform: "macos", format: `${format} (notarize)`, error: zipped.error }];
+    }
+    const submitted = await runTool("xcrun", notarytoolArguments({
+      artifactPath: submission,
+      appleId: opts.appleId,
+      applePassword: opts.applePassword,
+      teamId: opts.teamId,
+      keychainProfile: opts.notaryKeychainProfile,
+      apiKey: opts.notaryApiKey
+    }));
+    if (!submitted.success)
+      return [{ success: false, platform: "macos", format: `${format} (notarize)`, error: submitted.error }];
+    const stapled = await runTool("xcrun", ["stapler", "staple", artifactPath]);
+    return [{
+      success: stapled.success,
+      platform: "macos",
+      format: `${format} (notarize)`,
+      outputPath: stapled.success ? artifactPath : undefined,
+      error: stapled.success ? undefined : stapled.error
+    }];
+  } finally {
+    if (scratch)
+      removeTempDir(scratch);
+  }
 }
 async function packageWindows(config, outDir) {
   const results = [];
@@ -10910,6 +10928,9 @@ class AutoUpdater extends import_events3.EventEmitter {
         if (this.isNewerVersion(this.cachedManifest.version, this.config.currentVersion)) {
           this.updateInfo = this.cachedManifest;
           this.emit("update-available", this.cachedManifest);
+          if (this.config.autoDownload) {
+            await this.downloadUpdate();
+          }
           return this.cachedManifest;
         }
         this.emit("update-not-available");

package/dist/index.js

@@ -117,7 +117,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.319";
+var version = "0.0.329";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -433,6 +433,12 @@ async function packageMacOS(config, outDir) {
   } catch (error) {
     return [{ success: false, platform: "macos", format: "app", error: error.message }];
   }
+  if (opts.notarize && !opts.appStore) {
+    const notarized = await notarizeIfRequested(opts, appBundlePath, "app");
+    results.push(...notarized);
+    if (notarized.some((result) => !result.success))
+      return results;
+  }
   results.push({ success: true, platform: "macos", format: "app", outputPath: appBundlePath });
   if (opts.dmg !== false) {
     const outputPath = join2(outDir, `${name}-${version}.dmg`);
@@ -481,24 +487,36 @@ async function notarizeIfRequested(opts, artifactPath, format) {
       error: "Notarization requires a keychain profile, API key, or Apple ID/password/team ID"
     }];
   }
-  const submitted = await runTool("xcrun", notarytoolArguments({
-    artifactPath,
-    appleId: opts.appleId,
-    applePassword: opts.applePassword,
-    teamId: opts.teamId,
-    keychainProfile: opts.notaryKeychainProfile,
-    apiKey: opts.notaryApiKey
-  }));
-  if (!submitted.success)
-    return [{ success: false, platform: "macos", format: `${format} (notarize)`, error: submitted.error }];
-  const stapled = await runTool("xcrun", ["stapler", "staple", artifactPath]);
-  return [{
-    success: stapled.success,
-    platform: "macos",
-    format: `${format} (notarize)`,
-    outputPath: stapled.success ? artifactPath : undefined,
-    error: stapled.success ? undefined : stapled.error
-  }];
+  const scratch = format === "app" ? createTempDir("craft-notarize-") : undefined;
+  try {
+    const submission = scratch ? join2(scratch, "app.zip") : artifactPath;
+    if (scratch) {
+      const zipped = await runTool("ditto", ["-c", "-k", "--keepParent", artifactPath, submission]);
+      if (!zipped.success)
+        return [{ success: false, platform: "macos", format: `${format} (notarize)`, error: zipped.error }];
+    }
+    const submitted = await runTool("xcrun", notarytoolArguments({
+      artifactPath: submission,
+      appleId: opts.appleId,
+      applePassword: opts.applePassword,
+      teamId: opts.teamId,
+      keychainProfile: opts.notaryKeychainProfile,
+      apiKey: opts.notaryApiKey
+    }));
+    if (!submitted.success)
+      return [{ success: false, platform: "macos", format: `${format} (notarize)`, error: submitted.error }];
+    const stapled = await runTool("xcrun", ["stapler", "staple", artifactPath]);
+    return [{
+      success: stapled.success,
+      platform: "macos",
+      format: `${format} (notarize)`,
+      outputPath: stapled.success ? artifactPath : undefined,
+      error: stapled.success ? undefined : stapled.error
+    }];
+  } finally {
+    if (scratch)
+      removeTempDir(scratch);
+  }
 }
 async function packageWindows(config, outDir) {
   const results = [];
@@ -10666,6 +10684,9 @@ class AutoUpdater extends EventEmitter3 {
         if (this.isNewerVersion(this.cachedManifest.version, this.config.currentVersion)) {
           this.updateInfo = this.cachedManifest;
           this.emit("update-available", this.cachedManifest);
+          if (this.config.autoDownload) {
+            await this.downloadUpdate();
+          }
           return this.cachedManifest;
         }
         this.emit("update-not-available");

package/dist/ios/src/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/ios/src/index.js

@@ -1,5 +1,6 @@
 // @bun
 // ../ios/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() {
 }
 
 // ../ios/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/dist/ios/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/dist/ios/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/dist/ios/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/dist/ios/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/dist/ios/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/dist/ios/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/dist/ios/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) ?? ""