zeno-mobile-runner 0.2.0 → 0.2.2

package/src/runner_events.zig

@@ -5,35 +5,38 @@ const trace = @import("trace.zig");
 const types = @import("types.zig");
 
 pub fn eventString(allocator: std.mem.Allocator, value: []const u8) ![]const u8 {
-    var buffer = std.ArrayList(u8).empty;
-    errdefer buffer.deinit(allocator);
-    try buffer.writer(allocator).writeAll("{\"value\":");
-    try trace.writeJsonString(buffer.writer(allocator), value);
-    try buffer.writer(allocator).writeAll("}");
-    return try buffer.toOwnedSlice(allocator);
+    var buffer: std.Io.Writer.Allocating = .init(allocator);
+    errdefer buffer.deinit();
+    const writer = &buffer.writer;
+    try writer.writeAll("{\"value\":");
+    try trace.writeJsonString(writer, value);
+    try writer.writeAll("}");
+    return try buffer.toOwnedSlice();
 }
 
 pub fn recordNativeWait(tw: *trace.TraceWriter, kind: []const u8, wanted: selector.Selector, matched_index: ?usize, timeout_ms: u64) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    try payload.writer(tw.allocator).writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\"");
-    if (matched_index) |index| try payload.writer(tw.allocator).print(",\"matchedIndex\":{d}", .{index});
-    try payload.writer(tw.allocator).writeAll(",\"selector\":");
-    try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-    try payload.writer(tw.allocator).print(",\"timeoutMs\":{d}}}", .{timeout_ms});
-    try tw.recordEvent(kind, payload.items);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const writer = &payload.writer;
+    try writer.writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\"");
+    if (matched_index) |index| try writer.print(",\"matchedIndex\":{d}", .{index});
+    try writer.writeAll(",\"selector\":");
+    try trace.writeSelectorJson(writer, wanted);
+    try writer.print(",\"timeoutMs\":{d}}}", .{timeout_ms});
+    try tw.recordEvent(kind, writer.buffered());
 }
 
 pub fn recordNativeWaitTimeout(tw: *trace.TraceWriter, kind: []const u8, selectors: []const selector.Selector, timeout_ms: u64) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    try payload.writer(tw.allocator).print("{{\"status\":\"timeout\",\"strategy\":\"nativeSelector\",\"timeoutMs\":{d},\"selectors\":[", .{timeout_ms});
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const writer = &payload.writer;
+    try writer.print("{{\"status\":\"timeout\",\"strategy\":\"nativeSelector\",\"timeoutMs\":{d},\"selectors\":[", .{timeout_ms});
     for (selectors, 0..) |wanted, index| {
-        if (index > 0) try payload.writer(tw.allocator).writeAll(",");
-        try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
+        if (index > 0) try writer.writeAll(",");
+        try trace.writeSelectorJson(writer, wanted);
     }
-    try payload.writer(tw.allocator).writeAll("]}");
-    try tw.recordEvent(kind, payload.items);
+    try writer.writeAll("]}");
+    try tw.recordEvent(kind, writer.buffered());
 }
 
 pub fn recordNativeWaitTimeoutWithDiagnostics(device: anytype, tw: *trace.TraceWriter, kind: []const u8, selectors: []const selector.Selector, timeout_ms: u64) !void {
@@ -46,9 +49,9 @@ pub fn recordNativeWaitTimeoutWithDiagnostics(device: anytype, tw: *trace.TraceW
 }
 
 pub fn recordSelectorArrayStatus(tw: *trace.TraceWriter, kind: []const u8, status: []const u8, selectors: []const selector.Selector, timeout_ms: u64) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    const out = payload.writer(tw.allocator);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const out = &payload.writer;
     try out.writeAll("{\"status\":");
     try trace.writeJsonString(out, status);
     try out.writeAll(",\"selectors\":[");
@@ -57,22 +60,23 @@ pub fn recordSelectorArrayStatus(tw: *trace.TraceWriter, kind: []const u8, statu
         try trace.writeSelectorJson(out, wanted);
     }
     try out.print("],\"timeoutMs\":{d}}}", .{timeout_ms});
-    try tw.recordEvent(kind, payload.items);
+    try tw.recordEvent(kind, out.buffered());
 }
 
 pub fn recordSelectorEvent(tw: *trace.TraceWriter, kind: []const u8, wanted: selector.Selector) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    try payload.writer(tw.allocator).writeAll("{\"selector\":");
-    try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-    try payload.writer(tw.allocator).writeAll("}");
-    try tw.recordEvent(kind, payload.items);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const writer = &payload.writer;
+    try writer.writeAll("{\"selector\":");
+    try trace.writeSelectorJson(writer, wanted);
+    try writer.writeAll("}");
+    try tw.recordEvent(kind, writer.buffered());
 }
 
 pub fn recordActionStatus(tw: *trace.TraceWriter, kind: []const u8, status: []const u8, err: ?anyerror, url: ?[]const u8) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    const out = payload.writer(tw.allocator);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const out = &payload.writer;
     try out.writeAll("{\"status\":");
     try trace.writeJsonString(out, status);
     if (err) |actual| {
@@ -84,7 +88,7 @@ pub fn recordActionStatus(tw: *trace.TraceWriter, kind: []const u8, status: []co
         try trace.writeJsonString(out, value);
     }
     try out.writeAll("}");
-    try tw.recordEvent(kind, payload.items);
+    try tw.recordEvent(kind, out.buffered());
 }
 
 pub fn recordSwipe(tw: *trace.TraceWriter, x1: i32, y1: i32, x2: i32, y2: i32, duration_ms: u32) !void {
@@ -98,21 +102,21 @@ pub fn recordSwipe(tw: *trace.TraceWriter, x1: i32, y1: i32, x2: i32, y2: i32, d
 }
 
 pub fn recordTraceDiscover(tw: *trace.TraceWriter, status: []const u8, out_path: []const u8, include_actions: bool, validated: bool) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    const out = payload.writer(tw.allocator);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const out = &payload.writer;
     try out.writeAll("{\"status\":");
     try trace.writeJsonString(out, status);
     try out.writeAll(",\"out\":");
     try trace.writeJsonString(out, out_path);
     try out.print(",\"includeActions\":{},\"validated\":{}}}", .{ include_actions, validated });
-    try tw.recordEvent("trace.discover", payload.items);
+    try tw.recordEvent("trace.discover", out.buffered());
 }
 
 pub fn recordTraceExplore(tw: *trace.TraceWriter, status: []const u8, out_path: []const u8, goal: []const u8, include_actions: bool, validated: bool) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    const out = payload.writer(tw.allocator);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const out = &payload.writer;
     try out.writeAll("{\"status\":");
     try trace.writeJsonString(out, status);
     try out.writeAll(",\"out\":");
@@ -120,7 +124,7 @@ pub fn recordTraceExplore(tw: *trace.TraceWriter, status: []const u8, out_path:
     try out.writeAll(",\"goal\":");
     try trace.writeJsonString(out, goal);
     try out.print(",\"includeActions\":{},\"validated\":{}}}", .{ include_actions, validated });
-    try tw.recordEvent("trace.explore", payload.items);
+    try tw.recordEvent("trace.explore", out.buffered());
 }
 
 pub fn recordStepError(tw: *trace.TraceWriter, index: usize, err: anyerror) !void {
@@ -140,9 +144,9 @@ pub fn recordScenarioEnd(
     failed_index: ?usize,
     err: ?anyerror,
 ) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    const writer = payload.writer(tw.allocator);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const writer = &payload.writer;
     try writer.writeAll("{\"value\":");
     try trace.writeJsonString(writer, name);
     try writer.writeAll(",\"status\":");
@@ -155,7 +159,7 @@ pub fn recordScenarioEnd(
         try trace.writeJsonString(writer, @errorName(actual));
     }
     try writer.writeAll("}");
-    try tw.recordEvent("scenario.end", payload.items);
+    try tw.recordEvent("scenario.end", writer.buffered());
 }
 
 pub fn recordSelectorMiss(
@@ -178,15 +182,15 @@ pub fn recordWaitTimeout(
 }
 
 pub fn recordObservationRetry(tw: *trace.TraceWriter, kind: []const u8, err: anyerror) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    const writer = payload.writer(tw.allocator);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const writer = &payload.writer;
     try writer.writeAll("{\"status\":\"retry\",\"kind\":");
     try trace.writeJsonString(writer, kind);
     try writer.writeAll(",\"error\":");
     try trace.writeJsonString(writer, @errorName(err));
     try writer.writeAll("}");
-    try tw.recordEvent("observe.retry", payload.items);
+    try tw.recordEvent("observe.retry", writer.buffered());
 }
 
 pub fn recordDiagnostic(

package/src/runner_native.zig

@@ -61,13 +61,14 @@ fn recordSelectorAction(
     wanted: selector.Selector,
     max_chars: ?u32,
 ) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    try payload.writer(tw.allocator).writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\",\"selector\":");
-    try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-    if (max_chars) |value| try payload.writer(tw.allocator).print(",\"maxChars\":{d}", .{value});
-    try payload.writer(tw.allocator).writeAll("}");
-    try tw.recordEvent(kind, payload.items);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const writer = &payload.writer;
+    try writer.writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\",\"selector\":");
+    try trace.writeSelectorJson(writer, wanted);
+    if (max_chars) |value| try writer.print(",\"maxChars\":{d}", .{value});
+    try writer.writeAll("}");
+    try tw.recordEvent(kind, writer.buffered());
 }
 
 fn recordSelectorTextAction(
@@ -76,14 +77,15 @@ fn recordSelectorTextAction(
     wanted: selector.Selector,
     text: []const u8,
 ) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    try payload.writer(tw.allocator).writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\",\"selector\":");
-    try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-    try payload.writer(tw.allocator).writeAll(",\"text\":");
-    try trace.writeJsonString(payload.writer(tw.allocator), text);
-    try payload.writer(tw.allocator).writeAll("}");
-    try tw.recordEvent(kind, payload.items);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const writer = &payload.writer;
+    try writer.writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\",\"selector\":");
+    try trace.writeSelectorJson(writer, wanted);
+    try writer.writeAll(",\"text\":");
+    try trace.writeJsonString(writer, text);
+    try writer.writeAll("}");
+    try tw.recordEvent(kind, writer.buffered());
 }
 
 fn recordSelectorActionFailure(
@@ -92,13 +94,13 @@ fn recordSelectorActionFailure(
     wanted: selector.Selector,
     err: anyerror,
 ) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    const out = payload.writer(tw.allocator);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const out = &payload.writer;
     try out.writeAll("{\"status\":\"failed\",\"strategy\":\"nativeSelector\",\"error\":");
     try trace.writeJsonString(out, @errorName(err));
     try out.writeAll(",\"selector\":");
     try trace.writeSelectorJson(out, wanted);
     try out.writeAll("}");
-    try tw.recordEvent(kind, payload.items);
+    try tw.recordEvent(kind, out.buffered());
 }

package/src/runner_waits.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const health = @import("health.zig");
 const runner_config = @import("runner_config.zig");
 const runner_events = @import("runner_events.zig");
@@ -37,14 +38,14 @@ fn untilVisibleKind(
     options: RunOptions,
     kind: []const u8,
 ) !bool {
-    const deadline = std.time.milliTimestamp() + @as(i64, @intCast(timeout_ms));
+    const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
     while (true) {
         if (try nativeVisibleBySelector(device, wanted)) |visible| {
             if (visible) {
                 if (writer) |tw| try runner_events.recordNativeWait(tw, kind, wanted, null, timeout_ms);
                 return true;
             }
-            if (std.time.milliTimestamp() >= deadline) {
+            if (stdio.nowMs() >= deadline) {
                 if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, kind, &[_]selector.Selector{wanted}, timeout_ms);
                 return false;
             }
@@ -58,16 +59,17 @@ fn untilVisibleKind(
         defer snap.deinit(device.allocator);
         if (selector.find(snap.nodes, wanted)) |node| {
             if (writer) |tw| {
-                var payload = std.ArrayList(u8).empty;
-                defer payload.deinit(tw.allocator);
-                try payload.writer(tw.allocator).print("{{\"status\":\"ok\",\"target\":\"{s}\",\"selector\":", .{node.stable_id});
-                try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-                try payload.writer(tw.allocator).print(",\"timeoutMs\":{d}}}", .{timeout_ms});
-                try tw.recordEvent(kind, payload.items);
+                var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+                defer payload.deinit();
+                const out = &payload.writer;
+                try out.print("{{\"status\":\"ok\",\"target\":\"{s}\",\"selector\":", .{node.stable_id});
+                try trace.writeSelectorJson(out, wanted);
+                try out.print(",\"timeoutMs\":{d}}}", .{timeout_ms});
+                try tw.recordEvent(kind, out.buffered());
             }
             return true;
         }
-        if (std.time.milliTimestamp() >= deadline) {
+        if (stdio.nowMs() >= deadline) {
             if (writer) |tw| {
                 const selectors = [_]selector.Selector{wanted};
                 try runner_events.recordDiagnosticWithStrategyAndTimeout(tw, kind, "timeout", null, selectors[0..], snap, timeout_ms);
@@ -106,14 +108,14 @@ fn untilNotVisibleKind(
     options: RunOptions,
     kind: []const u8,
 ) !bool {
-    const deadline = std.time.milliTimestamp() + @as(i64, @intCast(timeout_ms));
+    const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
     while (true) {
         if (try nativeVisibleBySelector(device, wanted)) |visible| {
             if (!visible) {
                 if (writer) |tw| try runner_events.recordNativeWait(tw, kind, wanted, null, timeout_ms);
                 return true;
             }
-            if (std.time.milliTimestamp() >= deadline) {
+            if (stdio.nowMs() >= deadline) {
                 if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, kind, &[_]selector.Selector{wanted}, timeout_ms);
                 return false;
             }
@@ -127,16 +129,17 @@ fn untilNotVisibleKind(
         defer snap.deinit(device.allocator);
         if (selector.find(snap.nodes, wanted) == null) {
             if (writer) |tw| {
-                var payload = std.ArrayList(u8).empty;
-                defer payload.deinit(tw.allocator);
-                try payload.writer(tw.allocator).writeAll("{\"status\":\"ok\",\"selector\":");
-                try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-                try payload.writer(tw.allocator).print(",\"timeoutMs\":{d}}}", .{timeout_ms});
-                try tw.recordEvent(kind, payload.items);
+                var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+                defer payload.deinit();
+                const out = &payload.writer;
+                try out.writeAll("{\"status\":\"ok\",\"selector\":");
+                try trace.writeSelectorJson(out, wanted);
+                try out.print(",\"timeoutMs\":{d}}}", .{timeout_ms});
+                try tw.recordEvent(kind, out.buffered());
             }
             return true;
         }
-        if (std.time.milliTimestamp() >= deadline) {
+        if (stdio.nowMs() >= deadline) {
             if (writer) |tw| {
                 const selectors = [_]selector.Selector{wanted};
                 try runner_events.recordDiagnosticWithStrategyAndTimeout(tw, kind, "timeout", null, selectors[0..], snap, timeout_ms);
@@ -154,7 +157,7 @@ pub fn waitUntilAnyVisible(
     writer: ?*trace.TraceWriter,
     options: RunOptions,
 ) !?usize {
-    const deadline = std.time.milliTimestamp() + @as(i64, @intCast(timeout_ms));
+    const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
     while (true) {
         var all_native = true;
         for (selectors, 0..) |wanted, index| {
@@ -169,7 +172,7 @@ pub fn waitUntilAnyVisible(
             }
         }
         if (all_native) {
-            if (std.time.milliTimestamp() >= deadline) {
+            if (stdio.nowMs() >= deadline) {
                 if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, "wait.any", selectors, timeout_ms);
                 return null;
             }
@@ -184,17 +187,18 @@ pub fn waitUntilAnyVisible(
         for (selectors, 0..) |wanted, index| {
             if (selector.find(snap.nodes, wanted)) |node| {
                 if (writer) |tw| {
-                    var payload = std.ArrayList(u8).empty;
-                    defer payload.deinit(tw.allocator);
-                    try payload.writer(tw.allocator).print("{{\"status\":\"ok\",\"matchedIndex\":{d},\"target\":\"{s}\",\"selector\":", .{ index, node.stable_id });
-                    try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-                    try payload.writer(tw.allocator).print(",\"timeoutMs\":{d}}}", .{timeout_ms});
-                    try tw.recordEvent("wait.any", payload.items);
+                    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+                    defer payload.deinit();
+                    const out = &payload.writer;
+                    try out.print("{{\"status\":\"ok\",\"matchedIndex\":{d},\"target\":\"{s}\",\"selector\":", .{ index, node.stable_id });
+                    try trace.writeSelectorJson(out, wanted);
+                    try out.print(",\"timeoutMs\":{d}}}", .{timeout_ms});
+                    try tw.recordEvent("wait.any", out.buffered());
                 }
                 return index;
             }
         }
-        if (std.time.milliTimestamp() >= deadline) {
+        if (stdio.nowMs() >= deadline) {
             if (writer) |tw| try runner_events.recordWaitTimeout(tw, "wait.any", selectors, snap);
             return null;
         }
@@ -209,7 +213,7 @@ pub fn assertNoneVisible(
     writer: ?*trace.TraceWriter,
     options: RunOptions,
 ) !bool {
-    const deadline = std.time.milliTimestamp() + @as(i64, @intCast(timeout_ms));
+    const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
     while (true) {
         var snap = device.snapshot(writer) catch |err| {
             if (try retryTransientObservation(err, "assert.noneVisible", writer, deadline, options)) continue;
@@ -230,7 +234,7 @@ pub fn assertNoneVisible(
             return true;
         }
 
-        if (std.time.milliTimestamp() >= deadline) {
+        if (stdio.nowMs() >= deadline) {
             if (writer) |tw| try runner_events.recordDiagnosticWithStrategyAndTimeout(tw, "assert.noneVisible", "visible", null, selectors, snap, timeout_ms);
             return false;
         }
@@ -246,7 +250,7 @@ pub fn assertHealthy(
     options: RunOptions,
 ) !bool {
     const health_selectors = health.defaultSelectors();
-    const deadline = std.time.milliTimestamp() + @as(i64, @intCast(timeout_ms));
+    const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
     while (true) {
         var snap = device.snapshot(writer) catch |err| {
             if (try retryTransientObservation(err, "assert.healthy", writer, deadline, options)) continue;
@@ -263,7 +267,7 @@ pub fn assertHealthy(
             return true;
         }
 
-        if (std.time.milliTimestamp() >= deadline) {
+        if (stdio.nowMs() >= deadline) {
             if (writer) |tw| try runner_events.recordDiagnosticWithStrategyAndTimeout(tw, "assert.healthy", "unhealthy", null, health_selectors, snap, timeout_ms);
             return false;
         }
@@ -280,7 +284,7 @@ pub fn scrollUntilVisible(
     writer: ?*trace.TraceWriter,
     options: RunOptions,
 ) !bool {
-    const deadline = std.time.milliTimestamp() + @as(i64, @intCast(timeout_ms));
+    const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
     while (true) {
         var snap = device.snapshot(writer) catch |err| {
             if (try retryTransientObservation(err, "ui.scrollUntilVisible", writer, deadline, options)) continue;
@@ -289,19 +293,20 @@ pub fn scrollUntilVisible(
         defer snap.deinit(device.allocator);
         if (selector.find(snap.nodes, wanted)) |node| {
             if (writer) |tw| {
-                var payload = std.ArrayList(u8).empty;
-                defer payload.deinit(tw.allocator);
-                try payload.writer(tw.allocator).print("{{\"status\":\"ok\",\"target\":\"{s}\",\"selector\":", .{node.stable_id});
-                try trace.writeSelectorJson(payload.writer(tw.allocator), wanted);
-                try payload.writer(tw.allocator).print(",\"direction\":\"{s}\",\"timeoutMs\":{d}}}", .{
+                var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+                defer payload.deinit();
+                const out = &payload.writer;
+                try out.print("{{\"status\":\"ok\",\"target\":\"{s}\",\"selector\":", .{node.stable_id});
+                try trace.writeSelectorJson(out, wanted);
+                try out.print(",\"direction\":\"{s}\",\"timeoutMs\":{d}}}", .{
                     if (direction == .down) "down" else "up",
                     timeout_ms,
                 });
-                try tw.recordEvent("ui.scrollUntilVisible", payload.items);
+                try tw.recordEvent("ui.scrollUntilVisible", out.buffered());
             }
             return true;
         }
-        if (std.time.milliTimestamp() >= deadline) {
+        if (stdio.nowMs() >= deadline) {
             if (writer) |tw| {
                 const selectors = [_]selector.Selector{wanted};
                 try runner_events.recordWaitTimeout(tw, "ui.scrollUntilVisible", selectors[0..], snap);
@@ -348,7 +353,7 @@ fn retryTransientObservation(
     options: RunOptions,
 ) !bool {
     if (err != error.CommandTimedOut) return false;
-    if (std.time.milliTimestamp() >= deadline) return false;
+    if (stdio.nowMs() >= deadline) return false;
     if (writer) |tw| try runner_events.recordObservationRetry(tw, kind, err);
     try sleepMs(options.poll_ms);
     return true;
@@ -359,5 +364,5 @@ fn settleDevice(device: anytype, options: RunOptions) !void {
 }
 
 fn sleepMs(ms: u64) !void {
-    std.Thread.sleep(ms * std.time.ns_per_ms);
+    stdio.sleepNs(ms * std.time.ns_per_ms);
 }

package/src/scaffold.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 pub const app_config_file = ".zmr/config.json";
 pub const app_android_smoke_file = ".zmr/android-smoke.json";
@@ -40,24 +41,24 @@ pub fn writeStarterScenario(
     force: bool,
 ) !void {
     if (!force) {
-        std.fs.cwd().access(path, .{}) catch |err| switch (err) {
+        stdio.access(path) catch |err| switch (err) {
             error.FileNotFound => {},
             else => return err,
         };
-        if (std.fs.cwd().access(path, .{})) |_| return error.PathAlreadyExists else |err| switch (err) {
+        if (stdio.access(path)) |_| return error.PathAlreadyExists else |err| switch (err) {
             error.FileNotFound => {},
             else => return err,
         }
     }
 
     if (std.fs.path.dirname(path)) |parent| {
-        if (parent.len > 0) try std.fs.cwd().makePath(parent);
+        if (parent.len > 0) try std.Io.Dir.cwd().createDirPath(stdio.io(), parent);
     }
 
-    var file = try std.fs.cwd().createFile(path, .{ .truncate = true });
-    defer file.close();
+    var file = try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .truncate = true });
+    defer file.close(stdio.io());
     var buffer: [4096]u8 = undefined;
-    var file_writer = file.writer(&buffer);
+    var file_writer = file.writerStreaming(stdio.io(), &buffer);
     const writer = &file_writer.interface;
     try writer.writeAll(
         \\{
@@ -87,7 +88,7 @@ pub fn writeAppScaffold(
 ) !void {
     const zmr_dir = try std.fs.path.join(allocator, &.{ dir, ".zmr" });
     defer allocator.free(zmr_dir);
-    try std.fs.cwd().makePath(zmr_dir);
+    try std.Io.Dir.cwd().createDirPath(stdio.io(), zmr_dir);
 
     const config_path = try std.fs.path.join(allocator, &.{ zmr_dir, appFileBasename(app_config_file) });
     defer allocator.free(config_path);
@@ -114,9 +115,9 @@ fn appFileBasename(path: []const u8) []const u8 {
 
 fn writeAppConfig(path: []const u8, app_id: []const u8, force: bool) !void {
     var file = try createOutputFile(path, force);
-    defer file.close();
+    defer file.close(stdio.io());
     var buffer: [8192]u8 = undefined;
-    var file_writer = file.writer(&buffer);
+    var file_writer = file.writerStreaming(stdio.io(), &buffer);
     const writer = &file_writer.interface;
     try writer.writeAll(
         \\{
@@ -190,9 +191,9 @@ fn writeAppConfig(path: []const u8, app_id: []const u8, force: bool) !void {
 
 fn writeDeviceMatrix(path: []const u8, app_id: []const u8, force: bool) !void {
     var file = try createOutputFile(path, force);
-    defer file.close();
+    defer file.close(stdio.io());
     var buffer: [8192]u8 = undefined;
-    var file_writer = file.writer(&buffer);
+    var file_writer = file.writerStreaming(stdio.io(), &buffer);
     const writer = &file_writer.interface;
     try writer.writeAll(
         \\{
@@ -228,9 +229,9 @@ fn writeDeviceMatrix(path: []const u8, app_id: []const u8, force: bool) !void {
 fn writePlatformSmoke(path: []const u8, name: []const u8, app_id: []const u8, force: bool) !void {
     if (!force and try pathExists(path)) return;
     var file = try createOutputFile(path, force);
-    defer file.close();
+    defer file.close(stdio.io());
     var buffer: [4096]u8 = undefined;
-    var file_writer = file.writer(&buffer);
+    var file_writer = file.writerStreaming(stdio.io(), &buffer);
     const writer = &file_writer.interface;
     try writer.writeAll(
         \\{
@@ -256,7 +257,7 @@ fn writePlatformSmoke(path: []const u8, name: []const u8, app_id: []const u8, fo
 }
 
 fn pathExists(path: []const u8) !bool {
-    std.fs.cwd().access(path, .{}) catch |err| switch (err) {
+    stdio.access(path) catch |err| switch (err) {
         error.FileNotFound => return false,
         else => return err,
     };
@@ -300,9 +301,9 @@ fn isShellSafe(value: []const u8) bool {
 
 fn writeAgentInstructions(path: []const u8, app_id: []const u8, force: bool) !void {
     var file = try createOutputFile(path, force);
-    defer file.close();
+    defer file.close(stdio.io());
     var buffer: [4096]u8 = undefined;
-    var file_writer = file.writer(&buffer);
+    var file_writer = file.writerStreaming(stdio.io(), &buffer);
     const writer = &file_writer.interface;
     try writer.writeAll(
         \\# ZMR Agent Instructions
@@ -434,19 +435,19 @@ fn writeAgentInstructions(path: []const u8, app_id: []const u8, force: bool) !vo
     try writer.flush();
 }
 
-fn createOutputFile(path: []const u8, force: bool) !std.fs.File {
+fn createOutputFile(path: []const u8, force: bool) !std.Io.File {
     if (std.fs.path.dirname(path)) |parent| {
-        if (parent.len > 0) try std.fs.cwd().makePath(parent);
+        if (parent.len > 0) try std.Io.Dir.cwd().createDirPath(stdio.io(), parent);
     }
-    if (!force) return try std.fs.cwd().createFile(path, .{ .exclusive = true });
-    return try std.fs.cwd().createFile(path, .{ .truncate = true });
+    if (!force) return try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .exclusive = true });
+    return try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .truncate = true });
 }
 
 fn ensureTraceGitignore(allocator: std.mem.Allocator, dir: []const u8) !void {
     const path = try std.fs.path.join(allocator, &.{ dir, ".gitignore" });
     defer allocator.free(path);
 
-    const existing = std.fs.cwd().readFileAlloc(allocator, path, 1024 * 1024) catch |err| switch (err) {
+    const existing = stdio.readFileAlloc(allocator, path, 1024 * 1024) catch |err| switch (err) {
         error.FileNotFound => "",
         else => return err,
     };
@@ -455,10 +456,10 @@ fn ensureTraceGitignore(allocator: std.mem.Allocator, dir: []const u8) !void {
 
     if (std.mem.indexOf(u8, existing, "traces/") != null) return;
 
-    var file = try std.fs.cwd().createFile(path, .{ .truncate = true });
-    defer file.close();
+    var file = try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .truncate = true });
+    defer file.close(stdio.io());
     var buffer: [4096]u8 = undefined;
-    var file_writer = file.writer(&buffer);
+    var file_writer = file.writerStreaming(stdio.io(), &buffer);
     const writer = &file_writer.interface;
     if (existing.len > 0) {
         try writer.writeAll(existing);

package/src/scenario.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const fields = @import("scenario_fields.zig");
 const selector = @import("selector.zig");
 
@@ -162,7 +163,7 @@ pub const Scenario = struct {
 };
 
 pub fn parseFile(allocator: std.mem.Allocator, path: []const u8) !Scenario {
-    const content = try std.fs.cwd().readFileAlloc(allocator, path, 16 * 1024 * 1024);
+    const content = try stdio.readFileAlloc(allocator, path, 16 * 1024 * 1024);
     defer allocator.free(content);
     return try parseSlice(allocator, content);
 }
@@ -338,7 +339,7 @@ fn parseRawStep(allocator: std.mem.Allocator, object: std.json.ObjectMap) anyerr
         } };
     }
 
-    return error.UnknownScenarioAction;
+    return error.unknownScenarioAction;
 }
 
 fn appendParsedSteps(allocator: std.mem.Allocator, steps: *std.ArrayList(Step), value: std.json.Value) anyerror!void {
@@ -365,7 +366,7 @@ fn optionalDirection(object: std.json.ObjectMap, key: []const u8, default_value:
     if (value != .string) return error.OptionalFieldMustBeString;
     if (std.mem.eql(u8, value.string, "down")) return .down;
     if (std.mem.eql(u8, value.string, "up")) return .up;
-    return error.UnknownScrollDirection;
+    return error.unknownScrollDirection;
 }
 
 fn optionalTimeoutMs(object: std.json.ObjectMap) !?u64 {