craft-native 0.0.162 → 0.0.163

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

@@ -791,28 +791,28 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             } else {
                 val totalRows = layout.rowHeights.sum()
                 val rowGaps = max(0, layout.rowHeights.size - 1) * rowGap
-                val freeRows = max(0, contentHeight - totalRows - rowGaps)
+                val freeRows = max(0, contentHeight - totalRows - rowGaps).toFloat()
                 val rowCount = max(1, layout.rowHeights.size)
-                var rowLeading = 0
-                var rowBetween = rowGap
-                var rowExtra = 0
+                var rowLeading = 0f
+                var rowBetween = rowGap.toFloat()
+                var rowExtra = 0f
                 when (alignContentCode()) {
-                    1 -> rowLeading = freeRows / 2
+                    1 -> rowLeading = freeRows / 2f
                     2 -> rowLeading = freeRows
-                    3 -> if (rowCount > 1) rowBetween += freeRows / (rowCount - 1)
+                    3 -> if (rowCount > 1) rowBetween += freeRows / (rowCount - 1).toFloat()
                     4 -> {
-                        rowLeading = freeRows / (rowCount * 2)
-                        rowBetween += freeRows / rowCount
+                        rowLeading = freeRows / (rowCount * 2).toFloat()
+                        rowBetween += freeRows / rowCount.toFloat()
                     }
                     6 -> {
-                        rowLeading = freeRows / (rowCount + 1)
-                        rowBetween += freeRows / (rowCount + 1)
+                        rowLeading = freeRows / (rowCount + 1).toFloat()
+                        rowBetween += freeRows / (rowCount + 1).toFloat()
                     }
-                    5 -> rowExtra = freeRows / rowCount
+                    5 -> rowExtra = freeRows / rowCount.toFloat()
                 }
-                var rowTop = paddingTop + rowLeading
+                var rowTop = paddingTop.toFloat() + rowLeading
                 for ((rowIndex, row) in layout.rows.withIndex()) {
-                    val rowHeight = layout.rowHeights[rowIndex] + rowExtra
+                    val rowHeight = layout.rowHeights[rowIndex].toFloat() + rowExtra
                     for ((column, entry) in row.withIndex()) {
                         val align = entry.style.alignSelf ?: alignItems
                         val lp = entry.view.layoutParams as? MarginLayoutParams
@@ -821,7 +821,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                         val marginTop = lp?.topMargin ?: 0
                         val marginBottom = lp?.bottomMargin ?: 0
                         val availableWidth = max(0, layout.cellWidth - marginLeft - marginRight)
-                        val availableHeight = max(0, rowHeight - marginTop - marginBottom)
+                        val availableHeight = max(0, (rowHeight - marginTop - marginBottom).roundToInt())
                         val childWidth = if (align == "stretch" && entry.style.width == null) availableWidth else min(availableWidth, entry.width)
                         val childHeight = if (align == "stretch" && entry.style.height == null) availableHeight else min(availableHeight, entry.height)
                         val x = paddingLeft + column * (layout.cellWidth + columnGap) + marginLeft + when (align) {
@@ -829,11 +829,11 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                             "flex-end" -> availableWidth - childWidth
                             else -> 0
                         }
-                        val y = rowTop + marginTop + when (align) {
+                        val y = (rowTop + marginTop + when (align) {
                             "center" -> (availableHeight - childHeight) / 2
                             "flex-end" -> availableHeight - childHeight
                             else -> 0
-                        }
+                        }).roundToInt()
                         entry.view.layout(x, y, x + childWidth, y + childHeight)
                     }
                     rowTop += rowHeight + rowBetween
@@ -930,8 +930,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             }
             val free = max(0, availableMain - distributedMain)
             val (leading, between) = distribution(free, line.entries.size)
-            var mainOffset = if (orientation == HORIZONTAL) paddingLeft else paddingTop
-            mainOffset += leading
+            var mainOffset = (if (orientation == HORIZONTAL) paddingLeft else paddingTop).toFloat() + leading
             for ((index, entry) in line.entries.withIndex()) {
                 val lp = entry.view.layoutParams as? MarginLayoutParams
                 val marginStart = if (orientation == HORIZONTAL) lp?.leftMargin ?: 0 else lp?.topMargin ?: 0
@@ -958,10 +957,10 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 // local main-axis rule remains the fallback for old runtimes
                 // that return widths only.
                 val sharedPosition = if (!reverse) sharedPositions?.get(index)?.roundToInt() else null
-                val positionedMain = sharedPosition?.let { (if (orientation == HORIZONTAL) paddingLeft else paddingTop) + it }
+                val positionedMain = sharedPosition?.let { (if (orientation == HORIZONTAL) paddingLeft else paddingTop).toFloat() + it }
                     ?: mainOffset + marginStart
-                val x = if (orientation == HORIZONTAL) positionedMain else lineOffset + crossPosition
-                val y = if (orientation == HORIZONTAL) lineOffset + crossPosition else positionedMain
+                val x = if (orientation == HORIZONTAL) positionedMain.roundToInt() else lineOffset + crossPosition
+                val y = if (orientation == HORIZONTAL) lineOffset + crossPosition else positionedMain.roundToInt()
                 val distributedPrimary = sharedPrimary?.get(index)?.roundToInt() ?: fallbackWidths[index]
                 val w = if (orientation == HORIZONTAL) distributedPrimary else crossSize
                 val h = if (orientation == HORIZONTAL) crossSize else distributedPrimary
@@ -981,13 +980,16 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         onLayoutChanged?.invoke()
     }
 
-    private fun distribution(free: Int, count: Int): Pair<Int, Int> = when (justifyContent) {
-        "center" -> free / 2 to 0
-        "flex-end" -> free to 0
-        "space-between" -> 0 to if (count > 1) free / (count - 1) else 0
-        "space-around" -> free / (count * 2) to free / count
-        "space-evenly" -> free / (count + 1) to free / (count + 1)
-        else -> 0 to 0
+    private fun distribution(free: Int, count: Int): Pair<Float, Float> {
+        val available = free.toFloat()
+        return when (justifyContent) {
+            "center" -> available / 2f to 0f
+            "flex-end" -> available to 0f
+            "space-between" -> 0f to if (count > 1) available / (count - 1).toFloat() else 0f
+            "space-around" -> available / (count * 2).toFloat() to available / count.toFloat()
+            "space-evenly" -> available / (count + 1).toFloat() to available / (count + 1).toFloat()
+            else -> 0f to 0f
+        }
     }
 }
 

package/dist/api/mobile.d.ts

@@ -937,6 +937,142 @@ export declare const heartRate: {
     /** Bluetooth, scanning or the connection changed. */
     onState: (callback: (state: HeartRateState) => void) => (() => void);
 };
+/**
+ * Structured workouts scheduled onto the paired Apple Watch (iOS 17+, an app
+ * built with `enableScheduledWorkouts`): each appears in the watch's Workout
+ * app on its day, with its steps, goals and alerts. Plain JSON in SI units.
+ * In a browser, on Android and in a build without the capability
+ * `isSupported()` answers false and every other call rejects with
+ * `unsupported` (code `UNSUPPORTED`).
+ */
+export type ScheduledWorkoutsAuthorization = 'authorized' | 'denied' | 'notDetermined' | 'restricted' | 'unsupported';
+export type AppleWorkoutGoal = {
+    type: 'open';
+} | {
+    type: 'time';
+    seconds: number;
+} | {
+    type: 'distance';
+    meters: number;
+} | {
+    type: 'energy';
+    kilocalories: number;
+};
+export type AppleWorkoutAlert = 
+/** Beats per minute. */
+{
+    type: 'heartRate';
+    min: number;
+    max: number;
+} | {
+    type: 'heartRateZone';
+    zone: number;
+}
+/** Watts. */
+ | {
+    type: 'power';
+    min: number;
+    max: number;
+} | {
+    type: 'powerZone';
+    zone: number;
+}
+/** Metres per second (the current speed); a pace range is sent as speed. */
+ | {
+    type: 'speed';
+    min: number;
+    max: number;
+}
+/** Steps or revolutions per minute. */
+ | {
+    type: 'cadence';
+    min: number;
+    max: number;
+};
+export interface AppleWorkoutStep {
+    goal: AppleWorkoutGoal;
+    /** Dropped (the step kept) when WorkoutKit refuses it for the activity. */
+    alert?: AppleWorkoutAlert;
+    /** Shown on the watch from iOS 18; ignored on 17. At most 64 characters. */
+    displayName?: string;
+}
+export interface AppleIntervalBlock {
+    /** 1 or more. */
+    iterations: number;
+    steps: Array<{
+        purpose: 'work' | 'recovery';
+        step: AppleWorkoutStep;
+    }>;
+}
+export interface AppleCustomWorkout {
+    /** An HKWorkoutActivityType case name: 'running', 'cycling', 'swimming', 'traditionalStrengthTraining'... */
+    activity: string;
+    location: 'indoor' | 'outdoor' | 'unknown';
+    /** Swimming only: a pool swim is scheduled indoor, open water outdoor, when `location` is 'unknown'. */
+    swimmingLocation?: 'pool' | 'openWater';
+    /** Accepted for the record; WorkoutKit takes no pool length (the watch asks when the swim starts). */
+    poolLengthMeters?: number;
+    displayName: string;
+    warmup?: AppleWorkoutStep;
+    cooldown?: AppleWorkoutStep;
+    blocks: AppleIntervalBlock[];
+}
+export interface AppleWorkoutPlan {
+    /** A UUID; the plan's identity on the watch. */
+    id: string;
+    /** The local calendar day, 'YYYY-MM-DD'. */
+    date: string;
+    /** Local time of day, 07:00 when not given. */
+    hour?: number;
+    minute?: number;
+    workout: AppleCustomWorkout;
+}
+/** A plan on the watch's schedule. */
+export interface ScheduledWorkout {
+    /** Lowercase UUID. */
+    id: string;
+    date: string;
+    hour?: number;
+    minute?: number;
+    /** The person has done it. */
+    complete: boolean;
+}
+export interface ScheduleWorkoutResult {
+    id: string;
+    /** Alerts WorkoutKit refused and left out, each by where it was ("block 1 step 2: power alert..."). */
+    droppedAlerts?: string[];
+}
+export type ScheduledWorkoutsMethod = 'isSupported' | 'authorization' | 'requestAuthorization' | 'list' | 'schedule' | 'remove' | 'removeAll';
+/** The rejection every call but isSupported() gets where nothing can schedule. */
+export declare function scheduledWorkoutsUnsupported(): Error;
+/** A row of `list()`, or null for one that is not a scheduled plan. */
+export declare function normalizeScheduledWorkout(value: unknown): ScheduledWorkout | null;
+export declare const scheduledWorkouts: {
+    /** Whether this app build has the bridge at all (not whether this phone can schedule: `isSupported()`). */
+    isAvailable(): boolean;
+    /** Whether this app build answers `method`; an older build may lack one. */
+    supports(method: ScheduledWorkoutsMethod): boolean;
+    /** iOS 17 or later and WorkoutKit can schedule here; false everywhere else, never rejects. */
+    isSupported(): Promise<boolean>;
+    /** What the person allowed, without asking. */
+    authorization: () => Promise<ScheduledWorkoutsAuthorization>;
+    /** iOS's prompt the first time; its remembered answer after that. Call it from the person's tap. */
+    requestAuthorization: () => Promise<ScheduledWorkoutsAuthorization>;
+    /** Every plan on the watch's schedule. */
+    list: () => Promise<ScheduledWorkout[]>;
+    /**
+     * Put a plan on the watch's schedule (again on another day moves it).
+     * Rejects with a message naming what WorkoutKit refused: an activity or a
+     * goal it cannot schedule (an alert it refuses is dropped instead, listed in
+     * `droppedAlerts`), more plans than the watch holds (LIMIT_REACHED), or a
+     * schedule nothing kept, such as no paired watch (NOT_SCHEDULED).
+     */
+    schedule: (plan: AppleWorkoutPlan) => Promise<ScheduleWorkoutResult>;
+    /** Take a plan off every day it is scheduled; true when there was one. */
+    remove: (id: string) => Promise<boolean>;
+    /** Clear the schedule; how many plans it held. */
+    removeAll: () => Promise<number>;
+};
 export declare const deepLinks: {
     getInitialURL(): Promise<string | null>;
     /**
@@ -1474,6 +1610,7 @@ declare const mobile: {
     speech: typeof speech;
     music: typeof music;
     heartRate: typeof heartRate;
+    scheduledWorkouts: typeof scheduledWorkouts;
     deepLinks: typeof deepLinks;
     network: typeof network;
     appReview: typeof appReview;

package/dist/cli.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/ios/src/index.d.ts

@@ -88,6 +88,17 @@ export interface CraftConfig {
      * playback session).
      */
     enableBackgroundAudio?: boolean;
+    /**
+     * Schedule structured workouts onto the paired Apple Watch through
+     * `craft.scheduledWorkouts` (WorkoutKit's WorkoutScheduler, iOS 17+): each
+     * appears in the watch's Workout app on its day, with its steps, goals and
+     * alerts. Compiles CraftScheduledWorkouts.swift with the
+     * `CRAFT_SCHEDULED_WORKOUTS` condition, so an app without it never links
+     * WorkoutKit; below iOS 17 it is weak-linked and answers unsupported. iOS
+     * asks the person the first time the page calls
+     * `craft.scheduledWorkouts.requestAuthorization()`, never at launch.
+     */
+    enableScheduledWorkouts?: boolean;
     /**
      * Purpose strings in the app's own words, by Info.plist key
      * (`{ NSAppleMusicUsageDescription: 'Shows the song playing during a workout.' }`).
@@ -381,6 +392,13 @@ export declare function renderWatchEntitlements(config: CraftConfig): string;
  * reach everything the bridge actually uses.
  */
 export declare function renderRuntimeSettings(): string;
+/**
+ * Build settings a feature adds to the app target. WorkoutKit is compiled in
+ * only for `enableScheduledWorkouts`: CraftScheduledWorkouts.swift imports it
+ * behind the `CRAFT_SCHEDULED_WORKOUTS` condition, so an app that does not
+ * schedule workouts does not link it. `$(inherited)` keeps Debug's `DEBUG`.
+ */
+export declare function renderFeatureSettings(config: Pick<CraftConfig, 'enableScheduledWorkouts'>): string;
 export declare function renderPrivacyManifest(config: CraftConfig): string;
 /**
  * Whether a PNG carries an alpha channel, from its header: colour type 4

package/dist/ios/src/index.js

@@ -349,6 +349,7 @@ var DEFAULT_CONFIG = {
   enableMLKit: false,
   enableAppleMusic: false,
   enableHeartRate: false,
+  enableScheduledWorkouts: false,
   iosVersion: "16.0",
   watchosVersion: "9.0",
   teamId: "",
@@ -583,6 +584,14 @@ function renderRuntimeSettings() {
   ].join(`
 `);
 }
+function renderFeatureSettings(config) {
+  const conditions = [];
+  if (config.enableScheduledWorkouts)
+    conditions.push("CRAFT_SCHEDULED_WORKOUTS");
+  if (!conditions.length)
+    return "";
+  return `      SWIFT_ACTIVE_COMPILATION_CONDITIONS: "$(inherited) ${conditions.join(" ")}"`;
+}
 function renderPrivacyManifest(config) {
   const privacy = config.privacy ?? {};
   const collected = privacy.collectedDataTypes ?? [];
@@ -944,6 +953,7 @@ function writeShell(output, config) {
   cpSync(join2(TEMPLATES_DIR, "CraftHealth.swift"), join2(output, "Sources", "CraftHealth.swift"));
   cpSync(join2(TEMPLATES_DIR, "CraftMusic.swift"), join2(output, "Sources", "CraftMusic.swift"));
   cpSync(join2(TEMPLATES_DIR, "CraftHeartRate.swift"), join2(output, "Sources", "CraftHeartRate.swift"));
+  cpSync(join2(TEMPLATES_DIR, "CraftScheduledWorkouts.swift"), join2(output, "Sources", "CraftScheduledWorkouts.swift"));
   cpSync(join2(TEMPLATES_DIR, "CraftNativeMutation.swift"), join2(output, "Sources", "CraftNativeMutation.swift"));
   cpSync(join2(TEMPLATES_DIR, "CraftNativeUI.swift"), join2(output, "Sources", "CraftNativeUI.swift"));
   cpSync(join2(TEMPLATES_DIR, "CraftNativeServices.swift"), join2(output, "Sources", "CraftNativeServices.swift"));
@@ -1065,7 +1075,7 @@ async function init(options) {
   } else {
     rmSync2(join2(output, "Runtime"), { recursive: true, force: true });
   }
-  const projectYml = projectYmlTemplate.replace(/\{\{CRAFT_RUNTIME_SETTINGS\}\}/g, hasRuntime ? renderRuntimeSettings() : "").replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{BUNDLE_ID_PREFIX\}\}/g, bundleIdPrefix).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{IOS_VERSION\}\}/g, config.iosVersion || "15.0").replace(/\{\{DEVICE_FAMILIES\}\}/g, renderDeviceFamilies(config)).replace(/\{\{TEAM_ID\}\}/g, teamId || "").replace(/\{\{NATIVE_DEPENDENCIES\}\}/g, nativeDependencies.length ? `    dependencies:
+  const projectYml = projectYmlTemplate.replace(/\{\{CRAFT_RUNTIME_SETTINGS\}\}/g, hasRuntime ? renderRuntimeSettings() : "").replace(/\{\{FEATURE_SETTINGS\}\}/g, renderFeatureSettings(config)).replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{BUNDLE_ID_PREFIX\}\}/g, bundleIdPrefix).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{IOS_VERSION\}\}/g, config.iosVersion || "15.0").replace(/\{\{DEVICE_FAMILIES\}\}/g, renderDeviceFamilies(config)).replace(/\{\{TEAM_ID\}\}/g, teamId || "").replace(/\{\{NATIVE_DEPENDENCIES\}\}/g, nativeDependencies.length ? `    dependencies:
 ${nativeDependencies.join(`
 `)}` : "").replace(/\{\{NATIVE_TARGETS\}\}/g, nativeTargets.join(`
 `));
@@ -1298,6 +1308,7 @@ export {
   renderOrientations,
   renderOfflinePage,
   renderLaunchScreen,
+  renderFeatureSettings,
   renderEntitlements,
   renderDeviceFamilies,
   renderBackgroundTaskIdentifiers,

package/dist/ios/templates/CraftApp.swift

@@ -1212,6 +1212,9 @@ struct CraftConfig: Codable {
     /// A Bluetooth heart-rate strap (or a watch broadcasting its heart rate)
     /// through `craft.heartRate` (CraftHeartRate.swift).
     var enableHeartRate: Bool = false
+    /// Structured workouts scheduled onto the paired Apple Watch through
+    /// `craft.scheduledWorkouts` (CraftScheduledWorkouts.swift, WorkoutKit).
+    var enableScheduledWorkouts: Bool = false
     var devServerURL: String? = nil
     var trustedOrigins: [String] = []
     /// The longest the launch splash stays up when the page neither says it is
@@ -2335,6 +2338,22 @@ struct CraftWebView: UIViewRepresentable {
                         }
                     }
                 }
+            // MARK: - Scheduled workouts (CraftScheduledWorkouts.swift)
+            // Gated on enableScheduledWorkouts. One action for every method,
+            // as a native screen's ScheduledWorkouts module calls them;
+            // asking to schedule has its own, which waits on the person.
+            case "scheduledWorkouts", "scheduledWorkoutsRequestAuthorization":
+                if !config.enableScheduledWorkouts {
+                    rejectCallback(callbackId, error: "Scheduled workouts are disabled", code: "CAPABILITY_DISABLED")
+                } else {
+                    let method = action == "scheduledWorkouts" ? body["method"] as? String ?? "" : "requestAuthorization"
+                    CraftScheduledWorkouts.shared.perform(method: method, args: [body["options"] as? [String: Any] ?? [:]]) { [weak self] result in
+                        switch result {
+                        case .success(let value): self?.resolveCallback(callbackId, result: value)
+                        case .failure(let failure): self?.rejectCallback(callbackId, error: failure.message, code: failure.code)
+                        }
+                    }
+                }
             // MARK: - Orientation Lock
             case "lockOrientation":
                 if config.enableOrientationLock {
@@ -3337,6 +3356,7 @@ struct CraftWebView: UIViewRepresentable {
                     brightness: true,
                     music: \(config.enableAppleMusic),
                     heartRate: \(config.enableHeartRate),
+                    scheduledWorkouts: \(config.enableScheduledWorkouts),
                     speech: true,
                     network: true,
                     deviceInfo: true,
@@ -4877,6 +4897,7 @@ struct CraftWebView: UIViewRepresentable {
                     requestHealthAuthorization: true,
                     musicRequestAuthorization: true,
                     heartRateRequestAuthorization: true,
+                    scheduledWorkoutsRequestAuthorization: true,
                     requestPermission: true,
                     signInWithApple: true,
                     dialogAlert: true,
@@ -5123,6 +5144,22 @@ struct CraftWebView: UIViewRepresentable {
                         readRecording: function(options) { return heartRate('readRecording', {since: options && typeof options.since === 'number' ? options.since : null}); }
                     };
                 })();
+                // Structured workouts on the paired Apple Watch (WorkoutKit,
+                // iOS 17+): each appears in its Workout app on its day.
+                // schedule(plan) answers {id} or rejects naming what WorkoutKit
+                // refused; list() answers [{id, date, hour, minute, complete}].
+                (function() {
+                    function scheduled(method, options) { return craft._invoke('scheduledWorkouts', {method: method, options: options || {}}); }
+                    craft.scheduledWorkouts = {
+                        isSupported: function() { return scheduled('isSupported'); },
+                        authorization: function() { return scheduled('authorization'); },
+                        requestAuthorization: function() { return craft._invoke('scheduledWorkoutsRequestAuthorization'); },
+                        list: function() { return scheduled('list'); },
+                        schedule: function(plan) { return scheduled('schedule', plan); },
+                        remove: function(id) { return scheduled('remove', {id: typeof id === 'string' ? id : id && id.id}); },
+                        removeAll: function() { return scheduled('removeAll'); }
+                    };
+                })();
                 craft.liveActivity = {
                     start: function(options) { return craft._invoke('startLiveActivity', options || {}); },
                     update: function(idOrState, state) {

package/dist/ios/templates/CraftNativeActions.swift

@@ -68,6 +68,9 @@ enum CraftNativeActions {
         // A heart-rate strap is the app's own service (CraftHeartRate.swift),
         // so it needs no web view.
         if config.enableHeartRate { values.append("heartRate") }
+        // Workouts on the paired Apple Watch (CraftScheduledWorkouts.swift),
+        // also the app's own service.
+        if config.enableScheduledWorkouts { values.append("scheduledWorkouts") }
         // Photos picked from the library, files downloaded for the share
         // sheet and sent in a form (CraftNativeFiles.swift): the photo picker
         // runs out of process and asks no permission. Taking a photo needs
@@ -338,6 +341,17 @@ enum CraftNativeActions {
                 complete(requestToken, result.mapError { CraftNativeActionError(code: $0.code, message: $0.message) }, completion)
             }
             return
+        case ("ScheduledWorkouts", _):
+            // Workouts on the paired Apple Watch, the same service as a
+            // page's `craft.scheduledWorkouts` (WorkoutKit's scheduler).
+            guard config.enableScheduledWorkouts else {
+                complete(requestToken, failure("CAPABILITY_DISABLED", "Scheduled workouts are disabled"), completion)
+                return
+            }
+            CraftScheduledWorkouts.shared.perform(method: method, args: args) { result in
+                complete(requestToken, result.mapError { CraftNativeActionError(code: $0.code, message: $0.message) }, completion)
+            }
+            return
         case ("Linking", "openURL"), ("Linking", "canOpenURL"):
             // Another app or the system: `webcal:` subscriptions, `mailto:`,
             // `tel:`, the App Store, this app's page in Settings

package/dist/ios/templates/CraftNativeScreen.swift

@@ -1178,6 +1178,7 @@ private class CraftNativeFlowView: UIStackView {
             case "flex-end": 2
             case "space-between": 3
             case "space-around": 4
+            case "space-evenly": 6
             case "stretch": 5
             default: 0
             }
@@ -1374,6 +1375,9 @@ private class CraftNativeFlowView: UIStackView {
             case "space-around":
                 rowLeading = gridFree / CGFloat(rowHeights.count * 2)
                 rowBetween += gridFree / CGFloat(rowHeights.count)
+            case "space-evenly":
+                rowLeading = gridFree / CGFloat(rowHeights.count + 1)
+                rowBetween += gridFree / CGFloat(rowHeights.count + 1)
             case "stretch": rowExtra = gridFree / CGFloat(max(1, rowHeights.count))
             default: break
             }

package/dist/ios/templates/CraftScheduledWorkouts.swift

@@ -0,0 +1,524 @@
+import Foundation
+#if CRAFT_SCHEDULED_WORKOUTS
+import HealthKit
+import WorkoutKit
+#endif
+
+/// A scheduling call that did not happen: the message a page sees, and the
+/// bridge's error code.
+struct CraftScheduledWorkoutsError: Error {
+    let message: String
+    var code: String = "CRAFT_ERROR"
+}
+
+/// Structured workouts scheduled onto the paired Apple Watch through
+/// WorkoutKit's `WorkoutScheduler` (iOS 17+): each appears in the watch's
+/// Workout app on its day, steps, targets and alerts included.
+///
+/// One service for both sides: the page's `craft.scheduledWorkouts` (actions
+/// `scheduledWorkouts` and `scheduledWorkoutsRequestAuthorization`, which
+/// waits on the person) and a native screen's `ScheduledWorkouts` module.
+///
+/// WorkoutKit is compiled in only with `enableScheduledWorkouts`, which sets
+/// the `CRAFT_SCHEDULED_WORKOUTS` condition, so an app that does not schedule
+/// workouts does not link it. Without it (or below iOS 17) `isSupported`
+/// answers false, `authorization` answers `unsupported`, and everything else
+/// rejects UNSUPPORTED.
+///
+/// A plan is plain JSON (SI units):
+///
+///   { id: UUID, date: 'YYYY-MM-DD', hour?, minute?, workout: {
+///       activity: HKWorkoutActivityType case name, location: 'indoor' | 'outdoor' | 'unknown',
+///       swimmingLocation?: 'pool' | 'openWater', poolLengthMeters?, displayName,
+///       warmup?: step, cooldown?: step,
+///       blocks: [{ iterations, steps: [{ purpose: 'work' | 'recovery', step }] }] } }
+///   step = { goal: { type: 'open' | 'time' (seconds) | 'distance' (meters) | 'energy' (kilocalories) },
+///            alert?: { type: 'heartRate' | 'power' | 'speed' | 'cadence', min, max } | { type: 'heartRateZone' | 'powerZone', zone },
+///            displayName? }
+///
+/// An activity or a goal WorkoutKit refuses rejects the call, naming it; an
+/// alert it refuses is dropped and its step kept (`droppedAlerts`).
+///
+/// Simulator builds can stand in a scheduler with the
+/// `CraftFakeWorkoutScheduler` default (`xcrun simctl spawn booted defaults
+/// write <bundle id> CraftFakeWorkoutScheduler -bool YES`): plans are still
+/// built and checked by WorkoutKit, then kept in UserDefaults instead of on a
+/// watch, which a simulator never has. `CraftFakeWorkoutSchedulerAuthorization`
+/// (a string) presets its answer to `denied`, `restricted` or `authorized`.
+final class CraftScheduledWorkouts {
+    typealias Completion = (Result<Any, CraftScheduledWorkoutsError>) -> Void
+
+    static let shared = CraftScheduledWorkouts()
+
+    /// The call by method, with its options as the bridge sends them; answered on main.
+    func perform(method: String, args: [Any], completion: @escaping Completion) {
+        let options = args.first as? [String: Any] ?? [:]
+        let done: Completion = { result in DispatchQueue.main.async { completion(result) } }
+        #if CRAFT_SCHEDULED_WORKOUTS
+        if #available(iOS 17.0, *) {
+            Task { done(await CraftWorkoutKitScheduler.shared.perform(method: method, options: options)) }
+            return
+        }
+        #endif
+        done(Self.unsupported(method: method))
+    }
+
+    /// The answer where WorkoutKit is not there: compiled out, or below iOS 17.
+    static func unsupported(method: String) -> Result<Any, CraftScheduledWorkoutsError> {
+        switch method {
+        case "isSupported": return .success(false)
+        case "authorization", "requestAuthorization": return .success("unsupported")
+        case "list", "schedule", "remove", "removeAll":
+            return .failure(CraftScheduledWorkoutsError(message: "unsupported", code: "UNSUPPORTED"))
+        default:
+            return .failure(CraftScheduledWorkoutsError(message: "Unsupported ScheduledWorkouts method: \(method)", code: "UNKNOWN_ACTION"))
+        }
+    }
+}
+
+#if CRAFT_SCHEDULED_WORKOUTS
+
+/// What the scheduler keeps: a plan's id on a day, and whether it was done.
+@available(iOS 17.0, *)
+struct CraftScheduledWorkoutEntry {
+    let id: UUID
+    let date: DateComponents
+    let complete: Bool
+    /// The plan itself, which WorkoutKit needs to remove it; nil from the stand-in.
+    let plan: WorkoutPlan?
+
+    /// `{ id, date, hour?, minute?, complete }`, the id lowercase.
+    var json: [String: Any] {
+        var out: [String: Any] = ["id": id.uuidString.lowercased(), "complete": complete]
+        if let year = date.year, let month = date.month, let day = date.day {
+            out["date"] = String(format: "%04d-%02d-%02d", year, month, day)
+        }
+        if let hour = date.hour { out["hour"] = hour }
+        if let minute = date.minute { out["minute"] = minute }
+        return out
+    }
+}
+
+/// WorkoutKit's scheduler, or the simulator's stand-in.
+@available(iOS 17.0, *)
+protocol CraftWorkoutStore: AnyObject {
+    var isSupported: Bool { get }
+    var maxCount: Int { get }
+    func authorization() async -> String
+    func requestAuthorization() async -> String
+    func entries() async -> [CraftScheduledWorkoutEntry]
+    func schedule(_ plan: WorkoutPlan, at date: DateComponents) async
+    func remove(_ entry: CraftScheduledWorkoutEntry) async
+    func removeAll() async
+}
+
+@available(iOS 17.0, *)
+func craftWorkoutAuthorization(_ state: WorkoutScheduler.AuthorizationState) -> String {
+    switch state {
+    case .authorized: return "authorized"
+    case .denied: return "denied"
+    case .restricted: return "restricted"
+    case .notDetermined: return "notDetermined"
+    @unknown default: return "notDetermined"
+    }
+}
+
+@available(iOS 17.0, *)
+final class CraftSystemWorkoutStore: CraftWorkoutStore {
+    var isSupported: Bool { WorkoutScheduler.isSupported }
+    var maxCount: Int { WorkoutScheduler.maxAllowedScheduledWorkoutCount }
+    func authorization() async -> String { craftWorkoutAuthorization(await WorkoutScheduler.shared.authorizationState) }
+    func requestAuthorization() async -> String { craftWorkoutAuthorization(await WorkoutScheduler.shared.requestAuthorization()) }
+    func entries() async -> [CraftScheduledWorkoutEntry] {
+        await WorkoutScheduler.shared.scheduledWorkouts.map {
+            CraftScheduledWorkoutEntry(id: $0.plan.id, date: $0.date, complete: $0.complete, plan: $0.plan)
+        }
+    }
+    func schedule(_ plan: WorkoutPlan, at date: DateComponents) async { await WorkoutScheduler.shared.schedule(plan, at: date) }
+    func remove(_ entry: CraftScheduledWorkoutEntry) async {
+        guard let plan = entry.plan else { return }
+        await WorkoutScheduler.shared.remove(plan, at: entry.date)
+    }
+    func removeAll() async { await WorkoutScheduler.shared.removeAllWorkouts() }
+}
+
+/// Simulator builds only (see `CraftScheduledWorkouts`): plans kept in
+/// UserDefaults, as a paired watch would keep them.
+@available(iOS 17.0, *)
+final class CraftFakeWorkoutStore: CraftWorkoutStore {
+    private let key = "CraftFakeScheduledWorkouts"
+    private let authorizationKey = "CraftFakeWorkoutSchedulerAuthorization"
+    private let defaults = UserDefaults.standard
+    let isSupported = true
+    var maxCount: Int { WorkoutScheduler.maxAllowedScheduledWorkoutCount }
+
+    func authorization() async -> String { defaults.string(forKey: authorizationKey) ?? "notDetermined" }
+    func requestAuthorization() async -> String {
+        let current = await authorization()
+        guard current == "notDetermined" else { return current }
+        defaults.set("authorized", forKey: authorizationKey)
+        return "authorized"
+    }
+    func entries() async -> [CraftScheduledWorkoutEntry] {
+        (defaults.array(forKey: key) as? [[String: Any]] ?? []).compactMap { row in
+            guard let id = (row["id"] as? String).flatMap(UUID.init(uuidString:)) else { return nil }
+            var date = DateComponents()
+            date.year = row["year"] as? Int
+            date.month = row["month"] as? Int
+            date.day = row["day"] as? Int
+            date.hour = row["hour"] as? Int
+            date.minute = row["minute"] as? Int
+            return CraftScheduledWorkoutEntry(id: id, date: date, complete: row["complete"] as? Bool ?? false, plan: nil)
+        }
+    }
+    func schedule(_ plan: WorkoutPlan, at date: DateComponents) async {
+        var rows = defaults.array(forKey: key) as? [[String: Any]] ?? []
+        var row: [String: Any] = ["id": plan.id.uuidString, "complete": false]
+        row["year"] = date.year
+        row["month"] = date.month
+        row["day"] = date.day
+        row["hour"] = date.hour
+        row["minute"] = date.minute
+        rows.append(row)
+        defaults.set(rows, forKey: key)
+    }
+    func remove(_ entry: CraftScheduledWorkoutEntry) async {
+        let rows = (defaults.array(forKey: key) as? [[String: Any]] ?? []).filter { row in
+            !((row["id"] as? String).flatMap(UUID.init(uuidString:)) == entry.id
+                && row["year"] as? Int == entry.date.year && row["month"] as? Int == entry.date.month
+                && row["day"] as? Int == entry.date.day && row["hour"] as? Int == entry.date.hour
+                && row["minute"] as? Int == entry.date.minute)
+        }
+        defaults.set(rows, forKey: key)
+    }
+    func removeAll() async { defaults.removeObject(forKey: key) }
+}
+
+/// The calls, on whichever store this build schedules with.
+@available(iOS 17.0, *)
+final class CraftWorkoutKitScheduler {
+    static let shared = CraftWorkoutKitScheduler(store: CraftWorkoutKitScheduler.makeStore())
+
+    private let store: CraftWorkoutStore
+
+    init(store: CraftWorkoutStore) { self.store = store }
+
+    private static func makeStore() -> CraftWorkoutStore {
+        #if targetEnvironment(simulator)
+        if UserDefaults.standard.bool(forKey: "CraftFakeWorkoutScheduler") { return CraftFakeWorkoutStore() }
+        #endif
+        return CraftSystemWorkoutStore()
+    }
+
+    private func failure(_ message: String, _ code: String) -> Result<Any, CraftScheduledWorkoutsError> {
+        .failure(CraftScheduledWorkoutsError(message: message, code: code))
+    }
+
+    func perform(method: String, options: [String: Any]) async -> Result<Any, CraftScheduledWorkoutsError> {
+        switch method {
+        case "isSupported":
+            return .success(store.isSupported)
+        case "authorization":
+            return .success(store.isSupported ? await store.authorization() : "unsupported")
+        case "requestAuthorization":
+            return .success(store.isSupported ? await store.requestAuthorization() : "unsupported")
+        case "list", "schedule", "remove", "removeAll":
+            guard store.isSupported else { return failure("unsupported", "UNSUPPORTED") }
+            guard await store.authorization() == "authorized" else {
+                return failure("Scheduling workouts on the Apple Watch has not been allowed", "NOT_AUTHORIZED")
+            }
+            switch method {
+            case "list": return .success(await store.entries().map(\.json))
+            case "schedule": return await schedule(options)
+            case "remove": return await remove(id: options["id"] as? String)
+            default:
+                let count = await store.entries().count
+                await store.removeAll()
+                return .success(count)
+            }
+        default:
+            return failure("Unsupported ScheduledWorkouts method: \(method)", "UNKNOWN_ACTION")
+        }
+    }
+
+    private func schedule(_ body: [String: Any]) async -> Result<Any, CraftScheduledWorkoutsError> {
+        let built: CraftWorkoutPlanBuilder.Built
+        switch CraftWorkoutPlanBuilder.build(body) {
+        case .success(let value): built = value
+        case .failure(let error): return .failure(error)
+        }
+        let existing = await store.entries().filter { $0.id == built.plan.id }
+        let sameDay = existing.contains { CraftWorkoutPlanBuilder.sameMoment($0.date, built.date) }
+        if !sameDay {
+            // A plan id lives on one day: scheduling it again moves it.
+            let others = await store.entries().count - existing.count
+            guard others < store.maxCount else {
+                return failure("The Apple Watch holds at most \(store.maxCount) scheduled workouts; remove one first", "LIMIT_REACHED")
+            }
+            for entry in existing { await store.remove(entry) }
+            await store.schedule(built.plan, at: built.date)
+            // WorkoutScheduler.schedule neither throws nor answers; what it
+            // kept is the answer (nothing, without a paired watch).
+            let kept = await store.entries().contains { $0.id == built.plan.id && CraftWorkoutPlanBuilder.sameMoment($0.date, built.date) }
+            guard kept else {
+                return failure("WorkoutKit did not keep the workout. Is an Apple Watch paired with the Workout app installed?", "NOT_SCHEDULED")
+            }
+        }
+        var out: [String: Any] = ["id": built.plan.id.uuidString.lowercased()]
+        if !built.droppedAlerts.isEmpty { out["droppedAlerts"] = built.droppedAlerts }
+        return .success(out)
+    }
+
+    private func remove(id: String?) async -> Result<Any, CraftScheduledWorkoutsError> {
+        guard let id, let uuid = UUID(uuidString: id) else {
+            return failure("remove needs a plan id (a UUID)", "INVALID_ARGUMENT")
+        }
+        let matching = await store.entries().filter { $0.id == uuid }
+        for entry in matching { await store.remove(entry) }
+        return .success(!matching.isEmpty)
+    }
+}
+
+/// A plan's JSON turned into WorkoutKit's types, checked the way WorkoutKit
+/// checks them (`CustomWorkout.supportsActivity`, `supportsGoal`,
+/// `supportsAlert`). Pure: no scheduler, so it is unit tested on its own.
+@available(iOS 17.0, *)
+enum CraftWorkoutPlanBuilder {
+    struct Built {
+        let plan: WorkoutPlan
+        let date: DateComponents
+        /// Each alert WorkoutKit refused, by where it was ("block 1 step 2: power").
+        let droppedAlerts: [String]
+    }
+
+    static let activities: [String: HKWorkoutActivityType] = [
+        "running": .running, "cycling": .cycling, "swimming": .swimming, "walking": .walking,
+        "hiking": .hiking, "traditionalStrengthTraining": .traditionalStrengthTraining,
+        "functionalStrengthTraining": .functionalStrengthTraining, "rowing": .rowing, "yoga": .yoga,
+        "flexibility": .flexibility, "crossTraining": .crossTraining, "elliptical": .elliptical,
+        "highIntensityIntervalTraining": .highIntensityIntervalTraining, "other": .other,
+        "coreTraining": .coreTraining, "mixedCardio": .mixedCardio, "stairClimbing": .stairClimbing,
+        "stairs": .stairs, "stepTraining": .stepTraining, "pilates": .pilates, "cardioDance": .cardioDance,
+        "kickboxing": .kickboxing, "boxing": .boxing, "jumpRope": .jumpRope, "cooldown": .cooldown,
+        "crossCountrySkiing": .crossCountrySkiing, "paddleSports": .paddleSports,
+        "handCycling": .handCycling, "wheelchairRunPace": .wheelchairRunPace, "wheelchairWalkPace": .wheelchairWalkPace,
+    ]
+
+    static let locations: [String: HKWorkoutSessionLocationType] = ["indoor": .indoor, "outdoor": .outdoor, "unknown": .unknown]
+
+    private static func refuse(_ message: String) -> Result<Built, CraftScheduledWorkoutsError> {
+        .failure(CraftScheduledWorkoutsError(message: message, code: "INVALID_ARGUMENT"))
+    }
+
+    private static func number(_ value: Any?) -> Double? {
+        // JSON's true and false arrive as NSNumber too; they are not numbers here.
+        guard let value = value as? NSNumber, CFGetTypeID(value) != CFBooleanGetTypeID() else { return nil }
+        let double = value.doubleValue
+        return double.isFinite ? double : nil
+    }
+
+    /// Two schedule dates as WorkoutKit compares them: the day and the time of day.
+    static func sameMoment(_ a: DateComponents, _ b: DateComponents) -> Bool {
+        a.year == b.year && a.month == b.month && a.day == b.day && (a.hour ?? 0) == (b.hour ?? 0) && (a.minute ?? 0) == (b.minute ?? 0)
+    }
+
+    /// 'YYYY-MM-DD' plus the time of day (07:00 when not given), local.
+    static func date(_ body: [String: Any]) -> DateComponents? {
+        guard let text = body["date"] as? String else { return nil }
+        let parts = text.split(separator: "-", omittingEmptySubsequences: false)
+        guard parts.count == 3, parts[0].count == 4, parts[1].count == 2, parts[2].count == 2,
+              let year = Int(parts[0]), let month = Int(parts[1]), let day = Int(parts[2]) else { return nil }
+        let hour = body["hour"] == nil || body["hour"] is NSNull ? 7 : number(body["hour"]).map { Int($0) }
+        let minute = body["minute"] == nil || body["minute"] is NSNull ? 0 : number(body["minute"]).map { Int($0) }
+        guard let hour, let minute, (0...23).contains(hour), (0...59).contains(minute) else { return nil }
+        var components = DateComponents()
+        components.year = year
+        components.month = month
+        components.day = day
+        // A day that does not exist (2026-02-30) is refused, not rolled over.
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = .current
+        guard let real = calendar.date(from: components),
+              calendar.component(.day, from: real) == day, calendar.component(.month, from: real) == month else { return nil }
+        components.hour = hour
+        components.minute = minute
+        return components
+    }
+
+    static func goal(_ value: Any?) -> Result<(goal: WorkoutGoal, name: String), CraftScheduledWorkoutsError> {
+        let body = value as? [String: Any] ?? [:]
+        let type = body["type"] as? String ?? (value == nil ? "open" : "")
+        func positive(_ key: String) -> Double? { number(body[key]).flatMap { $0 > 0 ? $0 : nil } }
+        switch type {
+        case "open": return .success((.open, "open"))
+        case "time":
+            guard let seconds = positive("seconds") else { break }
+            return .success((.time(seconds, .seconds), "time"))
+        case "distance":
+            guard let meters = positive("meters") else { break }
+            return .success((.distance(meters, .meters), "distance"))
+        case "energy":
+            guard let kilocalories = positive("kilocalories") else { break }
+            return .success((.energy(kilocalories, .kilocalories), "energy"))
+        default:
+            return .failure(CraftScheduledWorkoutsError(message: "Unknown goal type '\(type)'", code: "INVALID_ARGUMENT"))
+        }
+        return .failure(CraftScheduledWorkoutsError(message: "A \(type) goal needs a positive number", code: "INVALID_ARGUMENT"))
+    }
+
+    /// The alert, or why it was left out.
+    static func alert(_ value: Any?) -> Result<(alert: any WorkoutAlert, name: String), CraftScheduledWorkoutsError> {
+        let body = value as? [String: Any] ?? [:]
+        let type = body["type"] as? String ?? ""
+        func invalid(_ why: String) -> Result<(alert: any WorkoutAlert, name: String), CraftScheduledWorkoutsError> {
+            .failure(CraftScheduledWorkoutsError(message: "\(type.isEmpty ? "alert" : type) \(why)", code: "INVALID_ARGUMENT"))
+        }
+        func range() -> ClosedRange<Double>? {
+            guard let a = number(body["min"]), let b = number(body["max"]), a >= 0, b >= 0, max(a, b) > 0 else { return nil }
+            return min(a, b)...max(a, b)
+        }
+        func zone() -> Int? {
+            guard let value = number(body["zone"]), value >= 1, value.rounded() == value else { return nil }
+            return Int(value)
+        }
+        switch type {
+        case "heartRate":
+            guard let range = range() else { return invalid("needs min and max") }
+            return .success((.heartRate(range), type))
+        case "heartRateZone":
+            guard let zone = zone() else { return invalid("needs a zone from 1") }
+            return .success((.heartRate(zone: zone), type))
+        case "power":
+            guard let range = range() else { return invalid("needs min and max") }
+            return .success((.power(range, unit: .watts), type))
+        case "powerZone":
+            guard let zone = zone() else { return invalid("needs a zone from 1") }
+            return .success((.power(zone: zone), type))
+        case "speed":
+            guard let range = range() else { return invalid("needs min and max") }
+            return .success((.speed(range, unit: .metersPerSecond, metric: .current), type))
+        case "cadence":
+            guard let range = range() else { return invalid("needs min and max") }
+            return .success((.cadence(range), type))
+        default:
+            return invalid("is not an alert WorkoutKit knows")
+        }
+    }
+
+    static func build(_ body: [String: Any]) -> Result<Built, CraftScheduledWorkoutsError> {
+        guard let idText = body["id"] as? String, let id = UUID(uuidString: idText) else {
+            return refuse("A scheduled workout needs an id (a UUID)")
+        }
+        guard let date = date(body) else {
+            return refuse("A scheduled workout needs a date ('YYYY-MM-DD') and, when given, an hour 0-23 and a minute 0-59")
+        }
+        guard let workout = body["workout"] as? [String: Any] else { return refuse("A scheduled workout needs a workout") }
+        let activityName = workout["activity"] as? String ?? ""
+        guard let activity = activities[activityName] else {
+            return refuse("WorkoutKit has no activity '\(activityName)'")
+        }
+        guard CustomWorkout.supportsActivity(activity) else {
+            return refuse("WorkoutKit cannot schedule a custom \(activityName) workout")
+        }
+        let locationName = workout["location"] as? String ?? "unknown"
+        guard var location = locations[locationName] else {
+            return refuse("A workout's location is indoor, outdoor or unknown, not '\(locationName)'")
+        }
+        // CustomWorkout has no swimming location of its own (and no pool
+        // length; the watch asks for that when the swim starts): a pool swim
+        // is indoor, open water outdoor.
+        if activity == .swimming, location == .unknown {
+            switch workout["swimmingLocation"] as? String {
+            case "openWater": location = .outdoor
+            case "pool", nil: location = .indoor
+            default: break
+            }
+        }
+        let context = "\(activityName) (\(locationName == "unknown" && location != .unknown ? (location == .indoor ? "indoor" : "outdoor") : locationName))"
+        var dropped: [String] = []
+
+        func step(_ value: Any?, at place: String) -> Result<WorkoutStep, CraftScheduledWorkoutsError> {
+            guard let body = value as? [String: Any] else {
+                return .failure(CraftScheduledWorkoutsError(message: "\(place) needs a goal", code: "INVALID_ARGUMENT"))
+            }
+            let parsedGoal: (goal: WorkoutGoal, name: String)
+            switch goal(body["goal"]) {
+            case .success(let value): parsedGoal = value
+            case .failure(let error): return .failure(CraftScheduledWorkoutsError(message: "\(place): \(error.message)", code: error.code))
+            }
+            guard CustomWorkout.supportsGoal(parsedGoal.goal, activity: activity, location: location) else {
+                return .failure(CraftScheduledWorkoutsError(message: "WorkoutKit refuses a \(parsedGoal.name) goal for \(context) (\(place))", code: "UNSUPPORTED_GOAL"))
+            }
+            var result = WorkoutStep(goal: parsedGoal.goal)
+            if let alertBody = body["alert"], !(alertBody is NSNull) {
+                switch alert(alertBody) {
+                case .success(let parsed):
+                    if CustomWorkout.supportsAlert(parsed.alert, activity: activity, location: location) {
+                        result.alert = parsed.alert
+                    } else {
+                        dropped.append("\(place): \(parsed.name) alert, which WorkoutKit refuses for \(context)")
+                    }
+                case .failure(let error):
+                    dropped.append("\(place): \(error.message)")
+                }
+            }
+            if #available(iOS 18.0, *), let name = (body["displayName"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines), !name.isEmpty {
+                result.displayName = String(name.prefix(64))
+            }
+            return .success(result)
+        }
+
+        var warmup: WorkoutStep?
+        if let value = workout["warmup"], !(value is NSNull) {
+            switch step(value, at: "warmup") {
+            case .success(let parsed): warmup = parsed
+            case .failure(let error): return .failure(error)
+            }
+        }
+        var cooldown: WorkoutStep?
+        if let value = workout["cooldown"], !(value is NSNull) {
+            switch step(value, at: "cooldown") {
+            case .success(let parsed): cooldown = parsed
+            case .failure(let error): return .failure(error)
+            }
+        }
+        var blocks: [IntervalBlock] = []
+        for (blockIndex, value) in (workout["blocks"] as? [Any] ?? []).enumerated() {
+            let block = value as? [String: Any] ?? [:]
+            let iterations = number(block["iterations"] ?? 1).map { Int($0) } ?? 0
+            guard iterations >= 1 else { return refuse("block \(blockIndex + 1) needs iterations of 1 or more") }
+            var steps: [IntervalStep] = []
+            for (stepIndex, entry) in (block["steps"] as? [Any] ?? []).enumerated() {
+                let place = "block \(blockIndex + 1) step \(stepIndex + 1)"
+                let entry = entry as? [String: Any] ?? [:]
+                let purpose: IntervalStep.Purpose
+                switch entry["purpose"] as? String {
+                case "work": purpose = .work
+                case "recovery": purpose = .recovery
+                default: return refuse("\(place) needs a purpose: work or recovery")
+                }
+                switch step(entry["step"], at: place) {
+                case .success(let parsed): steps.append(IntervalStep(purpose, step: parsed))
+                case .failure(let error): return .failure(error)
+                }
+            }
+            guard !steps.isEmpty else { return refuse("block \(blockIndex + 1) has no steps") }
+            blocks.append(IntervalBlock(steps: steps, iterations: iterations))
+        }
+        guard warmup != nil || cooldown != nil || !blocks.isEmpty else {
+            return refuse("A scheduled workout needs at least one step")
+        }
+        let displayName = (workout["displayName"] as? String)?.trimmingCharacters(in: .whitespacesAndNewlines)
+        let custom = CustomWorkout(
+            activity: activity,
+            location: location,
+            displayName: displayName?.isEmpty == false ? displayName : nil,
+            warmup: warmup,
+            blocks: blocks,
+            cooldown: cooldown
+        )
+        return .success(Built(plan: WorkoutPlan(.custom(custom), id: id), date: date, droppedAlerts: dropped))
+    }
+}
+
+#endif

package/dist/ios/templates/project.yml.template

@@ -39,6 +39,7 @@ targets:
       SWIFT_VERSION: "5.0"
       ASSETCATALOG_COMPILER_APPICON_NAME: AppIcon
 {{CRAFT_RUNTIME_SETTINGS}}
+{{FEATURE_SETTINGS}}
 {{NATIVE_DEPENDENCIES}}
 {{NATIVE_TARGETS}}
 # A shared scheme, so CI (Xcode Cloud, a fresh checkout's xcodebuild) can

package/dist/mobile.js

@@ -981,6 +981,72 @@ var heartRate = {
   onDevice: (callback) => hrSubscribe(heartRateWatch.devices, callback),
   onState: (callback) => hrSubscribe(heartRateWatch.states, callback)
 };
+var SCHEDULED_AUTHORIZATIONS = ["authorized", "denied", "notDetermined", "restricted", "unsupported"];
+function nativeScheduledWorkouts() {
+  const craft = getCraftRoot();
+  if (!craft?.scheduledWorkouts || craft.capabilities?.scheduledWorkouts !== true)
+    return;
+  return craft.scheduledWorkouts;
+}
+function scheduledWorkoutsUnsupported() {
+  return Object.assign(new Error("unsupported"), { code: "UNSUPPORTED" });
+}
+function scheduledAuthorization(value) {
+  return SCHEDULED_AUTHORIZATIONS.includes(value) ? value : "unsupported";
+}
+function normalizeScheduledWorkout(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const row = value;
+  if (typeof row.id !== "string" || !row.id || typeof row.date !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(row.date))
+    return null;
+  const out = { id: row.id.toLowerCase(), date: row.date, complete: row.complete === true };
+  if (typeof row.hour === "number" && Number.isFinite(row.hour))
+    out.hour = row.hour;
+  if (typeof row.minute === "number" && Number.isFinite(row.minute))
+    out.minute = row.minute;
+  return out;
+}
+async function scheduledCall(method, normalize, ...args) {
+  const native = nativeScheduledWorkouts();
+  if (typeof native?.[method] !== "function")
+    throw scheduledWorkoutsUnsupported();
+  return normalize(await native[method](...args));
+}
+var scheduledWorkouts = {
+  isAvailable() {
+    return typeof nativeScheduledWorkouts()?.isSupported === "function";
+  },
+  supports(method) {
+    return typeof nativeScheduledWorkouts()?.[method] === "function";
+  },
+  async isSupported() {
+    const native = nativeScheduledWorkouts();
+    if (typeof native?.isSupported !== "function")
+      return false;
+    try {
+      return await native.isSupported() === true;
+    } catch {
+      return false;
+    }
+  },
+  authorization: () => scheduledCall("authorization", scheduledAuthorization),
+  requestAuthorization: () => scheduledCall("requestAuthorization", scheduledAuthorization),
+  list: () => scheduledCall("list", (value) => Array.isArray(value) ? value.map(normalizeScheduledWorkout).filter((row) => row !== null) : []),
+  schedule: (plan) => {
+    if (!plan || typeof plan !== "object" || typeof plan.id !== "string")
+      return Promise.reject(Object.assign(new Error("schedule needs a plan with an id"), { code: "INVALID_ARGUMENT" }));
+    return scheduledCall("schedule", (value) => {
+      const row = value && typeof value === "object" ? value : {};
+      const out = { id: typeof row.id === "string" ? row.id.toLowerCase() : plan.id.toLowerCase() };
+      if (Array.isArray(row.droppedAlerts) && row.droppedAlerts.length)
+        out.droppedAlerts = row.droppedAlerts.filter((item) => typeof item === "string");
+      return out;
+    }, plan);
+  },
+  remove: (id) => scheduledCall("remove", (value) => value === true, id),
+  removeAll: () => scheduledCall("removeAll", (value) => typeof value === "number" && Number.isFinite(value) ? value : 0)
+};
 var deepLinks = {
   async getInitialURL() {
     return normalizeDeepLinkURL(await getCraftRoot()?.deepLinks?.getInitialURL?.());
@@ -1479,10 +1545,13 @@ export {
   snapshots,
   share,
   secureStorage,
+  scheduledWorkoutsUnsupported,
+  scheduledWorkouts,
   refresh,
   pushNotifications,
   permissions,
   notifications,
+  normalizeScheduledWorkout,
   normalizeNowPlaying,
   normalizeHeartRateState,
   normalizeHeartRateSamples,

package/package.json

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