zeno-mobile-runner 0.2.1 → 0.2.2

package/src/mcp.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const cli_output = @import("cli_output.zig");
 const errors = @import("errors.zig");
 const mcp_protocol = @import("mcp_protocol.zig");
@@ -13,12 +14,19 @@ const trace = @import("trace.zig");
 const validation = @import("validation.zig");
 
 pub fn serveStdioWithTrace(allocator: std.mem.Allocator, device: anytype, live_trace: ?*trace.TraceWriter) !void {
-    var stdin = std.fs.File.stdin().deprecatedReader();
-    const stdout = std.fs.File.stdout().deprecatedWriter();
+    var stdin_io: stdio.Input = .{};
+    stdin_io.init(.stdin());
+    const stdin = stdin_io.reader();
+
+    var stdout_io: stdio.Output = .{};
+    stdout_io.init(.stdout());
+    defer stdout_io.deinit();
+    const stdout = stdout_io.writer();
 
     while (true) {
-        const line = stdin.readUntilDelimiterOrEofAlloc(allocator, '\n', 16 * 1024 * 1024) catch |err| {
+        const line = stdio.readLineAlloc(stdin, allocator, 16 * 1024 * 1024) catch |err| {
             try mcp_protocol.writeError(stdout, null, -32700, @errorName(err));
+            try stdout_io.flush();
             continue;
         };
         const owned_line = line orelse break;
@@ -26,6 +34,7 @@ pub fn serveStdioWithTrace(allocator: std.mem.Allocator, device: anytype, live_t
         const trimmed = std.mem.trim(u8, owned_line, " \t\r\n");
         if (trimmed.len == 0) continue;
         try dispatchLine(allocator, device, trimmed, stdout, live_trace);
+        try stdout_io.flush();
     }
 }
 
@@ -111,10 +120,10 @@ fn callTool(
     if (std.mem.eql(u8, tool_name, "snapshot")) {
         var snap = try device.snapshot(live_trace);
         defer snap.deinit(device.allocator);
-        var payload = std.ArrayList(u8).empty;
-        defer payload.deinit(allocator);
-        try trace.writeSnapshotJson(payload.writer(allocator), snap);
-        try mcp_protocol.writeToolTextResult(writer, id, payload.items);
+        var payload: std.Io.Writer.Allocating = .init(allocator);
+        defer payload.deinit();
+        try trace.writeSnapshotJson(&payload.writer, snap);
+        try mcp_protocol.writeToolTextResult(writer, id, payload.writer.buffered());
         return;
     }
 
@@ -126,10 +135,10 @@ fn callTool(
             defer tw.allocator.free(path);
             try tw.recordEvent("observe.semanticSnapshot", "{\"status\":\"ok\"}");
         }
-        var payload = std.ArrayList(u8).empty;
-        defer payload.deinit(allocator);
-        try semantic.writeSemanticSnapshotJson(payload.writer(allocator), snap);
-        try mcp_protocol.writeToolTextResult(writer, id, payload.items);
+        var payload: std.Io.Writer.Allocating = .init(allocator);
+        defer payload.deinit();
+        try semantic.writeSemanticSnapshotJson(&payload.writer, snap);
+        try mcp_protocol.writeToolTextResult(writer, id, payload.writer.buffered());
         return;
     }
 
@@ -311,10 +320,10 @@ fn callTool(
         const path = try requiredParamString(arguments, "path");
         var result = try validation.validateFile(allocator, path);
         defer result.deinit(allocator);
-        var payload = std.ArrayList(u8).empty;
-        defer payload.deinit(allocator);
-        try cli_output.writeValidationJson(payload.writer(allocator), path, result);
-        try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+        var payload: std.Io.Writer.Allocating = .init(allocator);
+        defer payload.deinit();
+        try cli_output.writeValidationJson(&payload.writer, path, result);
+        try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimEnd(u8, payload.writer.buffered(), " \t\r\n"));
         return;
     }
 
@@ -382,15 +391,15 @@ fn writeMatchedIndexToolResult(
     id: ?std.json.Value,
     matched: ?usize,
 ) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(allocator);
-    const payload_writer = payload.writer(allocator);
+    var payload: std.Io.Writer.Allocating = .init(allocator);
+    defer payload.deinit();
+    const payload_writer = &payload.writer;
     if (matched) |index| {
         try payload_writer.print("{{\"matchedIndex\":{d}}}", .{index});
     } else {
         try payload_writer.writeAll("{\"matchedIndex\":null}");
     }
-    try mcp_protocol.writeToolTextResult(writer, id, payload.items);
+    try mcp_protocol.writeToolTextResult(writer, id, payload_writer.buffered());
 }
 
 fn parseArgumentsSelector(allocator: std.mem.Allocator, arguments: ?std.json.Value) !selector.Selector {

package/src/mcp_trace.zig

@@ -5,6 +5,7 @@ const cli_explore = @import("cli_explore.zig");
 const mcp_protocol = @import("mcp_protocol.zig");
 const report = @import("report.zig");
 const runner_events = @import("runner_events.zig");
+const stdio = @import("stdio.zig");
 const trace = @import("trace.zig");
 
 pub fn writeEventsToolResult(
@@ -16,30 +17,30 @@ pub fn writeEventsToolResult(
     limit: u64,
 ) !void {
     const tw = live_trace orelse {
-        var no_trace_payload = std.ArrayList(u8).empty;
-        defer no_trace_payload.deinit(allocator);
-        try no_trace_payload.writer(allocator).print("{{\"traceDir\":null,\"afterSeq\":{d},\"nextSeq\":{d},\"latestSeq\":0,\"events\":[]}}", .{ after_seq, after_seq });
-        try mcp_protocol.writeToolTextResult(writer, id, no_trace_payload.items);
+        var no_trace_payload: std.Io.Writer.Allocating = .init(allocator);
+        defer no_trace_payload.deinit();
+        try no_trace_payload.writer.print("{{\"traceDir\":null,\"afterSeq\":{d},\"nextSeq\":{d},\"latestSeq\":0,\"events\":[]}}", .{ after_seq, after_seq });
+        try mcp_protocol.writeToolTextResult(writer, id, no_trace_payload.writer.buffered());
         return;
     };
 
     const events_path = try std.fs.path.join(allocator, &.{ tw.root_dir, "events.jsonl" });
     defer allocator.free(events_path);
-    const content = std.fs.cwd().readFileAlloc(allocator, events_path, 64 * 1024 * 1024) catch |err| switch (err) {
+    const content = stdio.readFileAlloc(allocator, events_path, 64 * 1024 * 1024) catch |err| switch (err) {
         error.FileNotFound => try allocator.dupe(u8, ""),
         else => return err,
     };
     defer allocator.free(content);
 
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(allocator);
-    const payload_writer = payload.writer(allocator);
+    var payload: std.Io.Writer.Allocating = .init(allocator);
+    defer payload.deinit();
+    const payload_writer = &payload.writer;
     try payload_writer.writeAll("{\"traceDir\":");
     try trace.writeJsonString(payload_writer, tw.root_dir);
     try payload_writer.print(",\"afterSeq\":{d},\"nextSeq\":", .{after_seq});
-    var events_json = std.ArrayList(u8).empty;
-    defer events_json.deinit(allocator);
-    const events_writer = events_json.writer(allocator);
+    var events_json: std.Io.Writer.Allocating = .init(allocator);
+    defer events_json.deinit();
+    const events_writer = &events_json.writer;
     var next_seq = after_seq;
     var emitted: u64 = 0;
     var lines = std.mem.splitScalar(u8, content, '\n');
@@ -60,9 +61,9 @@ pub fn writeEventsToolResult(
         emitted += 1;
     }
     try payload_writer.print("{d},\"latestSeq\":{d},\"events\":[", .{ next_seq, tw.event_count });
-    try payload_writer.writeAll(events_json.items);
+    try payload_writer.writeAll(events_writer.buffered());
     try payload_writer.writeAll("]}");
-    try mcp_protocol.writeToolTextResult(writer, id, payload.items);
+    try mcp_protocol.writeToolTextResult(writer, id, payload_writer.buffered());
 }
 
 pub fn writeExportToolResult(
@@ -85,15 +86,15 @@ pub fn writeExportToolResult(
         .omit_screenshots = omit_screenshots,
     });
 
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(allocator);
-    const payload_writer = payload.writer(allocator);
+    var payload: std.Io.Writer.Allocating = .init(allocator);
+    defer payload.deinit();
+    const payload_writer = &payload.writer;
     try payload_writer.writeAll("{\"traceDir\":");
     try trace.writeJsonString(payload_writer, tw.root_dir);
     try payload_writer.writeAll(",\"out\":");
     try trace.writeJsonString(payload_writer, out_path);
     try payload_writer.print(",\"redacted\":{},\"omitScreenshots\":{}}}", .{ redact, omit_screenshots });
-    try mcp_protocol.writeToolTextResult(writer, id, payload.items);
+    try mcp_protocol.writeToolTextResult(writer, id, payload_writer.buffered());
 }
 
 pub fn writeExplainToolResult(
@@ -108,10 +109,10 @@ pub fn writeExplainToolResult(
     };
 
     try tw.flushManifest();
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(allocator);
-    try report.writeTraceExplanationJson(allocator, tw.root_dir, payload.writer(allocator));
-    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+    var payload: std.Io.Writer.Allocating = .init(allocator);
+    defer payload.deinit();
+    try report.writeTraceExplanationJson(allocator, tw.root_dir, &payload.writer);
+    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimEnd(u8, payload.writer.buffered(), " \t\r\n"));
     try tw.recordEvent("trace.explain", "{\"status\":\"ok\"}");
 }
 
@@ -152,10 +153,10 @@ pub fn writeDiscoverToolResult(
         discovered.summary.validated,
     );
 
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(allocator);
-    try cli_discover.writeJson(payload.writer(allocator), discovered.summary, discovered.validation);
-    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+    var payload: std.Io.Writer.Allocating = .init(allocator);
+    defer payload.deinit();
+    try cli_discover.writeJson(&payload.writer, discovered.summary, discovered.validation);
+    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimEnd(u8, payload.writer.buffered(), " \t\r\n"));
 }
 
 pub fn writeExploreToolResult(
@@ -198,8 +199,8 @@ pub fn writeExploreToolResult(
         explored.discovered.summary.validated,
     );
 
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(allocator);
-    try cli_explore.writeJson(payload.writer(allocator), explored.summary, explored.discovered.summary, explored.discovered.validation);
-    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimRight(u8, payload.items, " \t\r\n"));
+    var payload: std.Io.Writer.Allocating = .init(allocator);
+    defer payload.deinit();
+    try cli_explore.writeJson(&payload.writer, explored.summary, explored.discovered.summary, explored.discovered.validation);
+    try mcp_protocol.writeToolTextResult(writer, id, std.mem.trimEnd(u8, payload.writer.buffered(), " \t\r\n"));
 }

package/src/report.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const cli_output = @import("cli_output.zig");
 const report_html = @import("report_html.zig");
 const report_values = @import("report_values.zig");
+const stdio = @import("stdio.zig");
 const trace = @import("trace.zig");
 const trace_summary = @import("trace_summary.zig");
 
@@ -13,8 +14,8 @@ pub fn writeHtmlReport(
     const results_path = try std.fs.path.join(allocator, &.{ input_path, "results.jsonl" });
     defer allocator.free(results_path);
 
-    if (std.fs.cwd().openFile(results_path, .{})) |file| {
-        file.close();
+    if (std.Io.Dir.cwd().openFile(stdio.io(), results_path, .{})) |file| {
+        file.close(stdio.io());
         return try writeBenchmarkReport(allocator, input_path, results_path, out_path);
     } else |err| switch (err) {
         error.FileNotFound => return try writeTraceReport(allocator, input_path, out_path),
@@ -30,8 +31,8 @@ pub fn writeJUnitReport(
     const results_path = try std.fs.path.join(allocator, &.{ input_path, "results.jsonl" });
     defer allocator.free(results_path);
 
-    if (std.fs.cwd().openFile(results_path, .{})) |file| {
-        file.close();
+    if (std.Io.Dir.cwd().openFile(stdio.io(), results_path, .{})) |file| {
+        file.close(stdio.io());
         return try writeBenchmarkJUnitReport(allocator, input_path, results_path, out_path);
     } else |err| switch (err) {
         error.FileNotFound => return try writeTraceJUnitReport(allocator, input_path, out_path),
@@ -183,11 +184,11 @@ fn writeBenchmarkReport(
     results_path: []const u8,
     out_path: []const u8,
 ) !void {
-    const content = try std.fs.cwd().readFileAlloc(allocator, results_path, 64 * 1024 * 1024);
+    const content = try stdio.readFileAlloc(allocator, results_path, 64 * 1024 * 1024);
     defer allocator.free(content);
 
-    var rows_html = std.ArrayList(u8).empty;
-    defer rows_html.deinit(allocator);
+    var rows_html: std.Io.Writer.Allocating = .init(allocator);
+    defer rows_html.deinit();
     var durations = std.ArrayList(i64).empty;
     defer durations.deinit(allocator);
 
@@ -223,7 +224,7 @@ fn writeBenchmarkReport(
             failed += 1;
         }
 
-        const writer = rows_html.writer(allocator);
+        const writer = &rows_html.writer;
         try writer.writeAll("<tr><td>");
         try writer.print("{d}", .{run});
         try writer.writeAll("</td><td>");
@@ -257,9 +258,9 @@ fn writeBenchmarkReport(
     const mean = report_values.meanDuration(durations.items);
     const p95 = report_values.percentile95(durations.items);
 
-    var html = std.ArrayList(u8).empty;
-    defer html.deinit(allocator);
-    const writer = html.writer(allocator);
+    var html: std.Io.Writer.Allocating = .init(allocator);
+    defer html.deinit();
+    const writer = &html.writer;
     try report_html.writeStart(writer, "ZMR Report");
     try writer.writeAll("<h1>ZMR Report</h1>\n");
     try writer.writeAll("<p class=\"muted\">Source: ");
@@ -272,11 +273,11 @@ fn writeBenchmarkReport(
     try writer.print("<dt>P95</dt><dd>{d}ms</dd>", .{p95});
     try writer.writeAll("</dl></section>\n");
     try writer.writeAll("<section><h2>Runs</h2><table><thead><tr><th>Run</th><th>Tool</th><th>Status</th><th>Duration</th><th>Trace Status</th><th>Failure</th><th>Artifacts</th></tr></thead><tbody>\n");
-    try writer.writeAll(rows_html.items);
+    try writer.writeAll(rows_html.writer.buffered());
     try writer.writeAll("</tbody></table></section>\n");
     try writer.writeAll("<p class=\"warning\">Screenshots and raw UI XML may contain app data. Sanitize trace bundles before public sharing.</p>\n");
     try report_html.writeEnd(writer);
-    try report_html.writeFile(out_path, html.items);
+    try report_html.writeFile(out_path, html.writer.buffered());
 }
 
 fn writeBenchmarkJUnitReport(
@@ -285,11 +286,11 @@ fn writeBenchmarkJUnitReport(
     results_path: []const u8,
     out_path: []const u8,
 ) !void {
-    const content = try std.fs.cwd().readFileAlloc(allocator, results_path, 64 * 1024 * 1024);
+    const content = try stdio.readFileAlloc(allocator, results_path, 64 * 1024 * 1024);
     defer allocator.free(content);
 
-    var cases_xml = std.ArrayList(u8).empty;
-    defer cases_xml.deinit(allocator);
+    var cases_xml: std.Io.Writer.Allocating = .init(allocator);
+    defer cases_xml.deinit();
 
     var total: usize = 0;
     var failed: usize = 0;
@@ -319,7 +320,7 @@ fn writeBenchmarkJUnitReport(
         if (!row_passed) failed += 1;
         if (duration_ms > 0) total_duration_ms += duration_ms;
 
-        const writer = cases_xml.writer(allocator);
+        const writer = &cases_xml.writer;
         try writer.writeAll("  <testcase classname=\"");
         try report_html.escape(writer, tool);
         try writer.writeAll("\" name=\"run ");
@@ -343,9 +344,9 @@ fn writeBenchmarkJUnitReport(
         try writer.writeAll("</testcase>\n");
     }
 
-    var xml = std.ArrayList(u8).empty;
-    defer xml.deinit(allocator);
-    const writer = xml.writer(allocator);
+    var xml: std.Io.Writer.Allocating = .init(allocator);
+    defer xml.deinit();
+    const writer = &xml.writer;
     try writeJUnitHeader(writer);
     try writer.writeAll("<testsuite name=\"ZMR Benchmark\" tests=\"");
     try writer.print("{d}", .{total});
@@ -357,9 +358,9 @@ fn writeBenchmarkJUnitReport(
     try writer.writeAll("  <properties>\n");
     try writeJUnitProperty(writer, "source", input_path);
     try writer.writeAll("  </properties>\n");
-    try writer.writeAll(cases_xml.items);
+    try writer.writeAll(cases_xml.writer.buffered());
     try writer.writeAll("</testsuite>\n");
-    try report_html.writeFile(out_path, xml.items);
+    try report_html.writeFile(out_path, xml.writer.buffered());
 }
 
 fn writeTraceReport(
@@ -369,11 +370,11 @@ fn writeTraceReport(
 ) !void {
     const events_path = try std.fs.path.join(allocator, &.{ input_path, "events.jsonl" });
     defer allocator.free(events_path);
-    const content = try std.fs.cwd().readFileAlloc(allocator, events_path, 64 * 1024 * 1024);
+    const content = try stdio.readFileAlloc(allocator, events_path, 64 * 1024 * 1024);
     defer allocator.free(content);
 
-    var events_html = std.ArrayList(u8).empty;
-    defer events_html.deinit(allocator);
+    var events_html: std.Io.Writer.Allocating = .init(allocator);
+    defer events_html.deinit();
     var total: usize = 0;
     var terminal_status: ?[]u8 = null;
     defer if (terminal_status) |value| allocator.free(value);
@@ -407,7 +408,7 @@ fn writeTraceReport(
         }
 
         total += 1;
-        const writer = events_html.writer(allocator);
+        const writer = &events_html.writer;
         try writer.writeAll("<tr><td>");
         try writer.print("{d}", .{seq});
         try writer.writeAll("</td><td>");
@@ -417,9 +418,9 @@ fn writeTraceReport(
         try writer.writeAll("</code></td></tr>\n");
     }
 
-    var html = std.ArrayList(u8).empty;
-    defer html.deinit(allocator);
-    const writer = html.writer(allocator);
+    var html: std.Io.Writer.Allocating = .init(allocator);
+    defer html.deinit();
+    const writer = &html.writer;
     try report_html.writeStart(writer, "ZMR Trace Report");
     try writer.writeAll("<h1>ZMR Trace Report</h1>\n");
     try writer.writeAll("<p class=\"muted\">Source: ");
@@ -433,16 +434,18 @@ fn writeTraceReport(
     try report_html.escape(writer, terminal_error orelse "");
     try writer.writeAll("</dd></dl></section>\n");
     try writer.writeAll("<section><h2>Timeline</h2><table><thead><tr><th>Seq</th><th>Kind</th><th>Event</th></tr></thead><tbody>\n");
-    try writer.writeAll(events_html.items);
+    try writer.writeAll(events_html.writer.buffered());
     try writer.writeAll("</tbody></table></section>\n");
     try writer.writeAll("<p>");
     try report_html.writeArtifactLink(allocator, writer, events_path, "events.jsonl");
     try writer.writeAll("</p>\n");
     try writer.writeAll("<p class=\"warning\">Screenshots and raw UI XML may contain app data. Sanitize trace bundles before public sharing.</p>\n");
     try report_html.writeEnd(writer);
-    try report_html.writeFile(out_path, html.items);
+    try report_html.writeFile(out_path, html.writer.buffered());
 
-    const relative_report_path = std.fs.path.relative(allocator, input_path, out_path) catch try allocator.dupe(u8, out_path);
+    const cwd = std.process.currentPathAlloc(stdio.io(), allocator) catch try allocator.dupeZ(u8, ".");
+    defer allocator.free(cwd);
+    const relative_report_path = std.fs.path.relative(allocator, cwd, null, input_path, out_path) catch try allocator.dupe(u8, out_path);
     defer allocator.free(relative_report_path);
     try trace.attachReportPath(allocator, input_path, relative_report_path);
 }
@@ -456,9 +459,9 @@ fn writeTraceJUnitReport(
     defer summary.deinit(allocator);
 
     const failed = !isPassedStatus(summary.status);
-    var xml = std.ArrayList(u8).empty;
-    defer xml.deinit(allocator);
-    const writer = xml.writer(allocator);
+    var xml: std.Io.Writer.Allocating = .init(allocator);
+    defer xml.deinit();
+    const writer = &xml.writer;
 
     try writeJUnitHeader(writer);
     try writer.writeAll("<testsuite name=\"ZMR\" tests=\"1\" failures=\"");
@@ -499,7 +502,7 @@ fn writeTraceJUnitReport(
     }
     try writer.writeAll("</testcase>\n");
     try writer.writeAll("</testsuite>\n");
-    try report_html.writeFile(out_path, xml.items);
+    try report_html.writeFile(out_path, xml.writer.buffered());
 }
 
 fn isPassedStatus(status: []const u8) bool {

package/src/report_html.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 
 pub fn writeStart(writer: anytype, title: []const u8) !void {
     try writer.writeAll("<!doctype html><html><head><meta charset=\"utf-8\"><title>");
@@ -28,9 +29,9 @@ pub fn writeEnd(writer: anytype) !void {
 }
 
 pub fn writeFile(path: []const u8, bytes: []const u8) !void {
-    var file = try std.fs.cwd().createFile(path, .{ .truncate = true });
-    defer file.close();
-    try file.writeAll(bytes);
+    var file = try std.Io.Dir.cwd().createFile(stdio.io(), path, .{ .truncate = true });
+    defer file.close(stdio.io());
+    try std.Io.File.writeStreamingAll(file, stdio.io(), bytes);
 }
 
 pub fn writeArtifactLink(
@@ -39,7 +40,7 @@ pub fn writeArtifactLink(
     path: []const u8,
     label: []const u8,
 ) !void {
-    const href = std.fs.cwd().realpathAlloc(allocator, path) catch try allocator.dupe(u8, path);
+    const href = std.Io.Dir.cwd().realPathFileAlloc(stdio.io(), path, allocator) catch try allocator.dupeZ(u8, path);
     defer allocator.free(href);
 
     try writer.writeAll("<a href=\"file://");

package/src/runner.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const runner_actions = @import("runner_actions.zig");
 const runner_config = @import("runner_config.zig");
 const runner_events = @import("runner_events.zig");
@@ -294,7 +295,7 @@ fn isVisibleNow(
 }
 
 fn sleepMs(ms: u64) !void {
-    std.Thread.sleep(ms * std.time.ns_per_ms);
+    stdio.sleepNs(ms * std.time.ns_per_ms);
 }
 
 fn settleDevice(device: anytype, options: RunOptions) !void {

package/src/runner_actions.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const runner_config = @import("runner_config.zig");
 const runner_events = @import("runner_events.zig");
 const runner_native = @import("runner_native.zig");
@@ -16,7 +17,7 @@ pub fn tapSelector(
 ) !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));
+    const deadline = stdio.nowMs() + @as(i64, @intCast(options.action_timeout_ms));
     var attempts: u32 = 0;
     while (true) {
         attempts += 1;
@@ -25,23 +26,24 @@ pub fn tapSelector(
         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\":", .{
+                var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+                defer payload.deinit();
+                const out = &payload.writer;
+                try out.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 trace.writeSelectorJson(out, wanted);
+                try out.writeAll("}");
+                try tw.recordEvent("ui.tap", out.buffered());
             }
             try settleDevice(device, options);
             return;
         }
-        if (std.time.milliTimestamp() >= deadline) {
+        if (stdio.nowMs() >= deadline) {
             if (writer) |tw| {
                 try runner_events.recordSelectorMiss(tw, "ui.tap.notFound", wanted, snap);
             }
@@ -62,14 +64,15 @@ pub fn typeTextSelector(
     try tapSelector(device, wanted, writer, options);
     try device.typeText(text);
     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).writeAll(",\"text\":");
-        try trace.writeJsonString(payload.writer(tw.allocator), text);
-        try payload.writer(tw.allocator).writeAll("}");
-        try tw.recordEvent("ui.type", 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.writeAll(",\"text\":");
+        try trace.writeJsonString(out, text);
+        try out.writeAll("}");
+        try tw.recordEvent("ui.type", out.buffered());
     }
     try settleDevice(device, options);
 }
@@ -115,5 +118,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/runner_diagnostics.zig

@@ -27,10 +27,10 @@ pub fn recordWithOptions(
     snap: types.ObservationSnapshot,
     options: DiagnosticOptions,
 ) !void {
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    try writeSelectorDiagnosticJsonWithOptions(payload.writer(tw.allocator), status, strategy, selectors, snap, options);
-    try tw.recordEvent(kind, payload.items);
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    try writeSelectorDiagnosticJsonWithOptions(&payload.writer, status, strategy, selectors, snap, options);
+    try tw.recordEvent(kind, payload.writer.buffered());
 }
 
 pub fn writeSelectorDiagnosticJson(