craft-native 0.0.247 → 0.0.248

package/dist/ios/templates/CraftNativeServices.swift

@@ -313,8 +313,10 @@ final class CraftNativeSounds {
     func play(id: String, url: URL, options: [String: Any], answer: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
         stop(id: id, fadeOut: 0)
         let loop = options["loop"] as? Bool ?? false
-        let volume = Float(min(max((options["volume"] as? NSNumber)?.doubleValue ?? 1, 0), 1))
-        let fadeIn = max(0, (options["fadeIn"] as? NSNumber)?.doubleValue ?? 0) / 1000
+        let volumeValue = craftNativeNumber(options["volume"]).map { $0.doubleValue }.flatMap { $0.isFinite ? $0 : nil } ?? 1
+        let fadeInValue = craftNativeNumber(options["fadeIn"]).map { $0.doubleValue }.flatMap { $0.isFinite ? $0 : nil } ?? 0
+        let volume = Float(min(max(volumeValue, 0), 1))
+        let fadeIn = max(0, fadeInValue) / 1000
         Self.claimSession(respectSilentSwitch: options["respectSilentSwitch"] as? Bool ?? true)
         let item = AVPlayerItem(url: url)
         let player = AVQueuePlayer()

package/dist/ios/templates/CraftNativeUI.swift

@@ -1,4 +1,5 @@
 import AuthenticationServices
+import CoreFoundation
 import SafariServices
 import UIKit
 import WebKit
@@ -54,7 +55,12 @@ enum CraftPresenter {
     /// view's points, as a rect. Nil when it is not one.
     static func rect(_ value: Any?) -> CGRect? {
         guard let value = value as? [String: Any] else { return nil }
-        func number(_ key: String) -> CGFloat? { (value[key] as? NSNumber).map { CGFloat(truncating: $0) } }
+        func number(_ key: String) -> CGFloat? {
+            guard let number = value[key] as? NSNumber,
+                  CFGetTypeID(number) != CFBooleanGetTypeID() else { return nil }
+            let value = CGFloat(truncating: number)
+            return value.isFinite ? value : nil
+        }
         guard let x = number("x"), let y = number("y") else { return nil }
         return CGRect(x: x, y: y, width: max(0, number("width") ?? 0), height: max(0, number("height") ?? 0))
     }
@@ -464,7 +470,9 @@ extension CraftSignInWithApple: ASAuthorizationControllerDelegate, ASAuthorizati
 /// show the same glyph the system's own controls use.
 enum CraftSymbols {
     static func image(named name: String, options: [String: Any]) -> String? {
-        let pointSize = (options["pointSize"] as? NSNumber).map { CGFloat(truncating: $0) } ?? 17
+        let pointSize = craftNativeNumber(options["pointSize"])
+            .map { CGFloat(truncating: $0) }
+            .flatMap { $0.isFinite ? $0 : nil } ?? 17
         let weight: UIImage.SymbolWeight
         switch options["weight"] as? String {
         case "ultraLight": weight = .ultraLight

package/dist/ios/templates/testing/DriverTests.swift.template

@@ -276,6 +276,7 @@ final class DriverTests: XCTestCase {
             let host = XCUIApplication(bundleIdentifier: "{{BUNDLE_PREFIX}}.host")
             host.launchArguments = ["--craft-universal-link", url.absoluteString]
             host.launch()
+            host.buttons["craft-driver-open-universal-link"].tap()
             let opened = app.wait(for: .runningForeground, timeout: 75)
             if !opened {
                 post("/save?name=universal-link-host.txt", Data(host.debugDescription.utf8))

package/dist/ios/templates/testing/HostApp.swift

@@ -7,8 +7,15 @@ struct HostApp: App {
 
     var body: some Scene {
         WindowGroup {
-            Text(status).accessibilityIdentifier("craft-driver-status")
-                .task { await openUniversalLinkIfRequested() }
+            VStack {
+                Text(status).accessibilityIdentifier("craft-driver-status")
+                // XCTest must finish acquiring the host's launch assertion
+                // before a handoff can move another application foreground.
+                Button("Open Universal Link") {
+                    Task { await openUniversalLinkIfRequested() }
+                }
+                .accessibilityIdentifier("craft-driver-open-universal-link")
+            }
         }
     }
 

package/dist/macos/templates/CraftNativeMutation.swift

@@ -108,6 +108,13 @@ final class CraftNativeMutationDocument {
                 case "moveChild":
                     try moveChild(operation, nodes: &candidateNodes)
                     if let id = operation["parentId"] as? String { appendUnique(id, to: &affectedNodeIds) }
+                case "reparentChild":
+                    let previousParent = try reparentChild(operation, nodes: &candidateNodes)
+                    if let id = operation["parentId"] as? String { appendUnique(id, to: &affectedNodeIds) }
+                    appendUnique(previousParent, to: &affectedNodeIds)
+                    // A child crossing parents needs the committed tree to be
+                    // reconciled so the host can move its existing native view.
+                    requiresFullRender = true
                 case "removeNode":
                     if let id = operation["id"] as? String, let parent = candidateNodes[id]?.parent {
                         appendUnique(parent, to: &affectedNodeIds)
@@ -251,6 +258,35 @@ final class CraftNativeMutationDocument {
         nodes[parentId] = parent
     }
 
+    private func reparentChild(_ operation: [String: Any], nodes: inout [String: Node]) throws -> String {
+        let parentId = try requiredId(operation, field: "parentId", name: "reparentChild")
+        let childId = try requiredId(operation, field: "childId", name: "reparentChild")
+        guard var parent = nodes[parentId] else {
+            throw CraftNativeMutationFailure("UNKNOWN_PARENT", "node \(parentId) does not exist")
+        }
+        guard var child = nodes[childId], let previousParentId = child.parent,
+              var previousParent = nodes[previousParentId] else {
+            throw CraftNativeMutationFailure("NOT_ATTACHED", "node \(childId) is not attached to a parent")
+        }
+        guard acceptsChildren(parent.type) else {
+            throw CraftNativeMutationFailure("INVALID_PARENT", "node \(parentId) cannot contain child nodes")
+        }
+        guard parentId != childId, !descendants(of: childId, nodes: nodes).contains(parentId) else {
+            throw CraftNativeMutationFailure("CYCLE", "reparenting node \(childId) would create a cycle")
+        }
+        guard parentId != previousParentId else {
+            throw CraftNativeMutationFailure("SAME_PARENT", "node \(childId) is already a child of \(parentId)")
+        }
+        let index = try insertionIndex(operation, count: parent.children.count)
+        previousParent.children.removeAll { $0 == childId }
+        parent.children.insert(childId, at: index)
+        child.parent = parentId
+        nodes[previousParentId] = previousParent
+        nodes[parentId] = parent
+        nodes[childId] = child
+        return previousParentId
+    }
+
     private func removeNode(
         _ operation: [String: Any],
         nodes: inout [String: Node],

package/dist/macos/templates/native_layout.zig

@@ -105,6 +105,8 @@ pub const Style = struct {
     /// ABI and remains host-neutral because hosts resolve percentages before
     /// serializing the style.
     grid_auto_rows: ?f32 = null,
+    /// Explicit equal row-track count. Null means derive rows from children.
+    grid_rows: ?u32 = null,
 };
 
 pub const Node = struct {
@@ -297,6 +299,51 @@ pub const LayoutNodeInputV4 = extern struct {
     child_count: u32,
 };
 
+/// v5 appends the resolved explicit grid-row count to the v4 payload.
+pub const LayoutStyleInputV5 = extern struct {
+    direction: u32,
+    width: f32,
+    height: f32,
+    intrinsic_width: f32,
+    intrinsic_height: f32,
+    baseline: f32,
+    aspect_ratio: f32,
+    flex_basis: f32,
+    flex_grow: f32,
+    flex_shrink: f32,
+    min_width: f32,
+    max_width: f32,
+    min_height: f32,
+    max_height: f32,
+    gap: f32,
+    justify_content: u32,
+    align_items: u32,
+    align_self: u32,
+    flex_wrap: u32,
+    align_content: u32,
+    margin_top: f32,
+    margin_right: f32,
+    margin_bottom: f32,
+    margin_left: f32,
+    padding_top: f32,
+    padding_right: f32,
+    padding_bottom: f32,
+    padding_left: f32,
+    grid: u32,
+    grid_columns: u32,
+    row_gap: f32,
+    column_gap: f32,
+    reverse: u32,
+    grid_auto_rows: f32,
+    grid_rows: u32,
+};
+
+pub const LayoutNodeInputV5 = extern struct {
+    style: LayoutStyleInputV5,
+    first_child: u32,
+    child_count: u32,
+};
+
 const max_layout_nodes: usize = 65_536;
 
 /// Resolve an entire native view tree using the same layout rules used by the
@@ -452,6 +499,43 @@ pub export fn craft_native_layout_tree_v4(
     return if (result == node_count) 0 else -1;
 }
 
+/// v5 tree layout entry point. It preserves v4's auto-row and reverse fields,
+/// adding an explicit equal-track row count for gridTemplateRows.
+pub export fn craft_native_layout_tree_v5(
+    viewport_width: f32,
+    viewport_height: f32,
+    nodes: [*]const LayoutNodeInputV5,
+    node_count: usize,
+    frames: [*]Frame,
+    frame_count: usize,
+) callconv(.c) c_int {
+    if (node_count == 0 or node_count > max_layout_nodes or frame_count < node_count) return -1;
+
+    const input = nodes[0..node_count];
+    const visited = std.heap.page_allocator.alloc(bool, node_count) catch return -1;
+    defer std.heap.page_allocator.free(visited);
+    @memset(visited, false);
+    if (!validateLayoutTreeV5(input, 0, visited)) return -1;
+
+    var tree = std.heap.page_allocator.alloc(Node, node_count) catch return -1;
+    defer std.heap.page_allocator.free(tree);
+    for (input, 0..) |item, index| {
+        const first = @as(usize, @intCast(item.first_child));
+        const count = @as(usize, @intCast(item.child_count));
+        tree[index] = .{
+            .style = layoutStyleV5(item.style),
+            .children = tree[first .. first + count],
+        };
+    }
+
+    const result = layout(
+        tree[0],
+        .{ .width = finiteNonNegative(viewport_width), .height = finiteNonNegative(viewport_height) },
+        frames[0..frame_count],
+    ) catch return -1;
+    return if (result == node_count) 0 else -1;
+}
+
 fn validateLayoutTree(input: []const LayoutNodeInput, index: usize, visited: []bool) bool {
     if (index >= input.len or visited[index]) return false;
     visited[index] = true;
@@ -491,6 +575,19 @@ fn validateLayoutTreeV4(input: []const LayoutNodeInputV4, index: usize, visited:
     return true;
 }
 
+fn validateLayoutTreeV5(input: []const LayoutNodeInputV5, index: usize, visited: []bool) bool {
+    if (index >= input.len or visited[index]) return false;
+    visited[index] = true;
+    const item = input[index];
+    const first = @as(usize, @intCast(item.first_child));
+    const count = @as(usize, @intCast(item.child_count));
+    if (first > input.len or count > input.len - first or (count > 0 and first <= index)) return false;
+    for (first..first + count) |child| {
+        if (!validateLayoutTreeV5(input, child, visited)) return false;
+    }
+    return true;
+}
+
 fn layoutStyle(input: LayoutStyleInput) Style {
     return .{
         .direction = if (input.direction == 1) .column else .row,
@@ -614,6 +711,47 @@ fn layoutStyleV4(input: LayoutStyleInputV4) Style {
     };
 }
 
+fn layoutStyleV5(input: LayoutStyleInputV5) Style {
+    return .{
+        .direction = if (input.direction == 1) .column else .row,
+        .reverse = (input.reverse & 1) != 0,
+        .wrap_reverse = (input.reverse & 2) != 0,
+        .width = optionalFinite(input.width),
+        .height = optionalFinite(input.height),
+        .intrinsic_width = optionalFinite(input.intrinsic_width),
+        .intrinsic_height = optionalFinite(input.intrinsic_height),
+        .baseline = optionalFinite(input.baseline),
+        .aspect_ratio = optionalFinite(input.aspect_ratio),
+        .flex_basis = optionalFinite(input.flex_basis),
+        .flex_grow = finiteNonNegative(input.flex_grow),
+        .flex_shrink = finiteNonNegative(input.flex_shrink),
+        .min_width = optionalFinite(input.min_width),
+        .max_width = optionalFinite(input.max_width),
+        .min_height = optionalFinite(input.min_height),
+        .max_height = optionalFinite(input.max_height),
+        .gap = finiteNonNegative(input.gap),
+        .justify_content = @fromBackingInt(@intCast(@min(input.justify_content, 5))),
+        .align_items = @fromBackingInt(@intCast(@min(input.align_items, 4))),
+        .align_self = if (input.align_self == 0) null else @fromBackingInt(@intCast(@min(input.align_self - 1, 4))),
+        .flex_wrap = input.flex_wrap != 0,
+        .align_content = @fromBackingInt(@intCast(@min(input.align_content, 6))),
+        .margin_top = finiteNonNegative(input.margin_top),
+        .margin_right = finiteNonNegative(input.margin_right),
+        .margin_bottom = finiteNonNegative(input.margin_bottom),
+        .margin_left = finiteNonNegative(input.margin_left),
+        .padding_top = finiteNonNegative(input.padding_top),
+        .padding_right = finiteNonNegative(input.padding_right),
+        .padding_bottom = finiteNonNegative(input.padding_bottom),
+        .padding_left = finiteNonNegative(input.padding_left),
+        .grid = input.grid != 0,
+        .grid_columns = @max(@as(u32, 1), input.grid_columns),
+        .row_gap = finiteNonNegative(input.row_gap),
+        .column_gap = finiteNonNegative(input.column_gap),
+        .grid_auto_rows = optionalFinite(input.grid_auto_rows),
+        .grid_rows = if (input.grid_rows == 0) null else input.grid_rows,
+    };
+}
+
 fn optionalFinite(value: f32) ?f32 {
     return if (std.math.isFinite(value)) value else null;
 }
@@ -1359,12 +1497,26 @@ fn layoutGrid(
     const row_gap = axisGap(node.style.row_gap, node.style.gap);
     const available_width = @max(0, width - column_gap * @as(f32, @floatFromInt(column_count - 1)));
     const cell_width = available_width / @as(f32, @floatFromInt(column_count));
+    const natural_rows = if (node.children.len == 0) 0 else (node.children.len + column_count - 1) / column_count;
+    const row_count = @max(natural_rows, @as(usize, @intCast(node.style.grid_rows orelse 0)));
+    const row_heights = std.heap.page_allocator.alloc(f32, row_count) catch return error.FrameBufferTooSmall;
+    defer std.heap.page_allocator.free(row_heights);
+    for (0..row_count) |row| {
+        var track = gridRowHeight(node, row, column_count);
+        if (node.style.grid_rows != null) {
+            const gap_count = if (row_count > 1) row_count - 1 else 0;
+            const gaps = row_gap * @as(f32, @floatFromInt(gap_count));
+            const equal = @max(0, (height - gaps) / @as(f32, @floatFromInt(@max(row_count, 1))));
+            track = @max(track, equal);
+        }
+        row_heights[row] = track;
+    }
     var next_index = frame_index + 1;
     var row_y = y;
     for (node.children, 0..) |child, index| {
         const row = index / column_count;
         const column = index % column_count;
-        const row_height = gridRowHeight(node, row, column_count);
+        const row_height = row_heights[row];
         const child_available_width = @max(0, cell_width - horizontalMargins(child));
         const ratio_width = if (validAspectRatio(child.style.aspect_ratio)) |ratio|
             if (child.style.width == null and child.style.height != null) child.style.height.? * ratio else null
@@ -1395,7 +1547,6 @@ fn layoutGrid(
             row_y += row_height + row_gap;
         }
     }
-    _ = height;
     return next_index;
 }
 
@@ -1708,6 +1859,47 @@ fn emptyLayoutStyleInputV4() LayoutStyleInputV4 {
     };
 }
 
+fn emptyLayoutStyleInputV5() LayoutStyleInputV5 {
+    const unset = std.math.nan(f32);
+    return .{
+        .direction = 0,
+        .width = unset,
+        .height = unset,
+        .intrinsic_width = unset,
+        .intrinsic_height = unset,
+        .baseline = unset,
+        .aspect_ratio = unset,
+        .flex_basis = unset,
+        .flex_grow = 0,
+        .flex_shrink = 0,
+        .min_width = unset,
+        .max_width = unset,
+        .min_height = unset,
+        .max_height = unset,
+        .gap = 0,
+        .justify_content = 0,
+        .align_items = 3,
+        .align_self = 0,
+        .flex_wrap = 0,
+        .align_content = 5,
+        .margin_top = 0,
+        .margin_right = 0,
+        .margin_bottom = 0,
+        .margin_left = 0,
+        .padding_top = 0,
+        .padding_right = 0,
+        .padding_bottom = 0,
+        .padding_left = 0,
+        .grid = 0,
+        .grid_columns = 1,
+        .row_gap = 0,
+        .column_gap = 0,
+        .reverse = 0,
+        .grid_auto_rows = unset,
+        .grid_rows = 0,
+    };
+}
+
 fn clampBounds(value: f32, lower: f32, upper: f32) f32 {
     var result = finiteNonNegative(value);
     if (std.math.isFinite(lower) and lower >= 0) result = @max(result, lower);
@@ -1818,6 +2010,38 @@ test "v4 tree layout carries auto rows through nested grids" {
     try std.testing.expectEqual(@as(f32, 18), frames[4].y);
 }
 
+test "v5 tree layout carries explicit equal grid rows through the shared ABI" {
+    var root_style = emptyLayoutStyleInputV5();
+    root_style.width = 100;
+    root_style.height = 100;
+    root_style.grid = 1;
+    root_style.grid_columns = 2;
+    root_style.row_gap = 4;
+    root_style.grid_rows = 2;
+
+    var first_style = emptyLayoutStyleInputV5();
+    first_style.intrinsic_width = 10;
+    first_style.intrinsic_height = 6;
+    var second_style = emptyLayoutStyleInputV5();
+    second_style.intrinsic_width = 10;
+    second_style.intrinsic_height = 7;
+    var third_style = emptyLayoutStyleInputV5();
+    third_style.intrinsic_width = 10;
+    third_style.intrinsic_height = 5;
+
+    const nodes = [_]LayoutNodeInputV5{
+        .{ .style = root_style, .first_child = 1, .child_count = 3 },
+        .{ .style = first_style, .first_child = 0, .child_count = 0 },
+        .{ .style = second_style, .first_child = 0, .child_count = 0 },
+        .{ .style = third_style, .first_child = 0, .child_count = 0 },
+    };
+    var frames: [4]Frame = undefined;
+    try std.testing.expectEqual(@as(c_int, 0), craft_native_layout_tree_v5(100, 100, &nodes, nodes.len, &frames, frames.len));
+    try std.testing.expectEqual(@as(f32, 0), frames[1].y);
+    try std.testing.expectEqual(@as(f32, 0), frames[2].y);
+    try std.testing.expectEqual(@as(f32, 52), frames[3].y);
+}
+
 test "lays out nested flat trees with absolute descendant frames" {
     var root_style = emptyLayoutStyleInput();
     root_style.width = 200;

package/dist/mobile-testing.js

@@ -477,7 +477,7 @@ ${errors || output}`);
   return { restart, installUpdate, installedBuild };
 }
 export {
-  verifyMobileMediaCache,
+  createMobileTestDevice,
   recordIosSimulatorVideo,
-  createMobileTestDevice
+  verifyMobileMediaCache
 };

package/dist/mobile.js

@@ -1145,9 +1145,9 @@ function hrSubscribe(set, callback) {
         if (reading)
           hrNotify(heartRateWatch.readings, reading);
       } else if (detail.type === "device") {
-        const device2 = normalizeHeartRateDevice(detail.device);
-        if (device2)
-          hrNotify(heartRateWatch.devices, device2);
+        const device = normalizeHeartRateDevice(detail.device);
+        if (device)
+          hrNotify(heartRateWatch.devices, device);
       } else if (detail.type === "state") {
         hrNotify(heartRateWatch.states, normalizeHeartRateState(detail));
       }
@@ -1184,7 +1184,7 @@ var heartRate = {
   requestAuthorization: () => heartRateCall("requestAuthorization", () => "unavailable", (value) => HR_AUTHORIZATIONS.includes(value) ? value : "unavailable"),
   scan: (options = {}) => heartRateCall("scan", noHeartRate, normalizeHeartRateState, options),
   stopScan: () => heartRateCall("stopScan", noHeartRate, normalizeHeartRateState),
-  getDevices: () => heartRateCall("getDevices", () => [], (value) => Array.isArray(value) ? value.map(normalizeHeartRateDevice).filter((device2) => device2 !== null) : []),
+  getDevices: () => heartRateCall("getDevices", () => [], (value) => Array.isArray(value) ? value.map(normalizeHeartRateDevice).filter((device) => device !== null) : []),
   connect: (id) => heartRateCall("connect", noHeartRate, normalizeHeartRateState, id),
   reconnect: () => heartRateCall("reconnect", noHeartRate, normalizeHeartRateState),
   disconnect: (options = {}) => heartRateCall("disconnect", noHeartRate, normalizeHeartRateState, options),
@@ -1459,14 +1459,17 @@ var hybrid = {
     return postHybrid({ type: "back" });
   }
 };
-async function callNative(namespace, method, args, fallback) {
+async function callNative(namespace, method, args, fallback, options = {}) {
   const target = getCraftRoot()?.[namespace];
   if (!target || typeof target[method] !== "function")
     return fallback;
   try {
     const value = await target[method](...args);
     return value === undefined || value === null ? fallback : value;
-  } catch {
+  } catch (error) {
+    if (options.warnOnError) {
+      console.warn(`[craft] Native ${namespace}.${method} failed; using its fallback value.`, error);
+    }
     return fallback;
   }
 }
@@ -1484,7 +1487,7 @@ var dialog = {
     return callNative("dialog", "confirm", [options], false);
   },
   actionSheet(options) {
-    return callNative("dialog", "actionSheet", [options], null);
+    return callNative("dialog", "actionSheet", [options], null, { warnOnError: true });
   }
 };
 var contextMenu = {
@@ -1669,11 +1672,11 @@ var health = {
       throw new Error("Reading sleep intervals is unavailable");
     return craft.health.getSleepIntervals(options);
   },
-  async saveMindfulSession(session2) {
+  async saveMindfulSession(session) {
     const craft = getCraftRoot();
     if (!craft?.health?.saveMindfulSession)
       throw new Error("Saving mindful sessions is unavailable");
-    return craft.health.saveMindfulSession(session2);
+    return craft.health.saveMindfulSession(session);
   },
   async getMindfulSessions(options = {}) {
     const craft = getCraftRoot();
@@ -1693,6 +1696,41 @@ var health = {
       throw new Error("Heart-rate updates are unavailable");
     return Boolean(await craft.health.stopHeartRateUpdates());
   },
+  async startWorkout(options) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.startWorkout)
+      throw new Error("Live workouts are unavailable");
+    return craft.health.startWorkout(options);
+  },
+  async pauseWorkout() {
+    const craft = getCraftRoot();
+    if (!craft?.health?.pauseWorkout)
+      throw new Error("Live workouts are unavailable");
+    return Boolean(await craft.health.pauseWorkout());
+  },
+  async resumeWorkout() {
+    const craft = getCraftRoot();
+    if (!craft?.health?.resumeWorkout)
+      throw new Error("Live workouts are unavailable");
+    return Boolean(await craft.health.resumeWorkout());
+  },
+  async endWorkout() {
+    const craft = getCraftRoot();
+    if (!craft?.health?.endWorkout)
+      throw new Error("Live workouts are unavailable");
+    return craft.health.endWorkout();
+  },
+  onWorkout(callback) {
+    if (typeof window === "undefined" || typeof getCraftRoot()?.health?.startWorkout !== "function")
+      return () => {};
+    const listener = (event) => {
+      const detail = event.detail;
+      if (detail && typeof detail.id === "string" && (detail.event === "state" || detail.event === "error"))
+        callback(detail);
+    };
+    window.addEventListener("craftHealthWorkout", listener);
+    return () => window.removeEventListener("craftHealthWorkout", listener);
+  },
   onHeartRate(callback) {
     if (typeof window === "undefined" || typeof getCraftRoot()?.health?.startHeartRateUpdates !== "function")
       return () => {};
@@ -1819,59 +1857,59 @@ function getCraftMobile() {
   return;
 }
 export {
-  watchConnectivity,
-  tabBar,
-  symbols,
-  storage,
-  statusBar,
-  splash,
-  speech,
-  snapshots,
-  share,
-  session,
-  secureStorage,
-  scheduledWorkoutsUnsupported,
-  scheduledWorkouts,
-  refresh,
-  pushNotifications,
-  permissions,
-  notifications,
-  normalizeScheduledWorkout,
-  normalizeNowPlaying,
-  normalizeHeartRateState,
-  normalizeHeartRateSamples,
-  normalizeHeartRateReading,
-  normalizeHeartRateDevice,
-  normalizeDeepLinkURL,
-  network,
-  music,
-  location,
-  liveActivities,
-  lifecycle,
-  keepAwake,
-  isSnapshotName,
-  hybrid,
-  heartRate,
-  health,
-  haptics,
-  dialog,
-  device,
-  deepLinks,
-  crypto,
-  crashReporter,
-  contextMenu,
-  chrome,
-  camera,
-  browser,
-  brightness,
-  bridgeNotification,
-  biometrics,
-  background,
-  appearance,
-  appReview,
-  _webFallbackDeviceId,
-  _resetWebFallbackDeviceIdForTests,
-  SESSION_MESSAGE,
+  DEFAULT_SESSION_TOKEN_KEY,
   SESSION_EVENT,
-  DEFAULT_SESSION_TOKEN_KEY
+  SESSION_MESSAGE,
+  _resetWebFallbackDeviceIdForTests,
+  _webFallbackDeviceId,
+  appReview,
+  appearance,
+  background,
+  biometrics,
+  bridgeNotification,
+  brightness,
+  browser,
+  camera,
+  chrome,
+  contextMenu,
+  crashReporter,
+  crypto,
+  deepLinks,
+  device,
+  dialog,
+  haptics,
+  health,
+  heartRate,
+  hybrid,
+  isSnapshotName,
+  keepAwake,
+  lifecycle,
+  liveActivities,
+  location,
+  music,
+  network,
+  normalizeDeepLinkURL,
+  normalizeHeartRateDevice,
+  normalizeHeartRateReading,
+  normalizeHeartRateSamples,
+  normalizeHeartRateState,
+  normalizeNowPlaying,
+  normalizeScheduledWorkout,
+  notifications,
+  permissions,
+  pushNotifications,
+  refresh,
+  scheduledWorkouts,
+  scheduledWorkoutsUnsupported,
+  secureStorage,
+  session,
+  share,
+  snapshots,
+  speech,
+  splash,
+  statusBar,
+  storage,
+  symbols,
+  tabBar,
+  watchConnectivity
 };

package/package.json

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