zig-mobile-runner 0.1.0

package/src/runner.zig

@@ -0,0 +1,280 @@
+const std = @import("std");
+const runner_actions = @import("runner_actions.zig");
+const runner_config = @import("runner_config.zig");
+const runner_events = @import("runner_events.zig");
+const runner_waits = @import("runner_waits.zig");
+const scenario = @import("scenario.zig");
+const selector = @import("selector.zig");
+const trace = @import("trace.zig");
+
+pub const RunOptions = runner_config.RunOptions;
+
+pub fn runScenario(
+    allocator: std.mem.Allocator,
+    device: anytype,
+    script: scenario.Scenario,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    if (writer) |tw| {
+        try tw.startManifest(script.name, script.app_id);
+        const payload = try runner_events.eventString(tw.allocator, script.name);
+        defer tw.allocator.free(payload);
+        try tw.recordEvent("scenario.start", payload);
+    }
+    for (script.steps, 0..) |step, index| {
+        executeStep(allocator, device, step, writer, options) catch |err| {
+            if (writer) |tw| {
+                try runner_events.recordStepError(tw, index, err);
+                try runner_events.recordScenarioEnd(tw, script.name, "failed", index, err);
+                try tw.finishManifest(.{
+                    .status = "failed",
+                    .failed_step_index = index,
+                    .error_name = @errorName(err),
+                });
+            }
+            return err;
+        };
+        if (writer) |tw| {
+            const payload = try std.fmt.allocPrint(tw.allocator, "{{\"index\":{d}}}", .{index});
+            defer tw.allocator.free(payload);
+            try tw.recordEvent("step.done", payload);
+        }
+    }
+    if (writer) |tw| {
+        try runner_events.recordScenarioEnd(tw, script.name, "passed", null, null);
+        try tw.finishManifest(.{ .status = "passed" });
+    }
+}
+
+pub fn executeStep(
+    allocator: std.mem.Allocator,
+    device: anytype,
+    step: scenario.Step,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    switch (step) {
+        .launch => {
+            device.launch() catch |err| {
+                if (writer) |tw| try runner_events.recordActionStatus(tw, "app.launch", "failed", err, null);
+                return err;
+            };
+            if (writer) |tw| try runner_events.recordActionStatus(tw, "app.launch", "ok", null, null);
+            try settleDevice(device, options);
+        },
+        .stop => try device.stop(),
+        .clear_state => try device.clearState(),
+        .snapshot => {
+            var snap = try device.snapshot(writer);
+            defer snap.deinit(device.allocator);
+            if (writer) |tw| {
+                const path = try tw.writeSnapshot(snap);
+                defer tw.allocator.free(path);
+                const payload = try runner_events.eventString(tw.allocator, path);
+                defer tw.allocator.free(payload);
+                try tw.recordEvent("observe.snapshot", payload);
+            }
+        },
+        .open_link => |url| {
+            device.openLink(url) catch |err| {
+                if (writer) |tw| try runner_events.recordActionStatus(tw, "app.openLink", "failed", err, url);
+                return err;
+            };
+            if (writer) |tw| try runner_events.recordActionStatus(tw, "app.openLink", "ok", null, url);
+            try settleDevice(device, options);
+        },
+        .tap => |wanted| try tapSelector(device, wanted, writer, options),
+        .type_text => |input| {
+            if (input.selector) |wanted| return try typeTextSelector(device, wanted, input.text, writer, options);
+            try device.typeText(input.text);
+            try settleDevice(device, options);
+        },
+        .erase_text => |input| {
+            if (input.selector) |wanted| return try eraseTextSelector(device, wanted, input.max_chars, writer, options);
+            try device.eraseText(input.max_chars);
+            if (writer) |tw| {
+                const payload = try std.fmt.allocPrint(tw.allocator, "{{\"maxChars\":{d}}}", .{input.max_chars});
+                defer tw.allocator.free(payload);
+                try tw.recordEvent("ui.eraseText", payload);
+            }
+            try settleDevice(device, options);
+        },
+        .press_back => {
+            try device.pressBack();
+            try settleDevice(device, options);
+        },
+        .hide_keyboard => {
+            try device.hideKeyboard();
+            if (writer) |tw| try tw.recordEvent("ui.hideKeyboard", "{\"status\":\"ok\"}");
+            try settleDevice(device, options);
+        },
+        .swipe => |swipe| {
+            try device.swipe(swipe.x1, swipe.y1, swipe.x2, swipe.y2, swipe.duration_ms);
+            try settleDevice(device, options);
+        },
+        .wait_visible => |wait| {
+            if (!try waitUntilVisible(device, wait.selector, wait.timeout_ms, writer, options)) return error.WaitTimeout;
+        },
+        .wait_not_visible => |wait| {
+            if (!try waitUntilNotVisible(device, wait.selector, wait.timeout_ms, writer, options)) return error.WaitTimeout;
+        },
+        .wait_any => |wait| {
+            if (try waitUntilAnyVisible(device, wait.selectors, wait.timeout_ms, writer, options) == null) return error.WaitTimeout;
+        },
+        .assert_visible => |wanted| {
+            if (!try waitUntilVisible(device, wanted, options.default_timeout_ms, writer, options)) return error.AssertionFailed;
+        },
+        .assert_not_visible => |wanted| {
+            if (!try waitUntilNotVisible(device, wanted, options.default_timeout_ms, writer, options)) return error.AssertionFailed;
+        },
+        .assert_none_visible => |assertion| {
+            if (!try assertNoneVisible(device, assertion.selectors, assertion.timeout_ms, writer, options)) return error.AssertionFailed;
+        },
+        .assert_healthy_timeout_ms => |timeout_ms| {
+            if (!try assertHealthy(device, timeout_ms, writer, options)) return error.AssertionFailed;
+        },
+        .optional => |inner| {
+            executeStep(allocator, device, inner.*, writer, options) catch |err| {
+                if (writer) |tw| {
+                    const payload = try std.fmt.allocPrint(tw.allocator, "{{\"status\":\"skipped\",\"error\":\"{s}\"}}", .{@errorName(err)});
+                    defer tw.allocator.free(payload);
+                    try tw.recordEvent("step.optional", payload);
+                }
+            };
+        },
+        .when_visible => |block| {
+            const visible = if (block.timeout_ms == 0)
+                try isVisibleNow(device, block.selector, writer)
+            else
+                try waitUntilVisible(device, block.selector, block.timeout_ms, writer, options);
+            if (visible) {
+                for (block.steps) |inner| try executeStep(allocator, device, inner, writer, options);
+            } else if (writer) |tw| {
+                try runner_events.recordSelectorEvent(tw, "step.whenVisible.skipped", block.selector);
+            }
+        },
+        .repeat => |block| {
+            var iteration: u32 = 0;
+            while (iteration < block.times) : (iteration += 1) {
+                if (writer) |tw| {
+                    const payload = try std.fmt.allocPrint(tw.allocator, "{{\"iteration\":{d},\"times\":{d}}}", .{ iteration + 1, block.times });
+                    defer tw.allocator.free(payload);
+                    try tw.recordEvent("step.repeat.iteration", payload);
+                }
+                for (block.steps) |inner| try executeStep(allocator, device, inner, writer, options);
+            }
+        },
+        .scroll_until_visible => |scroll| {
+            if (!try scrollUntilVisible(device, scroll.selector, scroll.timeout_ms, scroll.direction, writer, options)) return error.WaitTimeout;
+        },
+        .sleep_ms => |ms| try sleepMs(ms),
+    }
+}
+
+pub fn tapSelector(
+    device: anytype,
+    wanted: selector.Selector,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    return try runner_actions.tapSelector(device, wanted, writer, options);
+}
+
+pub fn typeTextSelector(
+    device: anytype,
+    wanted: selector.Selector,
+    text: []const u8,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    return try runner_actions.typeTextSelector(device, wanted, text, writer, options);
+}
+
+pub fn eraseTextSelector(
+    device: anytype,
+    wanted: selector.Selector,
+    max_chars: u32,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    return try runner_actions.eraseTextSelector(device, wanted, max_chars, writer, options);
+}
+
+pub fn waitUntilVisible(
+    device: anytype,
+    wanted: selector.Selector,
+    timeout_ms: u64,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !bool {
+    return try runner_waits.waitUntilVisible(device, wanted, timeout_ms, writer, options);
+}
+
+pub fn waitUntilNotVisible(
+    device: anytype,
+    wanted: selector.Selector,
+    timeout_ms: u64,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !bool {
+    return try runner_waits.waitUntilNotVisible(device, wanted, timeout_ms, writer, options);
+}
+
+pub fn waitUntilAnyVisible(
+    device: anytype,
+    selectors: []const selector.Selector,
+    timeout_ms: u64,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !?usize {
+    return try runner_waits.waitUntilAnyVisible(device, selectors, timeout_ms, writer, options);
+}
+
+pub fn assertNoneVisible(
+    device: anytype,
+    selectors: []const selector.Selector,
+    timeout_ms: u64,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !bool {
+    return try runner_waits.assertNoneVisible(device, selectors, timeout_ms, writer, options);
+}
+
+pub fn assertHealthy(
+    device: anytype,
+    timeout_ms: u64,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !bool {
+    return try runner_waits.assertHealthy(device, timeout_ms, writer, options);
+}
+
+pub fn scrollUntilVisible(
+    device: anytype,
+    wanted: selector.Selector,
+    timeout_ms: u64,
+    direction: scenario.ScrollDirection,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !bool {
+    return try runner_waits.scrollUntilVisible(device, wanted, timeout_ms, direction, writer, options);
+}
+
+fn isVisibleNow(
+    device: anytype,
+    wanted: selector.Selector,
+    writer: ?*trace.TraceWriter,
+) !bool {
+    var snap = try device.snapshot(writer);
+    defer snap.deinit(device.allocator);
+    return selector.find(snap.nodes, wanted) != null;
+}
+
+fn sleepMs(ms: u64) !void {
+    std.Thread.sleep(ms * std.time.ns_per_ms);
+}
+
+fn settleDevice(device: anytype, options: RunOptions) !void {
+    try device.settle(options.settle_ms);
+}

package/src/runner_actions.zig

@@ -0,0 +1,109 @@
+const std = @import("std");
+const runner_config = @import("runner_config.zig");
+const runner_events = @import("runner_events.zig");
+const runner_native = @import("runner_native.zig");
+const selector = @import("selector.zig");
+const trace = @import("trace.zig");
+const types = @import("types.zig");
+
+const RunOptions = runner_config.RunOptions;
+
+pub fn tapSelector(
+    device: anytype,
+    wanted: selector.Selector,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    if (try runner_native.tryTapSelector(device, wanted, writer, options.settle_ms)) return;
+
+    const deadline = std.time.milliTimestamp() + @as(i64, @intCast(options.action_timeout_ms));
+    var attempts: u32 = 0;
+    while (true) {
+        attempts += 1;
+        var snap = try device.snapshot(writer);
+        defer snap.deinit(device.allocator);
+        if (findActionable(snap, wanted)) |node| {
+            try device.tap(node.bounds.centerX(), node.bounds.centerY());
+            if (writer) |tw| {
+                var payload = std.ArrayList(u8).empty;
+                defer payload.deinit(tw.allocator);
+                try payload.writer(tw.allocator).print("{{\"snapshotId\":\"{s}\",\"target\":\"{s}\",\"x\":{d},\"y\":{d},\"attempts\":{d},\"selector\":", .{
+                    snap.id,
+                    node.stable_id,
+                    node.bounds.centerX(),
+                    node.bounds.centerY(),
+                    attempts,
+                });
+                try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
+                try payload.writer(tw.allocator).writeAll("}");
+                try tw.recordEvent("ui.tap", payload.items);
+            }
+            try settleDevice(device, options);
+            return;
+        }
+        if (std.time.milliTimestamp() >= deadline) {
+            if (writer) |tw| {
+                try runner_events.recordSelectorMiss(tw, "ui.tap.notFound", wanted, snap);
+            }
+            return error.SelectorNotFound;
+        }
+        try sleepMs(options.poll_ms);
+    }
+}
+
+pub fn typeTextSelector(
+    device: anytype,
+    wanted: selector.Selector,
+    text: []const u8,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    if (try runner_native.tryTypeTextSelector(device, wanted, text, writer, options.settle_ms)) return;
+    try tapSelector(device, wanted, writer, options);
+    try device.typeText(text);
+    try settleDevice(device, options);
+}
+
+pub fn eraseTextSelector(
+    device: anytype,
+    wanted: selector.Selector,
+    max_chars: u32,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    if (try runner_native.tryEraseTextSelector(device, wanted, max_chars, writer, options.settle_ms)) return;
+    try tapSelector(device, wanted, writer, options);
+    try device.eraseText(max_chars);
+    if (writer) |tw| {
+        const payload = try std.fmt.allocPrint(tw.allocator, "{{\"maxChars\":{d}}}", .{max_chars});
+        defer tw.allocator.free(payload);
+        try tw.recordEvent("ui.eraseText", payload);
+    }
+    try settleDevice(device, options);
+}
+
+fn findActionable(snap: types.ObservationSnapshot, wanted: selector.Selector) ?types.UiNode {
+    for (snap.nodes) |node| {
+        if (!selector.matches(node, wanted)) continue;
+        if (!node.enabled) continue;
+        if (!isInViewport(node, snap.viewport)) continue;
+        return node;
+    }
+    return null;
+}
+
+fn isInViewport(node: types.UiNode, viewport: types.Viewport) bool {
+    if (node.bounds.width <= 0 or node.bounds.height <= 0) return false;
+    if (viewport.width == 0 or viewport.height == 0) return true;
+    const right = node.bounds.x + node.bounds.width;
+    const bottom = node.bounds.y + node.bounds.height;
+    return right > 0 and bottom > 0 and node.bounds.x < @as(i32, @intCast(viewport.width)) and node.bounds.y < @as(i32, @intCast(viewport.height));
+}
+
+fn settleDevice(device: anytype, options: RunOptions) !void {
+    try device.settle(options.settle_ms);
+}
+
+fn sleepMs(ms: u64) !void {
+    std.Thread.sleep(ms * std.time.ns_per_ms);
+}

package/src/runner_config.zig

@@ -0,0 +1,6 @@
+pub const RunOptions = struct {
+    settle_ms: u64 = 500,
+    poll_ms: u64 = 500,
+    default_timeout_ms: u64 = 5000,
+    action_timeout_ms: u64 = 5000,
+};

package/src/runner_diagnostics.zig

@@ -0,0 +1,268 @@
+const std = @import("std");
+const selector = @import("selector.zig");
+const trace = @import("trace.zig");
+const types = @import("types.zig");
+
+pub fn record(
+    tw: *trace.TraceWriter,
+    kind: []const u8,
+    status: []const u8,
+    strategy: ?[]const u8,
+    selectors: []const selector.Selector,
+    snap: types.ObservationSnapshot,
+) !void {
+    var payload = std.ArrayList(u8).empty;
+    defer payload.deinit(tw.allocator);
+    try writeSelectorDiagnosticJson(payload.writer(tw.allocator), status, strategy, selectors, snap);
+    try tw.recordEvent(kind, payload.items);
+}
+
+pub fn writeSelectorDiagnosticJson(
+    writer: anytype,
+    status: []const u8,
+    strategy: ?[]const u8,
+    selectors: []const selector.Selector,
+    snap: types.ObservationSnapshot,
+) !void {
+    try writer.print("{{\"status\":\"{s}\"", .{status});
+    if (strategy) |value| {
+        try writer.writeAll(",\"strategy\":");
+        try trace.writeJsonString(writer, value);
+    }
+    try writer.print(",\"snapshotId\":\"{s}\",\"selectors\":[", .{snap.id});
+    for (selectors, 0..) |wanted, index| {
+        if (index > 0) try writer.writeAll(",");
+        try trace.writeSelectorJson(writer, wanted);
+    }
+    try writer.writeAll("],\"activePackage\":");
+    if (snap.active_package) |value| {
+        try trace.writeJsonString(writer, value);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.writeAll(",\"activeActivity\":");
+    if (snap.active_activity) |value| {
+        try trace.writeJsonString(writer, value);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.writeAll(",\"visibleTexts\":[");
+    var count: usize = 0;
+    for (snap.nodes) |node| {
+        const text = node.text orelse node.content_desc orelse continue;
+        if (!node.visible or text.len == 0) continue;
+        if (count > 0) try writer.writeAll(",");
+        try trace.writeJsonString(writer, text);
+        count += 1;
+        if (count >= 20) break;
+    }
+    try writer.writeAll("]");
+    try writeCandidateList(writer, "hiddenCandidates", selectors, snap, .hidden);
+    try writeCandidateList(writer, "disabledCandidates", selectors, snap, .disabled);
+    try writeCandidateList(writer, "offscreenCandidates", selectors, snap, .offscreen);
+    try writeNearestTextMatches(writer, selectors, snap);
+    try writer.writeAll("}");
+}
+
+const CandidateKind = enum {
+    hidden,
+    disabled,
+    offscreen,
+};
+
+fn writeCandidateList(
+    writer: anytype,
+    field_name: []const u8,
+    selectors: []const selector.Selector,
+    snap: types.ObservationSnapshot,
+    candidate_kind: CandidateKind,
+) !void {
+    try writer.print(",\"{s}\":[", .{field_name});
+    var count: usize = 0;
+    for (snap.nodes) |node| {
+        var matched = false;
+        for (selectors) |wanted| {
+            if (nodeMatchesSelectorFields(node, wanted)) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) continue;
+        const include = switch (candidate_kind) {
+            .hidden => !node.visible,
+            .disabled => node.visible and !node.enabled,
+            .offscreen => node.visible and node.enabled and !isInViewport(node, snap.viewport),
+        };
+        if (!include) continue;
+        if (count > 0) try writer.writeAll(",");
+        try writeNodeDiagnostic(writer, node);
+        count += 1;
+        if (count >= 10) break;
+    }
+    try writer.writeAll("]");
+}
+
+fn writeNearestTextMatches(writer: anytype, selectors: []const selector.Selector, snap: types.ObservationSnapshot) !void {
+    try writer.writeAll(",\"nearestTextMatches\":[");
+    var written: usize = 0;
+    for (selectors) |wanted| {
+        const target = selectorTextTarget(wanted) orelse continue;
+        var best: [5]NearestCandidate = undefined;
+        var best_len: usize = 0;
+        for (snap.nodes) |node| {
+            const label = nodeLabel(node) orelse continue;
+            if (label.len == 0 or nodeMatchesSelectorFields(node, wanted)) continue;
+            const score = textDistance(target, label);
+            if (score > @max(target.len, label.len)) continue;
+            insertNearest(&best, &best_len, .{ .node = node, .text = label, .score = score });
+        }
+        for (best[0..best_len]) |candidate| {
+            if (written > 0) try writer.writeAll(",");
+            try writer.writeAll("{\"stableId\":");
+            try trace.writeJsonString(writer, candidate.node.stable_id);
+            try writer.writeAll(",\"text\":");
+            try trace.writeJsonString(writer, candidate.text);
+            try writer.print(",\"score\":{d}", .{candidate.score});
+            try writer.writeAll(",\"enabled\":");
+            try writer.writeAll(if (candidate.node.enabled) "true" else "false");
+            try writer.writeAll(",\"visible\":");
+            try writer.writeAll(if (candidate.node.visible) "true" else "false");
+            try writer.writeAll("}");
+            written += 1;
+            if (written >= 10) break;
+        }
+        if (written >= 10) break;
+    }
+    try writer.writeAll("]");
+}
+
+const NearestCandidate = struct {
+    node: types.UiNode,
+    text: []const u8,
+    score: usize,
+};
+
+fn insertNearest(candidates: *[5]NearestCandidate, len: *usize, candidate: NearestCandidate) void {
+    const insert_limit = candidates.len;
+    if (len.* == insert_limit and candidate.score >= candidates[len.* - 1].score) return;
+    var index: usize = 0;
+    while (index < len.* and candidates[index].score <= candidate.score) : (index += 1) {}
+    if (len.* < insert_limit) len.* += 1;
+    var move_index = len.* - 1;
+    while (move_index > index) : (move_index -= 1) {
+        candidates[move_index] = candidates[move_index - 1];
+    }
+    candidates[index] = candidate;
+}
+
+fn writeNodeDiagnostic(writer: anytype, node: types.UiNode) !void {
+    try writer.writeAll("{\"stableId\":");
+    try trace.writeJsonString(writer, node.stable_id);
+    try writer.writeAll(",\"className\":");
+    try trace.writeJsonString(writer, node.class_name);
+    try writer.writeAll(",\"text\":");
+    if (node.text) |value| {
+        try trace.writeJsonString(writer, value);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.writeAll(",\"contentDesc\":");
+    if (node.content_desc) |value| {
+        try trace.writeJsonString(writer, value);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.writeAll(",\"resourceId\":");
+    if (node.resource_id) |value| {
+        try trace.writeJsonString(writer, value);
+    } else {
+        try writer.writeAll("null");
+    }
+    try writer.print(
+        ",\"bounds\":{{\"x\":{d},\"y\":{d},\"width\":{d},\"height\":{d}}}",
+        .{ node.bounds.x, node.bounds.y, node.bounds.width, node.bounds.height },
+    );
+    try writer.writeAll(",\"enabled\":");
+    try writer.writeAll(if (node.enabled) "true" else "false");
+    try writer.writeAll(",\"visible\":");
+    try writer.writeAll(if (node.visible) "true" else "false");
+    try writer.writeAll("}");
+}
+
+fn nodeMatchesSelectorFields(node: types.UiNode, wanted: selector.Selector) bool {
+    if (wanted.id) |id| {
+        if (node.resource_id == null or !std.mem.eql(u8, node.resource_id.?, id)) return false;
+    }
+    if (wanted.text) |text| {
+        if (node.text == null or !std.mem.eql(u8, node.text.?, text)) return false;
+    }
+    if (wanted.text_contains) |needle| {
+        if (node.text == null or std.mem.indexOf(u8, node.text.?, needle) == null) return false;
+    }
+    if (wanted.content_desc) |desc| {
+        if (node.content_desc == null or !std.mem.eql(u8, node.content_desc.?, desc)) return false;
+    }
+    if (wanted.content_desc_contains) |needle| {
+        if (node.content_desc == null or std.mem.indexOf(u8, node.content_desc.?, needle) == null) return false;
+    }
+    if (wanted.class_name) |class_name| {
+        if (!std.mem.eql(u8, node.class_name, class_name)) return false;
+    }
+    return true;
+}
+
+fn selectorTextTarget(wanted: selector.Selector) ?[]const u8 {
+    if (wanted.text) |value| return value;
+    if (wanted.text_contains) |value| return value;
+    if (wanted.content_desc) |value| return value;
+    if (wanted.content_desc_contains) |value| return value;
+    return null;
+}
+
+fn nodeLabel(node: types.UiNode) ?[]const u8 {
+    if (node.text) |value| return value;
+    if (node.content_desc) |value| return value;
+    return null;
+}
+
+fn isInViewport(node: types.UiNode, viewport: types.Viewport) bool {
+    if (node.bounds.width <= 0 or node.bounds.height <= 0) return false;
+    if (viewport.width == 0 or viewport.height == 0) return true;
+    const right = node.bounds.x + node.bounds.width;
+    const bottom = node.bounds.y + node.bounds.height;
+    return right > 0 and bottom > 0 and node.bounds.x < @as(i32, @intCast(viewport.width)) and node.bounds.y < @as(i32, @intCast(viewport.height));
+}
+
+fn textDistance(left: []const u8, right: []const u8) usize {
+    if (containsIgnoreCase(left, right) or containsIgnoreCase(right, left)) {
+        return if (left.len > right.len) left.len - right.len else right.len - left.len;
+    }
+    const prefix = commonPrefixIgnoreCase(left, right);
+    return @max(left.len, right.len) - prefix;
+}
+
+fn containsIgnoreCase(haystack: []const u8, needle: []const u8) bool {
+    if (needle.len == 0) return true;
+    if (needle.len > haystack.len) return false;
+    var index: usize = 0;
+    while (index + needle.len <= haystack.len) : (index += 1) {
+        var matched = true;
+        for (needle, 0..) |needle_ch, offset| {
+            if (std.ascii.toLower(haystack[index + offset]) != std.ascii.toLower(needle_ch)) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) return true;
+    }
+    return false;
+}
+
+fn commonPrefixIgnoreCase(left: []const u8, right: []const u8) usize {
+    const limit = @min(left.len, right.len);
+    var index: usize = 0;
+    while (index < limit) : (index += 1) {
+        if (std.ascii.toLower(left[index]) != std.ascii.toLower(right[index])) break;
+    }
+    return index;
+}