craft-native 0.0.175 → 0.0.176

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

@@ -34,6 +34,7 @@ targets:
     settings:
       INFOPLIST_FILE: Info.plist
       CODE_SIGN_ENTITLEMENTS: Craft.entitlements
+      PRODUCT_NAME: "$(TARGET_NAME)"
       PRODUCT_BUNDLE_IDENTIFIER: {{BUNDLE_ID}}
       TARGETED_DEVICE_FAMILY: "{{DEVICE_FAMILIES}}"
       SWIFT_VERSION: "5.0"

package/dist/macos/templates/CraftNativeMutation.swift

@@ -305,7 +305,7 @@ final class CraftNativeMutationDocument {
     static let containerTypes: Set<String> = [
         "View", "SafeAreaView", "ScrollView", "KeyboardAvoidingView", "Modal", "Pressable",
         "TouchableOpacity", "TouchableHighlight", "ImageBackground", "FlatList", "SectionList",
-        "Fragment", "Svg", "G",
+        "Fragment", "Svg", "G", "Map",
     ]
     private static let containerTypeKeys = Set(containerTypes.map { $0.lowercased() })
 

package/dist/macos/templates/native_layout.zig

@@ -147,6 +147,152 @@ pub const GridItem = extern struct {
     alignment: u32,
 };
 
+/// Flat, C-compatible input for the host-neutral tree layout entry point.
+///
+/// Optional lengths use NaN as their unset value. Enum fields intentionally
+/// use the same zero-based values as the public `Style` enums, except for
+/// `align_self`: zero means `auto` and values one through five map to the
+/// corresponding `AlignItems` value. Children are a contiguous preorder slice
+/// described by `first_child` and `child_count`, so a host can build the tree
+/// without allocating platform objects in the shared core.
+pub const LayoutStyleInput = 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,
+};
+
+pub const LayoutNodeInput = extern struct {
+    style: LayoutStyleInput,
+    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
+/// host-neutral tests. Hosts may keep their platform measurement pass, flatten
+/// the measured tree into `LayoutNodeInput`, and then apply these absolute
+/// frames to UIKit or Android views. A non-zero result means the host should
+/// retain its compatibility fallback; no partial frame array is considered
+/// valid.
+pub export fn craft_native_layout_tree(
+    viewport_width: f32,
+    viewport_height: f32,
+    nodes: [*]const LayoutNodeInput,
+    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 (!validateLayoutTree(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 = layoutStyle(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;
+    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 (!validateLayoutTree(input, child, visited)) return false;
+    }
+    return true;
+}
+
+fn layoutStyle(input: LayoutStyleInput) Style {
+    return .{
+        .direction = if (input.direction == 1) .column else .row,
+        .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),
+    };
+}
+
+fn optionalFinite(value: f32) ?f32 {
+    return if (std.math.isFinite(value)) value else null;
+}
+
 /// Resolve an equal-track grid in content coordinates for native hosts.
 pub export fn craft_native_grid(
     available_width: f32,
@@ -591,16 +737,20 @@ fn layoutNode(
     frames[frame_index] = .{ .x = x, .y = y, .width = width, .height = height };
 
     if (node.children.len == 0) return frame_index + 1;
-    const content_width = @max(0, width - node.style.padding_left - node.style.padding_right);
-    const content_height = @max(0, height - node.style.padding_top - node.style.padding_bottom);
-    const content_x = x + node.style.padding_left;
-    const content_y = y + node.style.padding_top;
+    const padding_left = finiteNonNegative(node.style.padding_left);
+    const padding_right = finiteNonNegative(node.style.padding_right);
+    const padding_top = finiteNonNegative(node.style.padding_top);
+    const padding_bottom = finiteNonNegative(node.style.padding_bottom);
+    const content_width = @max(0, width - padding_left - padding_right);
+    const content_height = @max(0, height - padding_top - padding_bottom);
+    const content_x = x + padding_left;
+    const content_y = y + padding_top;
     if (node.style.grid) return layoutGrid(node, content_width, content_height, content_x, content_y, frame_index, frames);
 
     const main_size = if (node.style.direction == .row) content_width else content_height;
-    const gap = @max(0, node.style.gap);
+    const main_gap = flexAxisGap(node.style, node.style.direction);
     const gap_count = if (node.children.len > 1) node.children.len - 1 else 0;
-    const gap_total = gap * @as(f32, @floatFromInt(gap_count));
+    const gap_total = main_gap * @as(f32, @floatFromInt(gap_count));
     if (node.style.flex_wrap) return layoutWrapped(node, content_width, content_height, content_x, content_y, frame_index, frames);
     const flex = resolveFlex(node.children, node.style.direction, main_size, gap_total);
     const line_baseline = baselineForChildren(node.children, node.style.direction, content_width, content_height, content_height, node.style.align_items);
@@ -610,7 +760,7 @@ fn layoutNode(
     }
     const free_main = @max(0, main_size - used_main);
     var leading_space: f32 = 0;
-    var between_space: f32 = gap;
+    var between_space: f32 = main_gap;
     switch (node.style.justify_content) {
         .center => leading_space = free_main / 2,
         .flex_end => leading_space = free_main,
@@ -667,21 +817,22 @@ fn layoutWrapped(
     const direction = node.style.direction;
     const main_size = if (direction == .row) width else height;
     const cross_size = if (direction == .row) height else width;
-    const gap = @max(0, node.style.gap);
+    const main_gap = flexAxisGap(node.style, direction);
+    const cross_gap = crossAxisGap(node.style, direction);
     var line_count: usize = 0;
     var cross_total: f32 = 0;
     var start: usize = 0;
     while (start < node.children.len) {
-        const end = wrappedLineEnd(node.children, start, direction, main_size, gap);
+        const end = wrappedLineEnd(node.children, start, direction, main_size, main_gap);
         cross_total += wrappedLineCross(node.children[start..end], direction);
-        if (line_count > 0) cross_total += gap;
+        if (line_count > 0) cross_total += cross_gap;
         line_count += 1;
         start = end;
     }
     const free_cross = @max(0, cross_size - cross_total);
     var line_extra: f32 = 0;
     var cross_offset: f32 = 0;
-    var cross_between = gap;
+    var cross_between = cross_gap;
     switch (node.style.align_content) {
         .center => cross_offset = free_cross / 2,
         .flex_end => cross_offset = free_cross,
@@ -702,15 +853,15 @@ fn layoutWrapped(
     var next_index = frame_index + 1;
     start = 0;
     while (start < node.children.len) {
-        const end = wrappedLineEnd(node.children, start, direction, main_size, gap);
+        const end = wrappedLineEnd(node.children, start, direction, main_size, main_gap);
         const children = node.children[start..end];
         const line_cross = wrappedLineCross(children, direction) + line_extra;
-        const flex = resolveFlex(children, direction, main_size, gap * @as(f32, @floatFromInt(if (children.len > 1) children.len - 1 else 0)));
-        var used_main: f32 = gap * @as(f32, @floatFromInt(if (children.len > 1) children.len - 1 else 0));
+        const flex = resolveFlex(children, direction, main_size, main_gap * @as(f32, @floatFromInt(if (children.len > 1) children.len - 1 else 0)));
+        var used_main: f32 = main_gap * @as(f32, @floatFromInt(if (children.len > 1) children.len - 1 else 0));
         for (children) |child| used_main += flex.size(child, childMainBasis(child, direction)) + mainMargins(child, direction);
         const free_main = @max(0, main_size - used_main);
         var leading_space: f32 = 0;
-        var between_space: f32 = gap;
+        var between_space: f32 = main_gap;
         distributeJustify(node.style.justify_content, free_main, children.len, &leading_space, &between_space);
         const line_baseline = baselineForChildren(children, direction, width, height, line_cross, node.style.align_items);
         var main_offset = leading_space;
@@ -867,8 +1018,8 @@ fn layoutGrid(
 ) LayoutError!usize {
     const columns = @max(@as(u32, 1), node.style.grid_columns);
     const column_count: usize = @intCast(columns);
-    const column_gap = @max(0, node.style.column_gap);
-    const row_gap = @max(0, node.style.row_gap);
+    const column_gap = axisGap(node.style.column_gap, node.style.gap);
+    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));
     var next_index = frame_index + 1;
@@ -1073,6 +1224,66 @@ fn finiteNonNegative(value: f32) f32 {
     return if (!std.math.isFinite(value) or value < 0) 0 else value;
 }
 
+/// `gap` is the shorthand fallback for an axis-specific gap. The flat ABI
+/// uses zero for an omitted row/column value, so a positive axis value wins
+/// while an unset value continues to inherit the shorthand.
+fn axisGap(explicit: f32, shorthand: f32) f32 {
+    const value = finiteNonNegative(explicit);
+    return if (value > 0) value else finiteNonNegative(shorthand);
+}
+
+fn flexAxisGap(style: Style, direction: Axis) f32 {
+    return if (direction == .row)
+        axisGap(style.column_gap, style.gap)
+    else
+        axisGap(style.row_gap, style.gap);
+}
+
+fn crossAxisGap(style: Style, direction: Axis) f32 {
+    return if (direction == .row)
+        axisGap(style.row_gap, style.gap)
+    else
+        axisGap(style.column_gap, style.gap);
+}
+
+fn emptyLayoutStyleInput() LayoutStyleInput {
+    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 = 6,
+        .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,
+    };
+}
+
 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);
@@ -1088,6 +1299,92 @@ fn optionalDimension(explicit: f32, intrinsic: f32) f32 {
     return finiteNonNegative(if (isUnset(explicit)) intrinsic else explicit);
 }
 
+test "exports the host-neutral tree layout contract" {
+    var root_style = emptyLayoutStyleInput();
+    root_style.width = 100;
+    root_style.height = 40;
+    root_style.padding_left = 8;
+    root_style.padding_top = 4;
+    root_style.gap = 5;
+    root_style.justify_content = 1;
+
+    var child_style = emptyLayoutStyleInput();
+    child_style.intrinsic_width = 20;
+    child_style.intrinsic_height = 10;
+
+    const nodes = [_]LayoutNodeInput{
+        .{ .style = root_style, .first_child = 1, .child_count = 1 },
+        .{ .style = child_style, .first_child = 0, .child_count = 0 },
+    };
+    var frames: [2]Frame = undefined;
+    try std.testing.expectEqual(@as(c_int, 0), craft_native_layout_tree(100, 40, &nodes, nodes.len, &frames, frames.len));
+    try std.testing.expectEqual(@as(f32, 100), frames[0].width);
+    try std.testing.expectEqual(@as(f32, 40), frames[0].height);
+    try std.testing.expectEqual(@as(f32, 44), frames[1].x);
+    try std.testing.expectEqual(@as(f32, 4), frames[1].y);
+    try std.testing.expectEqual(@as(f32, 20), frames[1].width);
+    try std.testing.expectEqual(@as(f32, 10), frames[1].height);
+}
+
+test "lays out nested flat trees with absolute descendant frames" {
+    var root_style = emptyLayoutStyleInput();
+    root_style.width = 200;
+    root_style.height = 100;
+    root_style.padding_left = 10;
+    root_style.padding_top = 5;
+    root_style.gap = 10;
+
+    var column_style = emptyLayoutStyleInput();
+    column_style.direction = 1;
+    column_style.width = 80;
+    column_style.height = 60;
+    column_style.padding_left = 4;
+    column_style.padding_top = 3;
+    column_style.gap = 2;
+
+    var first_style = emptyLayoutStyleInput();
+    first_style.intrinsic_width = 20;
+    first_style.intrinsic_height = 10;
+    var second_style = emptyLayoutStyleInput();
+    second_style.intrinsic_width = 30;
+    second_style.intrinsic_height = 15;
+
+    const nodes = [_]LayoutNodeInput{
+        .{ .style = root_style, .first_child = 1, .child_count = 1 },
+        .{ .style = column_style, .first_child = 2, .child_count = 2 },
+        .{ .style = first_style, .first_child = 0, .child_count = 0 },
+        .{ .style = second_style, .first_child = 0, .child_count = 0 },
+    };
+    var frames: [4]Frame = undefined;
+    try std.testing.expectEqual(@as(c_int, 0), craft_native_layout_tree(200, 100, &nodes, nodes.len, &frames, frames.len));
+    try std.testing.expectEqual(@as(f32, 200), frames[0].width);
+    try std.testing.expectEqual(@as(f32, 100), frames[0].height);
+    try std.testing.expectEqual(@as(f32, 10), frames[1].x);
+    try std.testing.expectEqual(@as(f32, 5), frames[1].y);
+    try std.testing.expectEqual(@as(f32, 80), frames[1].width);
+    try std.testing.expectEqual(@as(f32, 60), frames[1].height);
+    try std.testing.expectEqual(@as(f32, 14), frames[2].x);
+    try std.testing.expectEqual(@as(f32, 8), frames[2].y);
+    try std.testing.expectEqual(@as(f32, 20), frames[2].width);
+    try std.testing.expectEqual(@as(f32, 10), frames[2].height);
+    try std.testing.expectEqual(@as(f32, 14), frames[3].x);
+    try std.testing.expectEqual(@as(f32, 20), frames[3].y);
+    try std.testing.expectEqual(@as(f32, 30), frames[3].width);
+    try std.testing.expectEqual(@as(f32, 15), frames[3].height);
+}
+
+test "rejects malformed host-neutral layout trees without writing frames" {
+    var style = emptyLayoutStyleInput();
+    style.width = 20;
+    style.height = 20;
+    const nodes = [_]LayoutNodeInput{
+        .{ .style = style, .first_child = 0, .child_count = 1 },
+    };
+    var frames = [_]Frame{.{ .x = 7, .y = 8, .width = 9, .height = 10 }};
+    try std.testing.expectEqual(@as(c_int, -1), craft_native_layout_tree(20, 20, &nodes, nodes.len, &frames, frames.len));
+    try std.testing.expectEqual(@as(f32, 7), frames[0].x);
+}
+
 test "distributes positive flex grow from a shared basis" {
     const children = [_]Node{
         .{ .style = .{ .flex_basis = 40, .flex_grow = 1 } },
@@ -1219,6 +1516,32 @@ test "aligns wrapped children using align self" {
     try std.testing.expectApproxEqAbs(@as(f32, 24), frames[3].y, 0.001);
 }
 
+test "keeps independent row and column gaps in wrapped flex" {
+    const children = [_]Node{
+        .{ .style = .{ .width = 45, .height = 10 } },
+        .{ .style = .{ .width = 45, .height = 10 } },
+        .{ .style = .{ .width = 45, .height = 10 } },
+    };
+    const root = Node{
+        .style = .{
+            .direction = .row,
+            .width = 100,
+            .height = 80,
+            .flex_wrap = true,
+            .column_gap = 5,
+            .row_gap = 12,
+            .align_items = .flex_start,
+            .align_content = .flex_start,
+        },
+        .children = &children,
+    };
+    var frames: [4]Frame = undefined;
+
+    _ = try layout(root, .{ .width = 100, .height = 80 }, &frames);
+    try std.testing.expectApproxEqAbs(@as(f32, 50), frames[2].x, 0.001);
+    try std.testing.expectApproxEqAbs(@as(f32, 22), frames[3].y, 0.001);
+}
+
 test "uses viewport size when the root is intrinsic" {
     var frames: [1]Frame = undefined;
     const count = try layout(.{}, .{ .width = 320, .height = 640 }, &frames);
@@ -1309,6 +1632,55 @@ test "sanitizes non-finite tree dimensions" {
     }
 }
 
+test "sanitizes non-finite and negative tree padding" {
+    const children = [_]Node{.{ .style = .{ .flex_basis = 10 } }};
+    const root = Node{
+        .style = .{
+            .width = 100,
+            .height = 40,
+            .padding_left = -8,
+            .padding_right = std.math.nan(f32),
+            .padding_top = std.math.inf(f32),
+            .padding_bottom = -4,
+        },
+        .children = &children,
+    };
+    var frames: [2]Frame = undefined;
+
+    _ = try layout(root, .{ .width = 100, .height = 40 }, &frames);
+    try std.testing.expectApproxEqAbs(@as(f32, 0), frames[1].x, 0.001);
+    try std.testing.expectApproxEqAbs(@as(f32, 0), frames[1].y, 0.001);
+}
+
+test "sanitizes non-finite tree flex and grid gaps" {
+    const flex_children = [_]Node{
+        .{ .style = .{ .flex_basis = 10 } },
+        .{ .style = .{ .flex_basis = 10 } },
+    };
+    const flex_root = Node{
+        .style = .{ .direction = .row, .width = 40, .height = 20, .gap = std.math.nan(f32) },
+        .children = &flex_children,
+    };
+    var flex_frames: [3]Frame = undefined;
+    _ = try layout(flex_root, .{ .width = 40, .height = 20 }, &flex_frames);
+    try std.testing.expectApproxEqAbs(@as(f32, 10), flex_frames[2].x, 0.001);
+
+    const grid_children = [_]Node{
+        .{ .style = .{ .width = 10, .height = 10 } },
+        .{ .style = .{ .width = 10, .height = 10 } },
+    };
+    const grid_root = Node{
+        .style = .{ .grid = true, .grid_columns = 2, .width = 40, .height = 20, .column_gap = std.math.inf(f32), .row_gap = -4 },
+        .children = &grid_children,
+    };
+    var grid_frames: [3]Frame = undefined;
+    _ = try layout(grid_root, .{ .width = 40, .height = 20 }, &grid_frames);
+    for (grid_frames) |frame| {
+        try std.testing.expect(std.math.isFinite(frame.x));
+        try std.testing.expect(std.math.isFinite(frame.y));
+    }
+}
+
 test "recurses across row and column axes without host concepts" {
     const grandchildren = [_]Node{
         .{ .style = .{ .flex_basis = 10, .flex_grow = 1 } },

package/dist/mobile.js

@@ -713,6 +713,71 @@ var speech = {
     getWebSpeech()?.synthesis.cancel();
   }
 };
+function crashReporterBridge() {
+  const root = globalThis.craft;
+  return root?.crashReporter && typeof root.crashReporter.capture === "function" ? root.crashReporter : undefined;
+}
+var crashReporter = {
+  isAvailable() {
+    const root = globalThis.craft;
+    if (!crashReporterBridge())
+      return false;
+    const caps = root?.capabilities;
+    if (Array.isArray(caps))
+      return caps.includes("crashReporter");
+    return caps?.crashReporter !== false;
+  },
+  async capture(event) {
+    const bridge = crashReporterBridge();
+    if (!bridge || !event || typeof event.message !== "string")
+      return false;
+    try {
+      return await bridge.capture(event) !== false;
+    } catch {
+      return false;
+    }
+  },
+  async setUser(id) {
+    const bridge = crashReporterBridge();
+    if (!bridge)
+      return false;
+    try {
+      return await bridge.setUser(id == null ? null : String(id)) !== false;
+    } catch {
+      return false;
+    }
+  },
+  async addBreadcrumb(breadcrumb) {
+    const bridge = crashReporterBridge();
+    if (!bridge)
+      return false;
+    try {
+      return await bridge.addBreadcrumb(breadcrumb) !== false;
+    } catch {
+      return false;
+    }
+  },
+  async flush() {
+    const bridge = crashReporterBridge();
+    if (!bridge)
+      return false;
+    try {
+      return await bridge.flush() !== false;
+    } catch {
+      return false;
+    }
+  },
+  async context() {
+    const bridge = crashReporterBridge();
+    if (!bridge)
+      return null;
+    try {
+      return await bridge.context();
+    } catch {
+      return null;
+    }
+  }
+};
 var MUSIC_AUTHORIZATIONS = ["authorized", "denied", "restricted", "notDetermined", "unavailable"];
 var MUSIC_STATES = ["stopped", "playing", "paused", "interrupted", "seekingForward", "seekingBackward", "unknown"];
 function musicAuthorization(value) {
@@ -1607,6 +1672,7 @@ export {
   dialog,
   device,
   deepLinks,
+  crashReporter,
   contextMenu,
   chrome,
   camera,

package/package.json

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