@craft-native/ios 0.0.304 → 0.0.328

package/README.md

@@ -1324,3 +1324,21 @@ and detents; Android sizes its native bottom panel to the selected detent
 without an extra dependency. Omitting presentationStyle keeps the existing
 full-screen overlay. A native sheet's close request still belongs to its
 owner, which sets visible to false.
+
+
+### Controlled native paging and font families
+
+A horizontal `ScrollView` with `pagingEnabled: true` and a numeric `pageIndex`
+uses viewport-sized direct children. The host advertises `nativePager` and emits
+`onPageSelected` with `{ index, count }` after initial layout, count changes and
+settled user selection. Updates to `pageIndex` select a page; removed pages clamp
+the index and resizing preserves it. Offscreen pages stay mounted but are hidden
+from native accessibility. `scrollEnabled: false` locks swiping while retaining
+controls in the selected page. Without `pageIndex`, scroll content keeps its
+ordinary intrinsic layout; this is an opt-in contract for a shared Pager.
+
+Text `fontFamily` accepts a CSS fallback list. Bundled/custom fonts take priority
+when available. `monospace`/`ui-monospace`, `serif`/`ui-serif` and
+`sans-serif`/`ui-sans-serif`/`system-ui` select platform fonts, retaining requested
+weight, italic style and system text scaling. A missing custom face falls through
+to the next family rather than silently replacing a requested mono font with sans.

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;
@@ -189,7 +190,12 @@ function serializeSimulatorSteps(steps) {
   };
   const line = (step) => {
     let arg = "";
-    if ("paths" in step) {
+    if (step.command === "holdtab") {
+      const seconds = step.seconds ?? 6;
+      if (!step.text.trim() || step.text.includes("|") || number(seconds) < 2 || seconds > 10)
+        throw new Error("holdtab needs a nonempty tab name and 2\u201310 seconds");
+      arg = `${step.text} | ${seconds}`;
+    } else if ("paths" in step) {
       if (!step.paths.length || step.paths.length > 64)
         throw new Error("Expected 1\u201364 touch paths");
       for (const path of step.paths) {
@@ -301,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;
@@ -502,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) {
@@ -1210,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));
@@ -1580,6 +1604,7 @@ export {
   backgroundRefreshIdentifier,
   bootSimulator,
   build,
+  compressNativeSources,
   createNativeMutationValidator,
   findApplicationSwiftSources,
   hasNativeRoutes,

package/dist/testing.d.ts

@@ -61,6 +61,12 @@ export type SimulatorStep = {
  | {
     command: 'touches';
     paths: TimedTouchPoint[][];
+}
+/** Standard XCTest tab hold; independent screenshots must be captured before release. */
+ | {
+    command: 'holdtab';
+    text: string;
+    seconds?: number;
 } | {
     command: 'field';
     index: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/ios",
-  "version": "0.0.304",
+  "version": "0.0.328",
   "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

@@ -766,6 +766,13 @@ final class CraftChrome: ObservableObject {
     @Published var tabAccessory: Tab?
     private weak var tabAccessoryOwner: AnyObject?
     @Published var selected: String?
+    /// The visible destination may be the accessory, independently of its owning stack.
+    @Published var visiblePath: String?
+    var accessorySelected: Bool {
+        guard let path = visiblePath, let accessory = tabAccessory?.id else { return false }
+        return path == accessory || path.hasPrefix(accessory + "/")
+    }
+    var highlightedTab: String? { accessorySelected ? nil : selected }
     let tabSwipeProgress = CraftTabSwipeProgress()
     private(set) var tabSwipePosition: CGFloat? {
         get { tabSwipeProgress.position }
@@ -1172,6 +1179,18 @@ final class CraftChromeRelay: NSObject, WKScriptMessageHandler {
 
 /// The floating tab bar: Liquid Glass on iOS 26 and later, a material capsule before.
 struct CraftTabBarView: View {
+    @Environment(\.dynamicTypeSize) private var dynamicTypeSize
+
+    var body: some View {
+        // ScaledMetric reads the environment of its owning view. Put the
+        // metrics in a child so this compact-chrome cap reaches them too.
+        CraftTabBarContent(viewerTextSize: dynamicTypeSize)
+            .dynamicTypeSize(...DynamicTypeSize.xxxLarge)
+    }
+}
+
+private struct CraftTabBarContent: View {
+    let viewerTextSize: DynamicTypeSize
     @ObservedObject private var chrome = CraftChrome.shared
     @Environment(\.accessibilityReduceMotion) private var reduceMotion
     @Environment(\.scenePhase) private var scenePhase
@@ -1183,7 +1202,7 @@ struct CraftTabBarView: View {
     @ScaledMetric(relativeTo: .caption2) private var badgeSize: CGFloat = 10
 
     var body: some View {
-        if chrome.tabBarVisible && !chrome.tabs.isEmpty {
+        if !chrome.tabs.isEmpty {
             HStack(spacing: 8) {
                 bar
                 if let accessory = chrome.tabAccessory {
@@ -1191,8 +1210,13 @@ struct CraftTabBarView: View {
                         surface {
                             Image(systemName: accessory.symbol)
                                 .font(.system(size: iconSize))
-                                .foregroundStyle(Color.primary)
+                                .foregroundStyle(chrome.accessorySelected ? selectedColor : Color.primary)
                                 .frame(width: 62, height: 62)
+                                .background {
+                                    if chrome.accessorySelected {
+                                        Circle().fill(selectedColor.opacity(0.14)).padding(4)
+                                    }
+                                }
                         }
                             .contentShape(Rectangle())
                             .overlay(alignment: .topTrailing) {
@@ -1207,9 +1231,17 @@ struct CraftTabBarView: View {
                             }
                     }
                     .buttonStyle(.plain)
+                    .accessibilityShowsLargeContentViewer {
+                        Image(systemName: accessory.symbol)
+                        Text(accessory.accessibilityLabel ?? accessory.title)
+                    }
+                    // Keep accessibility intent for the viewer; displayed
+                    // sizes come from the bounded metrics owned above.
+                    .environment(\.dynamicTypeSize, viewerTextSize)
                     .accessibilityLabel(accessory.accessibilityLabel ?? accessory.title)
                     .accessibilityValue(accessory.badge ?? "")
                     .accessibilityIdentifier("craft-tab-accessory")
+                    .accessibilityAddTraits(chrome.accessorySelected ? .isSelected : [])
                 }
             }
                 .padding(.horizontal, 16)
@@ -1219,9 +1251,14 @@ struct CraftTabBarView: View {
                         .onAppear { report(proxy) }
                         .onChange(of: proxy.frame(in: .global)) { _ in report(proxy) }
                 })
-                .transition(reduceMotion ? .opacity : .move(edge: .bottom).combined(with: .opacity))
+                // Keep the view mounted: a disappearing conditional inside a
+                // child does not reliably animate in the UIKit navigation transaction.
+                .offset(y: chrome.tabBarVisible || reduceMotion ? 0 : 120)
+                .opacity(chrome.tabBarVisible ? 1 : 0)
+                .allowsHitTesting(chrome.tabBarVisible)
+                .accessibilityHidden(!chrome.tabBarVisible)
+                .animation(.easeInOut(duration: reduceMotion ? 0.12 : 0.24), value: chrome.tabBarVisible)
                 .ignoresSafeArea(.keyboard)
-                .dynamicTypeSize(...DynamicTypeSize.xxxLarge)
         }
     }
 
@@ -1260,7 +1297,7 @@ struct CraftTabBarView: View {
     private var items: some View {
         HStack(spacing: 0) {
             ForEach(chrome.tabs) { tab in
-                let isSelected = tab.id == chrome.selected
+                let isSelected = tab.id == chrome.highlightedTab
                 Button { chrome.tap(tab) } label: {
                     VStack(spacing: 3) {
                         ZStack(alignment: .topTrailing) {
@@ -1305,6 +1342,7 @@ struct CraftTabBarView: View {
                     Image(systemName: symbol(tab.symbol, selected: isSelected))
                     Text(tab.displayTitle)
                 }
+                .environment(\.dynamicTypeSize, viewerTextSize)
                 .accessibilityIdentifier("craft-tab-\(tab.id)")
                 .accessibilityLabel(tab.accessibilityLabel ?? tab.badge.map { "\(tab.displayTitle), \($0)" } ?? tab.displayTitle)
                 .accessibilityAddTraits(isSelected ? [.isSelected, .isButton] : .isButton)
@@ -1312,7 +1350,7 @@ struct CraftTabBarView: View {
         }
         .background {
             CraftTabSelectionIndicator(
-                selected: chrome.tabs.firstIndex(where: { $0.id == chrome.selected }),
+                selected: chrome.tabs.firstIndex(where: { $0.id == chrome.highlightedTab }),
                 count: chrome.tabs.count,
                 cornerRadius: chrome.tabSelectionCornerRadius
             )
@@ -8243,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/CraftHybrid.swift

@@ -1664,6 +1664,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             (nav.topViewController as? CraftNativeScreenController)?.screenVisibilityChanged(true)
         }
         currentTab = id
+        if let top = nav.topViewController { CraftChrome.shared.visiblePath = nativePaths[ObjectIdentifier(top)] }
         for (key, other) in stacks { other.view.isHidden = key != id }
         nav.view.frame = view.bounds
         view.bringSubviewToFront(nav.view)
@@ -2042,6 +2043,9 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     func navigationController(_ navigationController: UINavigationController, willShow viewController: UIViewController, animated: Bool) {
         lastNavigation = CACurrentMediaTime()
         if animated { CraftFramePacing.shared.begin("navigation") }
+        if navigationController === visibleStack {
+            CraftChrome.shared.visiblePath = nativePaths[ObjectIdentifier(viewController)]
+        }
         // The page draws its own header, and a tab's root screen its own
         // title unless it asked for the bar; a pushed native screen gets the
         // bar and its Back.
@@ -2084,6 +2088,8 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             hybrid.pageReset(to: rootPath)
         }
         guard navigationController === visibleStack else { return }
+        // Also restore selection after a cancelled interactive pop.
+        CraftChrome.shared.visiblePath = nativePaths[ObjectIdentifier(viewController)]
         if let slot = viewController as? CraftHybridWebSlot { adoptWeb(into: slot) } else { parkWeb() }
     }
 

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

@@ -43,6 +43,7 @@ enum CraftNativeActions {
         // `speech`, `audio` (background sound) and `eventStream` (a fetch read
         // as it arrives) need nothing the app has to declare.
         var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking", "badge", "animation", "viewFocus", "viewMeasure", "viewReparent", "viewNonModalPresentation", "nativePlatformControls"]
+        values.append("nativePager")
         values.append("storageCompareAndSet")
         values.append("storageSetIfAbsent")
         values.append("viewScroll")
@@ -94,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
@@ -372,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
@@ -554,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
@@ -2744,6 +2745,7 @@ final class CraftNativeCelebration {
 }
 
 private class CraftNativeFlowView: UIStackView {
+    var pageViewport: CGSize? { didSet { if pageViewport != oldValue { invalidateMeasurements() } } }
     var celebration: CraftNativeCelebration?
     func configureCelebration(_ raw: Any?) {
         if raw != nil && celebration == nil { celebration = CraftNativeCelebration(view: self) }
@@ -2966,6 +2968,7 @@ private class CraftNativeFlowView: UIStackView {
     }
 
     func measure(width: CGFloat?, height: CGFloat?, maxWidth: CGFloat, maxHeight: CGFloat) -> CGSize {
+        if let page = pageViewport { return CGSize(width: page.width * CGFloat(arrangedSubviews.filter { !$0.isHidden }.count), height: page.height) }
         let key = MeasureKey(width: width, height: height, maxWidth: maxWidth, maxHeight: maxHeight)
         if let cached = measurements[key] { return cached }
         let size = layout(width: width, height: height, maxWidth: maxWidth, maxHeight: maxHeight, place: false).size
@@ -2977,6 +2980,12 @@ private class CraftNativeFlowView: UIStackView {
         super.layoutSubviews()
         craftApplyCornerRadius()
         celebration?.layout()
+        if let page = pageViewport {
+            for (index, child) in arrangedSubviews.filter({ !$0.isHidden }).enumerated() {
+                child.frame = CGRect(x: CGFloat(index) * page.width, y: 0, width: page.width, height: page.height)
+            }
+            return
+        }
         let scale = window?.screen.scale ?? traitCollection.displayScale
         let result = layout(width: bounds.width, height: bounds.height, maxWidth: bounds.width, maxHeight: bounds.height, place: true)
         var moved = false
@@ -4344,6 +4353,46 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
     private var laidOutSize: CGSize = .zero
     private let pullToRefresh = UIRefreshControl()
     private var refreshHandler: (() -> Void)?
+    private var authoredPageIndex: Int?
+    private var pendingPageIndex: Int?
+    private var currentPageIndex = 0
+    private var pageAnimating = false
+    private var reportedPage: (Int, Int)?
+    private var pageHandler: ((Int, Int) -> Void)?
+
+    /// Opt-in viewport-sized pages. Ordinary horizontal scroll strips retain
+    /// their intrinsic widths; only a controlled pageIndex enables this mode.
+    func configurePager(_ raw: Any?, onSelect: ((Int, Int) -> Void)?) {
+        let next = craftNativeNumber(raw).flatMap { number -> Int? in
+            let value = number.doubleValue
+            return value.isFinite ? Int(min(Double(Int.max / 2), max(0, value))) : nil
+        }
+        if next != authoredPageIndex { pendingPageIndex = next; contentNeedsLayout = true }
+        authoredPageIndex = next
+        pageHandler = onSelect
+        if next == nil { contentStack.pageViewport = nil; reportedPage = nil; pageAnimating = false }
+        setNeedsLayout()
+    }
+
+    func beginPageDrag() { pageAnimating = false }
+
+    func finishPageMotion() {
+        pageAnimating = false
+        DispatchQueue.main.async { [weak self] in self?.settlePage() }
+    }
+
+    func settlePage() {
+        guard authoredPageIndex != nil, bounds.width > 0, !pageAnimating,
+              !isTracking, !isDragging, !isDecelerating else { return }
+        let pages = contentStack.arrangedSubviews.filter { !$0.isHidden }
+        let index = min(max(0, Int((contentOffset.x / bounds.width).rounded())), max(0, pages.count - 1))
+        currentPageIndex = index
+        for (i, child) in pages.enumerated() { child.accessibilityElementsHidden = i != index }
+        if reportedPage?.0 != index || reportedPage?.1 != pages.count {
+            reportedPage = (index, pages.count)
+            pageHandler?(index, pages.count)
+        }
+    }
 
     override init(frame: CGRect) {
         super.init(frame: frame)
@@ -4384,6 +4433,11 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
     /// The size of the content laid out across the visible width (or, sideways,
     /// height), which is also the scroll view's own size when nothing fixes it.
     func contentFitting(width: CGFloat?, height: CGFloat?) -> CGSize {
+        if authoredPageIndex != nil && !isVertical {
+            let pageWidth = max(0, width ?? bounds.width)
+            let pageHeight = max(0, height ?? bounds.height)
+            return CGSize(width: pageWidth * CGFloat(contentStack.arrangedSubviews.filter { !$0.isHidden }.count), height: pageHeight)
+        }
         if isVertical {
             let contentWidth = max(0, (width ?? bounds.width) - adjustedContentInset.left - adjustedContentInset.right)
             return contentStack.measure(width: contentWidth, height: nil, maxWidth: contentWidth, maxHeight: CraftNativeFlexLayout.unbounded)
@@ -4406,7 +4460,9 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
         craftApplyCornerRadius()
         if contentNeedsLayout || laidOutSize != bounds.size {
             contentNeedsLayout = false
+            let resized = laidOutSize != bounds.size
             laidOutSize = bounds.size
+            if authoredPageIndex != nil && !isVertical { contentStack.pageViewport = bounds.size }
             var size = contentFitting(width: bounds.width, height: bounds.height)
             if isVertical {
                 size.width = max(0, bounds.width - adjustedContentInset.left - adjustedContentInset.right)
@@ -4416,12 +4472,31 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
             let frame = CGRect(origin: .zero, size: size)
             if contentStack.frame != frame { contentStack.frame = frame }
             if contentSize != size { contentSize = size }
+            if authoredPageIndex != nil && !isVertical {
+                contentStack.layoutIfNeeded()
+                let count = contentStack.arrangedSubviews.filter { !$0.isHidden }.count
+                let index = min(max(0, pendingPageIndex ?? currentPageIndex), max(0, count - 1))
+                let target = CGPoint(x: CGFloat(index) * bounds.width, y: 0)
+                let moves = pendingPageIndex != nil || resized || index != currentPageIndex
+                let animated = moves && target != contentOffset && !resized && !UIAccessibility.isReduceMotionEnabled
+                if moves {
+                    pageAnimating = animated
+                    setContentOffset(target, animated: animated)
+                }
+                pendingPageIndex = nil
+                currentPageIndex = index
+                if !animated && !isTracking && !isDragging && !isDecelerating { settlePage() }
+            }
         }
         // A scroll view lays out on every frame of a scroll: the sticky
         // headers follow it here, over content placed by this same pass.
         if !stickyIndices.isEmpty || pendingScrollTarget != nil { contentStack.layoutIfNeeded() }
         updateStickyHeaders()
         scrollToPendingTarget()
+        // A nonanimated target changes the offset synchronously inside this
+        // layout pass. Rebase the headers against that actual viewport, not
+        // the viewport from before the target was applied.
+        updateStickyHeaders()
     }
 
     // MARK: Sticky headers
@@ -4444,7 +4519,7 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
         view.center.y - view.bounds.height / 2
     }
 
-    private func updateStickyHeaders() {
+    fileprivate func updateStickyHeaders() {
         let children = contentStack.arrangedSubviews
         let headers = isVertical ? stickyIndices.compactMap { $0 < children.count ? children[$0] : nil }.filter { !$0.isHidden } : []
         for view in stickyViews where !headers.contains(where: { $0 === view }) {
@@ -4617,11 +4692,13 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
         craftScrollGesture(gestureRecognizer, runsWith: otherGestureRecognizer)
     }
 
-    func setAxis(_ axis: NSLayoutConstraint.Axis) {
+    func setAxis(_ axis: NSLayoutConstraint.Axis, resetBounce: Bool = true) {
         if contentStack.axis != axis { setContentNeedsLayout() }
         contentStack.axis = axis
-        alwaysBounceVertical = axis == .vertical
-        alwaysBounceHorizontal = axis == .horizontal
+        if resetBounce {
+            alwaysBounceVertical = axis == .vertical
+            alwaysBounceHorizontal = axis == .horizontal
+        }
     }
 }
 
@@ -5474,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)
     }
@@ -5624,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] = [:]
@@ -5894,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()
@@ -7598,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) ?? ""
@@ -8461,6 +8587,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             scroll.isScrollEnabled = props["scrollEnabled"] as? Bool != false
             scroll.bounces = props["bounces"] as? Bool ?? true
             scroll.isPagingEnabled = props["pagingEnabled"] as? Bool ?? false
+            let pageHandler = nonEmptyHandler(events["onPageSelected"])
+            scroll.configurePager(props["pageIndex"], onSelect: pageHandler.map { handler in
+                { [weak self] index, count in self?.send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["index": index, "count": count]]) }
+            })
             scroll.keyboardDismissMode = keyboardDismissMode(props["keyboardDismissMode"])
             scroll.setKeyboardShouldPersistTaps(props["keyboardShouldPersistTaps"])
             scroll.showsVerticalScrollIndicator = props["showsVerticalScrollIndicator"] as? Bool != false
@@ -8492,6 +8622,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 contentStyle.merge(override) { _, next in next }
             }
             configureStack(scroll.contentStack, style: contentStyle)
+            // Content-style defaults are vertical; the scroll host's explicit
+            // axis must survive that shared container configuration without
+            // resetting the authored bounce options applied above.
+            scroll.setAxis(direction, resetBounce: false)
             reconcileChildren(children.filter {
                 guard let child = $0 as? [String: Any] else { return true }
                 return canonicalType(child["type"] as? String ?? "") != "RefreshControl"
@@ -9712,10 +9846,28 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             for: size,
             compatibleWith: traitCollection
         )
-        var font = (style["fontFamily"] as? String).flatMap { UIFont(name: $0, size: scaledSize) }
-            ?? .systemFont(ofSize: scaledSize, weight: weight)
+        let families = (style["fontFamily"] as? String ?? "").split(separator: ",").map {
+            $0.trimmingCharacters(in: .whitespacesAndNewlines).trimmingCharacters(in: CharacterSet(charactersIn: "\"'"))
+        }
+        let selectedFont = families.lazy.compactMap { family -> UIFont? in
+            switch family.lowercased() {
+            case "monospace", "ui-monospace": return .monospacedSystemFont(ofSize: scaledSize, weight: weight)
+            case "serif", "ui-serif":
+                let system = UIFont.systemFont(ofSize: scaledSize, weight: weight)
+                return system.fontDescriptor.withDesign(.serif).map { UIFont(descriptor: $0, size: scaledSize) }
+            case "sans-serif", "ui-sans-serif", "system-ui", "-apple-system": return .systemFont(ofSize: scaledSize, weight: weight)
+            default:
+                guard let custom = UIFont(name: family, size: scaledSize) else { return nil }
+                let weighted = custom.fontDescriptor.addingAttributes([.traits: [UIFontDescriptor.TraitKey.weight: weight.rawValue]])
+                var traits = custom.fontDescriptor.symbolicTraits
+                if weight >= .semibold { traits.insert(.traitBold) } else { traits.remove(.traitBold) }
+                let descriptor = weighted.withSymbolicTraits(traits) ?? weighted
+                return UIFont(descriptor: descriptor, size: scaledSize)
+            }
+        }.first
+        var font = selectedFont ?? .systemFont(ofSize: scaledSize, weight: weight)
         if style["fontStyle"] as? String == "italic",
-           let descriptor = font.fontDescriptor.withSymbolicTraits(.traitItalic) {
+           let descriptor = font.fontDescriptor.withSymbolicTraits(font.fontDescriptor.symbolicTraits.union(.traitItalic)) {
             font = UIFont(descriptor: descriptor, size: scaledSize)
         }
         return font
@@ -10502,6 +10654,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        // Sticky positioning is a native scroll behavior and must also run
+        // without a JavaScript onScroll subscription, including animations.
+        (scrollView as? CraftNativeScrollView)?.updateStickyHeaders()
         guard let handler = scrollHandlers[ObjectIdentifier(scrollView)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": scrollEvent(scrollView)])
     }
@@ -10510,12 +10665,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
         CraftFramePacing.shared.begin(pacingName)
+        (scrollView as? CraftNativeScrollView)?.beginPageDrag()
         guard let handler = scrollBeginHandlers[ObjectIdentifier(scrollView)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": scrollEvent(scrollView)])
     }
 
     func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
-        if !decelerate { CraftFramePacing.shared.end(pacingName) }
+        if !decelerate { CraftFramePacing.shared.end(pacingName); (scrollView as? CraftNativeScrollView)?.finishPageMotion() }
         guard let handler = scrollEndHandlers[ObjectIdentifier(scrollView)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": scrollEvent(scrollView)])
     }
@@ -10527,10 +10683,15 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
         CraftFramePacing.shared.end(pacingName)
+        (scrollView as? CraftNativeScrollView)?.finishPageMotion()
         guard let handler = scrollMomentumEndHandlers[ObjectIdentifier(scrollView)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": scrollEvent(scrollView)])
     }
 
+    func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {
+        (scrollView as? CraftNativeScrollView)?.finishPageMotion()
+    }
+
     private func scrollEvent(_ scrollView: UIScrollView) -> [String: Any] {
         [
             "contentOffset": ["x": scrollView.contentOffset.x, "y": scrollView.contentOffset.y],

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

package/templates/testing/DriverTests.swift.template

@@ -22,6 +22,7 @@ import Darwin
 ///   tapif <text>          tap it when it is on screen, else carry on (the big timer's "Show the controls")
 ///   tapid <identifier>
 ///   longpressid <identifier> holds a hittable native element to open its edit menu
+///   holdtab <name> [| secs] standard XCTest hold (2–10s, default 6), BEGIN/END timing receipt
 ///   touches <JSON>       timed normalized touch paths in one native dispatch
 ///   tapxy <x> <y>         normalised 0…1 of the screen
 ///   tapexact <label>      a button whose label is exactly this
@@ -381,6 +382,43 @@ final class DriverTests: XCTestCase {
             }
             target.press(forDuration: 1.2)
             note("longpressid \(arg): ok")
+        case "holdtab":
+            let parts = arg.components(separatedBy: "|").map { $0.trimmingCharacters(in: .whitespaces) }
+            guard parts.count <= 2, let name = parts.first, !name.isEmpty,
+                  let duration = parts.count == 2 ? Double(parts[1]) : 6,
+                  duration.isFinite, (2...10).contains(duration) else {
+                check(false, "holdtab needs a tab name and 2–10 seconds")
+                return
+            }
+            guard let button = poll(10, { tabButton(name) }) else {
+                check(false, "holdtab cannot find tab \(name)")
+                return
+            }
+            let frame = button.frame
+            let coordinate = button.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5))
+            let startedAt = Date().timeIntervalSince1970
+            let startedUptime = ProcessInfo.processInfo.systemUptime
+            // BEGIN arms the independent screenshot watcher. XCTest still
+            // performs its normal idle checks before synthesizing the press;
+            // the watcher must wait for that synthesis, not infer touch-down.
+            note("BEGIN holdtab \(name) | \(duration) | \(startedAt)")
+            fflush(nil)
+            coordinate.press(forDuration: duration)
+            let returnedAt = Date().timeIntervalSince1970
+            let returnedUptime = ProcessInfo.processInfo.systemUptime
+            note("END holdtab \(name) | \(returnedAt)")
+            let receipt: [String: Any] = [
+                "tab": name, "requestedSeconds": duration,
+                "input": "XCUICoordinate.press(forDuration:)",
+                "startedAt": startedAt, "returnedAt": returnedAt,
+                "startedUptime": startedUptime, "returnedUptime": returnedUptime,
+                "frame": ["x": frame.minX, "y": frame.minY, "width": frame.width, "height": frame.height],
+                "note": "Call times include XCTest idle checks; during-hold screenshots require an independent synthesis-timed capture.",
+            ]
+            if let data = try? JSONSerialization.data(withJSONObject: receipt, options: [.sortedKeys]) {
+                post("/save?name=holdtab-\(Int(startedUptime * 1000)).json", data)
+            }
+            check(true, "holdtab \(name): standard \(duration)s press returned")
         case "touches":
             do {
                 guard let data = arg.data(using: .utf8),