craft-native 0.0.276 → 0.0.290

package/dist/ios/templates/CraftWatchApp.swift.template

@@ -1,4 +1,5 @@
 import SwiftUI
+import HealthKit
 import WatchConnectivity
 
 @main
@@ -15,14 +16,28 @@ struct {{APP_NAME}}WatchApp: App {
 
 @MainActor
 final class CraftWatchSession: NSObject, ObservableObject {
+    private static let protocolVersion = 1
+    private static let persistedStateKey = "craft.watch.state.v1"
+    private static let healthKitEnabled = {{HEALTH_KIT_ENABLED}}
+
     @Published private(set) var isPhoneReachable = false
     @Published private(set) var isRecording = false
     @Published private(set) var isPaused = false
     @Published private(set) var distanceMeters = 0.0
     @Published private(set) var durationSeconds = 0.0
     @Published private(set) var status = "Ready"
+    @Published private(set) var plannedSession: [String: Any]?
+    @Published private(set) var heartRateBpm: Double?
+    @Published private(set) var heartRateZone: Int?
+    @Published private(set) var lastWorkout: [String: Any]?
 
     private let session: WCSession?
+    private let healthStore = HKHealthStore()
+    private var stateVersion = 0
+    private var workoutSession: HKWorkoutSession?
+    private var workoutBuilder: HKLiveWorkoutBuilder?
+    private var workoutId: String?
+    private var workoutStartedAt: Date?
 
     override init() {
         if WCSession.isSupported() {
@@ -32,49 +47,320 @@ final class CraftWatchSession: NSObject, ObservableObject {
         }
         super.init()
         session?.delegate = self
+        restoreState()
         session?.activate()
     }
 
     func toggleRecording() {
-        let action: String
         if !isRecording {
-            action = "start"
+            if Self.healthKitEnabled {
+                startHealthWorkout { [weak self] started in
+                    if started { self?.send(action: "start") }
+                }
+            } else {
+                send(action: "start")
+            }
         } else if isPaused {
-            action = "resume"
+            resumeHealthWorkout()
+            send(action: "resume")
         } else {
-            action = "pause"
+            pauseHealthWorkout()
+            send(action: "pause")
         }
-        send(action: action)
     }
 
     func finishRecording() {
-        send(action: "finish")
+        if Self.healthKitEnabled, workoutSession != nil {
+            endHealthWorkout { [weak self] _ in self?.send(action: "finish") }
+        } else {
+            send(action: "finish")
+        }
+    }
+
+    /// The phone sends a planned session through application context. Context
+    /// is the right transport here: it replaces stale plans while the watch is
+    /// offline and is replayed when the app launches again.
+    func clearPlannedSession() {
+        plannedSession = nil
+        persistState()
+        publishState()
     }
 
     private func send(action: String) {
         guard let session, session.activationState == .activated else {
             status = "Open WildLoop on iPhone"
+            persistState()
             return
         }
-        let message: [String: Any] = ["type": "recording-control", "action": action]
+        let message: [String: Any] = [
+            "protocolVersion": Self.protocolVersion,
+            "requestId": UUID().uuidString,
+            "type": "recording-control",
+            "action": action,
+        ]
         if session.isReachable {
             session.sendMessage(message, replyHandler: { [weak self] reply in
                 Task { @MainActor in self?.apply(reply) }
             }, errorHandler: { [weak self] _ in
-                Task { @MainActor in self?.status = "Could not reach iPhone" }
+                Task { @MainActor in
+                    self?.status = "Could not reach iPhone"
+                    self?.persistState()
+                    self?.publishState()
+                }
             })
         } else {
             session.transferUserInfo(message)
             status = "Command queued"
+            persistState()
+            publishState()
         }
     }
 
     private func apply(_ payload: [String: Any]) {
+        if let plan = payload["plan"] as? [String: Any], payload["type"] as? String == "planned-session" {
+            plannedSession = plan
+            status = "Plan ready"
+        } else if let plan = payload["plannedSession"] as? [String: Any] {
+            plannedSession = plan
+        }
         if let recording = payload["recording"] as? Bool { isRecording = recording }
         if let paused = payload["paused"] as? Bool { isPaused = paused }
         if let distance = payload["distanceMeters"] as? Double { distanceMeters = max(distance, 0) }
         if let duration = payload["durationSeconds"] as? Double { durationSeconds = max(duration, 0) }
         if let value = payload["status"] as? String { status = value }
+        if let heartRate = payload["heartRateBpm"] as? Double, heartRate.isFinite { heartRateBpm = max(heartRate, 0) }
+        if let zone = payload["heartRateZone"] as? Int { heartRateZone = min(max(zone, 1), 5) }
+        if let workout = payload["workout"] as? [String: Any] { lastWorkout = workout }
+        persistState()
+        publishState()
+    }
+
+    private func restoreState() {
+        guard let state = UserDefaults.standard.dictionary(forKey: Self.persistedStateKey) else { return }
+        if let recording = state["recording"] as? Bool { isRecording = recording }
+        if let paused = state["paused"] as? Bool { isPaused = paused }
+        if let distance = state["distanceMeters"] as? Double { distanceMeters = max(distance, 0) }
+        if let duration = state["durationSeconds"] as? Double { durationSeconds = max(duration, 0) }
+        if let value = state["status"] as? String { status = value }
+        if let version = state["stateVersion"] as? Int { stateVersion = max(version, stateVersion) }
+        plannedSession = state["plannedSession"] as? [String: Any]
+        if let heartRate = state["heartRateBpm"] as? Double { heartRateBpm = max(heartRate, 0) }
+        if let zone = state["heartRateZone"] as? Int { heartRateZone = min(max(zone, 1), 5) }
+        lastWorkout = state["lastWorkout"] as? [String: Any]
+    }
+
+    private func persistState() {
+        stateVersion += 1
+        var state: [String: Any] = [
+            "protocolVersion": Self.protocolVersion,
+            "stateVersion": stateVersion,
+            "recording": isRecording,
+            "paused": isPaused,
+            "distanceMeters": distanceMeters,
+            "durationSeconds": durationSeconds,
+            "status": status,
+        ]
+        if let plannedSession { state["plannedSession"] = plannedSession }
+        if let heartRateBpm { state["heartRateBpm"] = heartRateBpm }
+        if let heartRateZone { state["heartRateZone"] = heartRateZone }
+        if let lastWorkout { state["lastWorkout"] = lastWorkout }
+        UserDefaults.standard.set(state, forKey: Self.persistedStateKey)
+    }
+
+    private func publishState() {
+        guard let session, session.activationState == .activated else { return }
+        var state: [String: Any] = [
+            "protocolVersion": Self.protocolVersion,
+            "stateVersion": stateVersion,
+            "type": "watch-state",
+            "recording": isRecording,
+            "paused": isPaused,
+            "distanceMeters": distanceMeters,
+            "durationSeconds": durationSeconds,
+            "status": status,
+        ]
+        if let plannedSession { state["plannedSession"] = plannedSession }
+        if let heartRateBpm { state["heartRateBpm"] = heartRateBpm }
+        if let heartRateZone { state["heartRateZone"] = heartRateZone }
+        if let lastWorkout { state["workout"] = lastWorkout }
+        try? session.updateApplicationContext(state)
+    }
+
+    private func startHealthWorkout(completion: @escaping (Bool) -> Void) {
+        guard HKHealthStore.isHealthDataAvailable() else {
+            status = "HealthKit unavailable"
+            persistState()
+            completion(false)
+            return
+        }
+        let shareTypes: Set<HKSampleType> = [HKObjectType.workoutType()]
+        var readTypes: Set<HKObjectType> = [HKObjectType.workoutType()]
+        if let heartRate = HKQuantityType.quantityType(forIdentifier: .heartRate) { readTypes.insert(heartRate) }
+        if let distance = HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning) { readTypes.insert(distance) }
+        if let energy = HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned) { readTypes.insert(energy) }
+        healthStore.requestAuthorization(toShare: shareTypes, read: readTypes) { [weak self] success, error in
+            DispatchQueue.main.async {
+                guard let self else { return completion(false) }
+                guard success else {
+                    self.status = error?.localizedDescription ?? "HealthKit authorization denied"
+                    self.persistState()
+                    return completion(false)
+                }
+                self.beginHealthWorkout(completion: completion)
+            }
+        }
+    }
+
+    private func beginHealthWorkout(completion: @escaping (Bool) -> Void) {
+        guard workoutSession == nil else { completion(true); return }
+        let configuration = HKWorkoutConfiguration()
+        configuration.activityType = .running
+        configuration.locationType = .outdoor
+        do {
+            let session = try HKWorkoutSession(healthStore: healthStore, configuration: configuration)
+            let builder = session.associatedWorkoutBuilder()
+            session.delegate = self
+            builder.delegate = self
+            builder.shouldCollectWorkoutEvents = true
+            builder.dataSource = HKLiveWorkoutDataSource(healthStore: healthStore, workoutConfiguration: configuration)
+            workoutSession = session
+            workoutBuilder = builder
+            workoutId = UUID().uuidString.lowercased()
+            let start = Date()
+            workoutStartedAt = start
+            session.startActivity(with: start)
+            builder.beginCollection(withStart: start) { [weak self] success, error in
+                DispatchQueue.main.async {
+                    guard let self else { return completion(false) }
+                    guard success else {
+                        self.clearHealthWorkout()
+                        self.status = error?.localizedDescription ?? "Workout could not start"
+                        self.persistState()
+                        return completion(false)
+                    }
+                    self.isRecording = true
+                    self.isPaused = false
+                    self.status = "Recording"
+                    self.persistState()
+                    self.publishState()
+                    completion(true)
+                }
+            }
+        } catch {
+            status = error.localizedDescription
+            persistState()
+            completion(false)
+        }
+    }
+
+    private func pauseHealthWorkout() {
+        guard let workoutSession else { return }
+        workoutSession.pause()
+        isPaused = true
+        status = "Paused"
+        persistState()
+        publishState()
+    }
+
+    private func resumeHealthWorkout() {
+        guard let workoutSession else { return }
+        workoutSession.resume()
+        isPaused = false
+        status = "Recording"
+        persistState()
+        publishState()
+    }
+
+    private func endHealthWorkout(completion: @escaping ([String: Any]?) -> Void) {
+        guard let workoutSession, let workoutBuilder, let id = workoutId else {
+            completion(nil)
+            return
+        }
+        let end = Date()
+        workoutSession.end()
+        workoutBuilder.endCollection(withEnd: end) { [weak self] success, error in
+            guard let self else { return }
+            guard success else {
+                DispatchQueue.main.async {
+                    self.status = error?.localizedDescription ?? "Workout could not finish"
+                    self.persistState()
+                    completion(nil)
+                }
+                return
+            }
+            workoutBuilder.finishWorkout { [weak self] workout, finishError in
+                DispatchQueue.main.async {
+                    guard let self else { return completion(nil) }
+                    guard let workout else {
+                        self.status = finishError?.localizedDescription ?? "Workout could not be saved"
+                        self.persistState()
+                        return completion(nil)
+                    }
+                    let result: [String: Any] = [
+                        "id": id,
+                        "workoutId": workout.uuid.uuidString,
+                        "startDate": (self.workoutStartedAt ?? workout.startDate).timeIntervalSince1970 * 1000,
+                        "endDate": end.timeIntervalSince1970 * 1000,
+                        "durationSeconds": workout.duration,
+                        "distanceMeters": self.distanceMeters,
+                    ]
+                    self.lastWorkout = result
+                    self.isRecording = false
+                    self.isPaused = false
+                    self.status = "Saved to Apple Health"
+                    self.clearHealthWorkout()
+                    self.persistState()
+                    self.publishState()
+                    completion(result)
+                }
+            }
+        }
+    }
+
+    private func clearHealthWorkout() {
+        workoutSession = nil
+        workoutBuilder = nil
+        workoutId = nil
+        workoutStartedAt = nil
+    }
+
+    private func updateHealthMetrics(_ builder: HKLiveWorkoutBuilder) {
+        if let heartRate = HKQuantityType.quantityType(forIdentifier: .heartRate),
+           let value = builder.statistics(for: heartRate)?.mostRecentQuantity()?.doubleValue(for: HKUnit.count().unitDivided(by: .minute())),
+           value.isFinite {
+            heartRateBpm = max(value, 0)
+            let maximum = (plannedSession?["maxHeartRateBpm"] as? Double) ?? 190
+            heartRateZone = min(max(Int(ceil(value / maximum * 5)), 1), 5)
+        }
+        if let distance = HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning),
+           let value = builder.statistics(for: distance)?.sumQuantity()?.doubleValue(for: .meter()),
+           value.isFinite {
+            distanceMeters = max(value, 0)
+        }
+        if let start = workoutStartedAt { durationSeconds = max(Date().timeIntervalSince(start), 0) }
+        persistState()
+        publishState()
+    }
+}
+
+extension CraftWatchSession: HKWorkoutSessionDelegate, HKLiveWorkoutBuilderDelegate {
+    nonisolated func workoutSession(_ workoutSession: HKWorkoutSession, didChangeTo toState: HKWorkoutSessionState, from fromState: HKWorkoutSessionState, date: Date) {}
+
+    nonisolated func workoutSession(_ workoutSession: HKWorkoutSession, didFailWithError error: Error) {
+        Task { @MainActor in
+            status = error.localizedDescription
+            isRecording = false
+            isPaused = false
+            clearHealthWorkout()
+            persistState()
+            publishState()
+        }
+    }
+
+    nonisolated func workoutBuilderDidCollectEvent(_ workoutBuilder: HKLiveWorkoutBuilder) {}
+
+    nonisolated func workoutBuilder(_ workoutBuilder: HKLiveWorkoutBuilder, didCollectDataOf types: Set<HKSampleType>) {
+        Task { @MainActor in updateHealthMetrics(workoutBuilder) }
     }
 }
 
@@ -84,11 +370,15 @@ extension CraftWatchSession: WCSessionDelegate {
             isPhoneReachable = session.isReachable
             status = error == nil ? "Ready" : "Connection unavailable"
             apply(session.receivedApplicationContext)
+            publishState()
         }
     }
 
     nonisolated func sessionReachabilityDidChange(_ session: WCSession) {
-        Task { @MainActor in isPhoneReachable = session.isReachable }
+        Task { @MainActor in
+            isPhoneReachable = session.isReachable
+            if session.isReachable { publishState() }
+        }
     }
 
     nonisolated func session(_ session: WCSession, didReceiveApplicationContext applicationContext: [String: Any]) {
@@ -129,6 +419,10 @@ struct CraftWatchRecordingView: View {
                     metric(distance, label: "Distance")
                     metric(duration, label: "Time")
                 }
+                if let heartRate = session.heartRateBpm {
+                    metric(String(format: "%.0f bpm", heartRate), label: "Heart rate")
+                    if let zone = session.heartRateZone { Text("Zone \(zone) of 5").font(.caption2).foregroundStyle(.secondary) }
+                }
                 Button(session.isRecording && !session.isPaused ? "Pause" : session.isPaused ? "Resume" : "Start") {
                     session.toggleRecording()
                 }

package/dist/ios/templates/WatchExtension.Info.plist.template

@@ -30,5 +30,6 @@
         <key>NSExtensionPointIdentifier</key>
         <string>com.apple.watchkit</string>
     </dict>
+    {{HEALTH_USAGE_DESCRIPTIONS}}
 </dict>
 </plist>

package/dist/macos/templates/CraftNativeMutation.swift

@@ -115,6 +115,9 @@ final class CraftNativeMutationDocument {
                     // A child crossing parents needs the committed tree to be
                     // reconciled so the host can move its existing native view.
                     requiresFullRender = true
+                case "replaceChildren":
+                    let parentId = try replaceChildren(operation, nodes: &candidateNodes)
+                    appendUnique(parentId, to: &affectedNodeIds)
                 case "removeNode":
                     if let id = operation["id"] as? String, let parent = candidateNodes[id]?.parent {
                         appendUnique(parent, to: &affectedNodeIds)
@@ -287,6 +290,54 @@ final class CraftNativeMutationDocument {
         return previousParentId
     }
 
+    /// Replaces a container's ordered child snapshot in one atomic mutation.
+    ///
+    /// The list protocol uses this operation when a keyed `:for` expansion
+    /// produces a new row set. Existing nodes may stay attached to the same
+    /// parent; removed children become detached and can be reused or removed
+    /// by later operations in the same batch.
+    private func replaceChildren(_ operation: [String: Any], nodes: inout [String: Node]) throws -> String {
+        let parentId = try requiredId(operation, field: "parentId", name: "replaceChildren")
+        guard var parent = nodes[parentId] else {
+            throw CraftNativeMutationFailure("UNKNOWN_PARENT", "node \(parentId) does not exist")
+        }
+        guard acceptsChildren(parent.type) else {
+            throw CraftNativeMutationFailure("INVALID_PARENT", "node \(parentId) cannot contain child nodes")
+        }
+        guard let values = operation["children"] as? [Any] else {
+            throw CraftNativeMutationFailure("INVALID_CHILDREN", "replaceChildren.children must be an array")
+        }
+        var childIds: [String] = []
+        for value in values {
+            guard let childId = value as? String, !childId.isEmpty else {
+                throw CraftNativeMutationFailure("INVALID_CHILDREN", "replaceChildren.children must contain non-empty ids")
+            }
+            guard !childIds.contains(childId) else {
+                throw CraftNativeMutationFailure("DUPLICATE_CHILD", "child \(childId) appears more than once")
+            }
+            guard let child = nodes[childId] else {
+                throw CraftNativeMutationFailure("UNKNOWN_NODE", "node \(childId) does not exist")
+            }
+            guard childId != parentId, !descendants(of: childId, nodes: nodes).contains(parentId) else {
+                throw CraftNativeMutationFailure("CYCLE", "attaching node \(childId) would create a cycle")
+            }
+            guard child.parent == nil || child.parent == parentId else {
+                throw CraftNativeMutationFailure("NODE_ATTACHED", "node \(childId) already has a parent")
+            }
+            childIds.append(childId)
+        }
+        let removedChildIds = parent.children.filter { !childIds.contains($0) }
+        for oldChildId in removedChildIds {
+            for descendant in descendants(of: oldChildId, nodes: nodes).union([oldChildId]) {
+                nodes.removeValue(forKey: descendant)
+            }
+        }
+        parent.children = childIds
+        nodes[parentId] = parent
+        for childId in childIds { nodes[childId]?.parent = parentId }
+        return parentId
+    }
+
     private func removeNode(
         _ operation: [String: Any],
         nodes: inout [String: Node],

package/dist/mobile.js

@@ -223,6 +223,55 @@ var permissions = {
     }
   }
 };
+var files = {
+  async pickFile(options = {}) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.files) {
+      return craft.files.pickFile(options);
+    }
+    if (typeof document === "undefined") {
+      throw new Error("File picker not available. Must run in Craft or a browser.");
+    }
+    return new Promise((resolve, reject) => {
+      const input = document.createElement("input");
+      input.type = "file";
+      if (options.contentTypes?.length)
+        input.accept = options.contentTypes.join(",");
+      const requested = Number(options.maxSelections);
+      const maxSelections = Number.isFinite(requested) && requested > 0 ? Math.min(20, Math.floor(requested)) : 1;
+      input.multiple = maxSelections > 1;
+      input.style.display = "none";
+      let settled = false;
+      const finish = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        input.remove();
+        result();
+      };
+      input.addEventListener("cancel", () => finish(() => resolve([])), { once: true });
+      input.onchange = () => {
+        const chosen = Array.from(input.files ?? []).slice(0, maxSelections);
+        const limit = Number(options.maxBytes);
+        if (Number.isFinite(limit) && limit > 0) {
+          const oversized = chosen.find((file) => file.size > limit);
+          if (oversized) {
+            finish(() => reject(Object.assign(new Error("The selected file is too large"), { code: "FILE_TOO_LARGE" })));
+            return;
+          }
+        }
+        finish(() => resolve(chosen.map((file) => ({
+          path: URL.createObjectURL(file),
+          name: file.name,
+          type: file.type || "application/octet-stream",
+          size: file.size
+        }))));
+      };
+      document.body.append(input);
+      input.click();
+    });
+  }
+};
 var camera = {
   async takePicture(options = {}) {
     const craft = getCraftMobile();
@@ -1877,6 +1926,7 @@ export {
   deepLinks,
   device,
   dialog,
+  files,
   haptics,
   health,
   heartRate,

package/dist/package.d.ts

@@ -29,6 +29,16 @@ export interface PackageConfig {
     platforms?: Array<'macos' | 'windows' | 'linux'>;
     /** macOS-specific options */
     macos?: {
+        /** Preserve a prebuilt .app, including its resources and Info.plist. */
+        appBundlePath?: string;
+        /** Use existing notarytool credentials stored in the macOS keychain. */
+        notaryKeychainProfile?: string;
+        /** App Store Connect API-key authentication for notarization. */
+        notaryApiKey?: {
+            path: string;
+            keyId: string;
+            issuer: string;
+        };
         /** Create DMG installer */
         dmg?: boolean;
         /** Create PKG installer */
@@ -46,6 +56,12 @@ export interface PackageConfig {
         installerIdentity?: string;
         /** Path to the entitlements plist applied when signing the app */
         entitlements?: string;
+        /** Entitlements for bundled helper executables, separate from the main app. */
+        helperEntitlements?: string;
+        /** Keychain containing the application and installer signing identities. */
+        signingKeychain?: string;
+        /** Privacy manifest copied to `Contents/Resources/PrivacyInfo.xcprivacy`. */
+        privacyManifest?: string;
         /** Path to a `.provisionprofile` embedded as `Contents/embedded.provisionprofile` */
         provisioningProfile?: string;
         /** Build number (`CFBundleVersion`). Defaults to `version`. */
@@ -198,19 +214,29 @@ export declare function codesignArguments(opts: {
     identity: string;
     entitlements?: string;
     hardenedRuntime?: boolean;
+    deep?: boolean;
+    identifier?: string;
+    keychain?: string;
 }): string[];
 /** Build the `productbuild` argument list for a Mac App Store submission package. */
 export declare function productbuildArguments(opts: {
     appBundlePath: string;
     outputPath: string;
     identity: string;
+    keychain?: string;
 }): string[];
 /** Build the `xcrun notarytool submit` argument list for a DMG or PKG. */
 export declare function notarytoolArguments(opts: {
     artifactPath: string;
-    appleId: string;
-    applePassword: string;
-    teamId: string;
+    appleId?: string;
+    applePassword?: string;
+    teamId?: string;
+    keychainProfile?: string;
+    apiKey?: {
+        path: string;
+        keyId: string;
+        issuer: string;
+    };
 }): string[];
 export declare function dmgCapacityMegabytes(contentBytes: number): number;
 export declare function dmgCreateArguments(opts: {

package/dist/types.d.ts

@@ -569,6 +569,8 @@ export interface AppConfig {
  * Craft System Tray API (available as window.craft.tray in WebView)
  */
 export interface CraftTrayAPI {
+    /** SF Symbol name, image path, or base64 image data URL. */
+    setIcon(icon: string): Promise<void>;
     /**
      * Update the system tray title/text
      * Updates in real-time (60fps max)
@@ -723,6 +725,11 @@ export interface AppInfo {
      * Platform (macos, linux, windows)
      */
     platform: string;
+    /** Whether platform file access is restricted to explicit user grants. */
+    sandboxed?: boolean;
+    bundleId?: string;
+    bundlePath?: string;
+    executablePath?: string;
 }
 /**
  * Notification options
@@ -1163,6 +1170,23 @@ export interface CraftBridgeAPI {
      * System tray control (desktop only)
      */
     tray?: CraftTrayAPI;
+    /** Native status-item arrangement and collapse controls (macOS). */
+    menubar?: {
+        init(): Promise<void>;
+        collapse(): Promise<void>;
+        expand(): Promise<void>;
+        toggle(): Promise<void>;
+        getState(): Promise<{
+            collapsed: boolean;
+            initialized: boolean;
+            separatorHidden: boolean;
+        }>;
+        setAutoCollapse(seconds: number): Promise<void>;
+        setSeparatorHidden(hidden: boolean): Promise<void>;
+        onStateChange(callback: (state: {
+            collapsed: boolean;
+        }) => void): () => void;
+    };
     /**
      * Window control (desktop)
      */
@@ -1207,6 +1231,7 @@ export interface CraftBridgeAPI {
     /**
      * Screen-sharing and screen-recording detection (macOS)
      */
+    timers?: CraftTimersAPI;
     screenSharing?: CraftScreenSharingAPI;
     /**
      * Trigger one haptic tap on a Force Touch trackpad (macOS), as
@@ -2326,3 +2351,10 @@ declare global {
         craft?: CraftBridgeAPI & CraftEventEmitter;
     }
 }
+/** Native background deadlines, independent of hidden WebKit DOM timers. */
+export interface CraftTimersAPI {
+    /** Wait up to one day. Aborting rejects with AbortError and releases native resources. */
+    sleep(delayMs: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/package.json

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