craft-native 0.0.246 → 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

@@ -54,6 +54,7 @@ async function verifyMobileMediaCache(options) {
   const scratch = await mkdtemp(join(tmpdir(), "craft-media-probe-"));
   const bytes = new Uint8Array(await Bun.file(join(fixtures, "demo.mp4")).arrayBuffer());
   const counts = new Map;
+  const resumed = new Set;
   const timers = new Set;
   const server = Bun.listen({
     hostname: "0.0.0.0",
@@ -72,6 +73,20 @@ async function verifyMobileMediaCache(options) {
         const path = socket.data.request.split(" ")[1];
         const n = (counts.get(path) || 0) + 1;
         counts.set(path, n);
+        const from = Number(/^range:\s*bytes=(\d+)-\s*$/im.exec(socket.data.request)?.[1] ?? Number.NaN);
+        if (path === "/android/restart.mp4" && n > 1 && from > 0 && from < bytes.length) {
+          resumed.add(path);
+          socket.write(`HTTP/1.1 206 Partial Content\r
+Content-Type: video/mp4\r
+Content-Range: bytes ${from}-${bytes.length - 1}/${bytes.length}\r
+Content-Length: ${bytes.length - from}\r
+Connection: close\r
+\r
+`);
+          socket.write(bytes.subarray(from));
+          socket.end();
+          return;
+        }
         const empty = path.endsWith("/empty.mp4");
         const partial = path.endsWith("/partial.mp4");
         const cut = (path.endsWith("/broken.mp4") || path.endsWith("/restart.mp4")) && n === 1;
@@ -207,6 +222,7 @@ include(":app")`);
 `);
       await Bun.write(join(android, "gradle.properties"), `org.gradle.jvmargs=-Xmx768m
 org.gradle.workers.max=2
+android.useAndroidX=true
 `);
       await Bun.write(join(app, "build.gradle.kts"), `plugins { id("com.android.application");
   id("org.jetbrains.kotlin.android") }
@@ -264,11 +280,13 @@ ${await Bun.file(join(fixtures, "media-cache.kt")).text()}`);
         if (counts.get("/android/restart.mp4") !== 1)
           throw new Error("Android process did not start interrupted download");
         await probe("recover");
+        if (!resumed.has("/android/restart.mp4"))
+          throw new Error("Android did not resume the interrupted download from its part file");
         if (counts.get("/android/slow.mp4") !== 1)
           throw new Error("Android duplicate fetch: keep did not coalesce");
         if (counts.get("/android/account/slow.mp4") !== 2)
           throw new Error("Android account switch did not start a fresh transfer");
-        print("PASS: Android emulator interruption, restart, retry, prune and cached video decode");
+        print("PASS: Android emulator interruption, resumed restart, retry, prune and cached video decode");
       }
     }
   } finally {
@@ -459,7 +477,7 @@ ${errors || output}`);
   return { restart, installUpdate, installedBuild };
 }
 export {
-  verifyMobileMediaCache,
+  createMobileTestDevice,
   recordIosSimulatorVideo,
-  createMobileTestDevice
+  verifyMobileMediaCache
 };