craft-native 0.0.304 → 0.0.328

package/dist/index.js

@@ -117,7 +117,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.304";
+var version = "0.0.328";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -384,6 +384,7 @@ async function packageMacOS(config, outDir) {
     iconPath: config.iconPath,
     provisioningProfile: opts.provisioningProfile,
     additionalExecutables: opts.additionalExecutables,
+    nativeRuntimePath: opts.nativeRuntimePath,
     outputPath: appBundlePath
   });
   if (!appBundle.success) {
@@ -432,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`);
@@ -480,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 = [];
@@ -666,7 +685,7 @@ ${schemes.length ? `MimeType=${schemes.map((scheme) => `x-scheme-handler/${schem
 }
 function macOSInfoPlist(metadata) {
   const entries = [
-    ["CFBundleExecutable", metadata.name],
+    ["CFBundleExecutable", metadata.executableName || metadata.name],
     ["CFBundleIdentifier", metadata.bundleId],
     ["CFBundleName", metadata.name],
     ["CFBundleShortVersionString", metadata.version],
@@ -809,6 +828,9 @@ function copyMacOSAppBundle(source, destination) {
     return { success: false, error: error.message };
   }
 }
+function macOSRuntimeExecutablePath(appBundlePath) {
+  return join2(appBundlePath, "Contents", "Helpers", "CraftRuntime.app", "Contents", "MacOS", "craft");
+}
 function createMacOSAppBundle(opts) {
   try {
     const { name, binaryPath, iconPath, provisioningProfile, additionalExecutables, outputPath } = opts;
@@ -825,6 +847,27 @@ function createMacOSAppBundle(opts) {
       copyFileSync(executable, destination);
       chmodSync(destination, 493);
     }
+    if (opts.nativeRuntimePath) {
+      const helper = macOSRuntimeExecutablePath(outputPath);
+      const helperContents = resolve(helper, "..", "..");
+      mkdirSync(join2(helperContents, "MacOS"), { recursive: true });
+      copyFileSync(opts.nativeRuntimePath, helper);
+      chmodSync(helper, 493);
+      if (iconPath) {
+        mkdirSync(join2(helperContents, "Resources"), { recursive: true });
+        copyFileSync(iconPath, join2(helperContents, "Resources", "icon.icns"));
+      }
+      writeFileSync2(join2(helperContents, "Info.plist"), macOSInfoPlist({
+        name,
+        executableName: "craft",
+        version: opts.version,
+        bundleId: `${opts.bundleId}.runtime`,
+        buildNumber: opts.buildNumber,
+        minimumSystemVersion: opts.minimumSystemVersion,
+        menuBarOnly: true,
+        iconName: iconPath ? "icon" : undefined
+      }));
+    }
     let iconName;
     if (iconPath) {
       if (!existsSync3(iconPath))
@@ -10641,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");
@@ -11595,6 +11641,7 @@ export {
   liveActivities,
   loadURL,
   location,
+  macOSRuntimeExecutablePath,
   materialYou,
   media,
   menuItem,

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;
@@ -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() {
 }
 
 // ../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;
@@ -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/ios/src/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/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

@@ -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/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/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/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)
             }