zeno-mobile-runner 0.2.0 → 0.2.2

package/src/ios.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const command = @import("command.zig");
 const ios_devices = @import("ios_devices.zig");
 const ios_lifecycle = @import("ios_lifecycle.zig");
@@ -128,9 +129,13 @@ pub const IosDevice = struct {
         const result = try self.runSimctl(&.{ "openurl", self.target(), url }, default_max_output);
         defer result.deinit(self.allocator);
         try result.ensureSuccess();
-        if (urlMayNeedOpenConfirmation(url)) {
-            self.acceptOpenURLConfirmationBestEffort();
-        }
+        // Opening a URL on the simulator can raise a SpringBoard "Open in <App>?"
+        // confirmation for universal links (http/https) and, just as often, for
+        // custom schemes — the common Expo dev-client case
+        // (exp+scheme://expo-development-client/...). Attempt a best-effort accept
+        // whenever a shim is configured; the shim probes briefly and returns fast
+        // when no dialog is present, so this stays cheap on the no-prompt path.
+        self.acceptOpenURLConfirmationBestEffort();
     }
 
     pub fn tap(self: *IosDevice, x: i32, y: i32) !void {
@@ -186,11 +191,11 @@ pub const IosDevice = struct {
                 .duration_ms = @as(u32, @intCast(@min(timeout_ms, std.math.maxInt(u32)))),
             });
         }
-        std.Thread.sleep(timeout_ms * std.time.ns_per_ms);
+        stdio.sleepNs(timeout_ms * std.time.ns_per_ms);
     }
 
     pub fn snapshot(self: *IosDevice, writer: ?*trace.TraceWriter) !types.ObservationSnapshot {
-        const id = if (writer) |tw| try tw.nextSnapshotId() else try std.fmt.allocPrint(self.allocator, "snapshot-{d}", .{std.time.milliTimestamp()});
+        const id = if (writer) |tw| try tw.nextSnapshotId() else try std.fmt.allocPrint(self.allocator, "snapshot-{d}", .{stdio.nowMs()});
         errdefer self.allocator.free(id);
 
         var screenshot_artifact: ?[]const u8 = null;
@@ -235,7 +240,7 @@ pub const IosDevice = struct {
 
         return .{
             .id = id,
-            .timestamp_ms = std.time.milliTimestamp(),
+            .timestamp_ms = stdio.nowMs(),
             .viewport = viewport,
             .active_package = active_package,
             .active_activity = null,
@@ -253,21 +258,21 @@ pub const IosDevice = struct {
             defer self.allocator.free(response);
             return try ios_shim.parseScreenshotPng(self.allocator, response);
         }
-        const path = try std.fmt.allocPrint(self.allocator, "/tmp/zmr-ios-screenshot-{d}.png", .{std.time.nanoTimestamp()});
+        const path = try std.fmt.allocPrint(self.allocator, "/tmp/zmr-ios-screenshot-{d}.png", .{stdio.nowNs()});
         defer self.allocator.free(path);
-        defer std.fs.cwd().deleteFile(path) catch {};
+        defer std.Io.Dir.cwd().deleteFile(stdio.io(), path) catch {};
 
         const result = try self.runSimctl(&.{ "io", self.target(), "screenshot", path }, default_max_output);
         defer result.deinit(self.allocator);
         try result.ensureSuccess();
-        return try std.fs.cwd().readFileAlloc(self.allocator, path, default_max_output);
+        return try stdio.readFileAlloc(self.allocator, path, default_max_output);
     }
 
     fn logDelta(self: *IosDevice) !?[]const u8 {
         if (self.target_kind == .physical) return null;
         const result = try self.runSimctl(&.{ "spawn", self.target(), "log", "show", "--style", "compact", "--last", "30s" }, 1024 * 1024);
         defer result.deinit(self.allocator);
-        if (result.term != .Exited or result.term.Exited != 0) return null;
+        if (result.term != .exited or result.term.exited != 0) return null;
         return try self.allocator.dupe(u8, result.stdout);
     }
 
@@ -278,15 +283,15 @@ pub const IosDevice = struct {
     }
 
     fn recordSnapshotSemanticFailure(self: *IosDevice, writer: *trace.TraceWriter, screenshot_artifact: []const u8, err: anyerror) !void {
-        var payload = std.ArrayList(u8).empty;
-        defer payload.deinit(writer.allocator);
-        const out = payload.writer(writer.allocator);
+        var payload: std.Io.Writer.Allocating = .init(writer.allocator);
+        defer payload.deinit();
+        const out = &payload.writer;
         try out.writeAll("{\"status\":\"failed\",\"artifactStatus\":\"captured\",\"semanticStatus\":\"failed\",\"error\":");
         try trace.writeJsonString(out, @errorName(err));
         try out.writeAll(",\"screenshotArtifact\":");
         try trace.writeJsonString(out, screenshot_artifact);
         try out.writeAll(",\"source\":\"ios-xctest-shim\"}");
-        try writer.recordEvent("observe.snapshot.semanticExtraction", payload.items);
+        try writer.recordEvent("observe.snapshot.semanticExtraction", out.buffered());
         _ = self;
     }
 
@@ -336,19 +341,19 @@ pub const IosDevice = struct {
     fn runShimWithTimeout(self: *IosDevice, shim_command: ios_shim.Command, timeout_ms: u64) ![]u8 {
         const path = self.shim_path orelse return error.IosXCTestShimRequired;
 
-        var input = std.ArrayList(u8).empty;
-        defer input.deinit(self.allocator);
-        try ios_shim.writeCommandJson(input.writer(self.allocator), shim_command);
+        var input: std.Io.Writer.Allocating = .init(self.allocator);
+        defer input.deinit();
+        try ios_shim.writeCommandJson(&input.writer, shim_command);
 
         var attempt: usize = 0;
         while (attempt < shim_command_attempts) {
             attempt += 1;
-            const result = try command.runWithInputTimeout(self.allocator, &.{path}, input.items, 4 * 1024 * 1024, timeout_ms);
+            const result = try command.runWithInputTimeout(self.allocator, &.{path}, input.writer.buffered(), 4 * 1024 * 1024, timeout_ms);
             defer result.deinit(self.allocator);
 
             result.ensureSuccess() catch |err| {
                 if (attempt < shim_command_attempts and err == error.CommandFailed and isTransientShimBootstrapFailure(result)) {
-                    std.Thread.sleep(shim_bootstrap_retry_delay_ms * std.time.ns_per_ms);
+                    stdio.sleepNs(shim_bootstrap_retry_delay_ms * std.time.ns_per_ms);
                     continue;
                 }
                 return err;
@@ -387,7 +392,7 @@ pub const IosDevice = struct {
 fn isTransientShimBootstrapFailure(result: command.ExecResult) bool {
     if (result.timed_out) return false;
     switch (result.term) {
-        .Exited => |code| if (code == 0) return false,
+        .exited => |code| if (code == 0) return false,
         else => return false,
     }
     return std.mem.indexOf(u8, result.stderr, "iOS shim server exited before it became ready") != null or
@@ -396,7 +401,7 @@ fn isTransientShimBootstrapFailure(result: command.ExecResult) bool {
 }
 
 fn shimTimeoutMs() u64 {
-    return parseShimTimeoutMs(std.posix.getenv(shim_timeout_env));
+    return parseShimTimeoutMs(stdio.getenv(shim_timeout_env));
 }
 
 fn parseShimTimeoutMs(raw: ?[]const u8) u64 {
@@ -406,14 +411,6 @@ fn parseShimTimeoutMs(raw: ?[]const u8) u64 {
     return parsed;
 }
 
-fn urlMayNeedOpenConfirmation(url: []const u8) bool {
-    return startsWithIgnoreCase(url, "http://") or startsWithIgnoreCase(url, "https://");
-}
-
-fn startsWithIgnoreCase(value: []const u8, prefix: []const u8) bool {
-    return value.len >= prefix.len and std.ascii.eqlIgnoreCase(value[0..prefix.len], prefix);
-}
-
 pub fn listDevices(allocator: std.mem.Allocator, xcrun_path: []const u8) ![]types.DeviceInfo {
     return try ios_devices.listSimulators(allocator, xcrun_path);
 }

package/src/ios_devices.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const command = @import("command.zig");
 const types = @import("types.zig");
 
@@ -39,7 +40,7 @@ pub fn runSimctlCommand(
         }
         result.deinit(allocator);
         attempt += 1;
-        std.Thread.sleep(simctl_retry_delay_ms * std.time.ns_per_ms);
+        stdio.sleepNs(simctl_retry_delay_ms * std.time.ns_per_ms);
     }
 }
 
@@ -62,9 +63,9 @@ pub fn runDevicectlJsonCommand(
     xcrun_path: []const u8,
     extra: []const []const u8,
 ) ![]u8 {
-    const path = try std.fmt.allocPrint(allocator, "/tmp/zmr-devicectl-{d}.json", .{std.time.nanoTimestamp()});
+    const path = try std.fmt.allocPrint(allocator, "/tmp/zmr-devicectl-{d}.json", .{stdio.nowNs()});
     defer allocator.free(path);
-    defer std.fs.cwd().deleteFile(path) catch {};
+    defer std.Io.Dir.deleteFileAbsolute(stdio.io(), path) catch {};
 
     var argv = std.ArrayList([]const u8).empty;
     defer argv.deinit(allocator);
@@ -76,7 +77,7 @@ pub fn runDevicectlJsonCommand(
     const result = try command.run(allocator, argv.items, default_max_output);
     defer result.deinit(allocator);
     try result.ensureSuccess();
-    return try std.fs.cwd().readFileAlloc(allocator, path, default_max_output);
+    return try std.Io.Dir.cwd().readFileAlloc(stdio.io(), path, allocator, .limited(default_max_output));
 }
 
 pub fn parseSimulatorsJson(allocator: std.mem.Allocator, content: []const u8) ![]types.DeviceInfo {
@@ -158,7 +159,7 @@ pub fn findPidForBundleId(allocator: std.mem.Allocator, content: []const u8, app
 fn isRetriableSimctlFailure(result: command.ExecResult) bool {
     if (result.timed_out) return false;
     switch (result.term) {
-        .Exited => |code| if (code == 0) return false,
+        .exited => |code| if (code == 0) return false,
         else => return false,
     }
     return std.mem.indexOf(u8, result.stderr, "CoreSimulatorService connection became invalid") != null or

package/src/ios_lifecycle.zig

@@ -65,7 +65,7 @@ pub fn uninstallPhysicalBestEffort(
 
 pub fn isMissingInstalledApp(result: command.ExecResult) bool {
     switch (result.term) {
-        .Exited => |code| if (code == 0) return false,
+        .exited => |code| if (code == 0) return false,
         else => return false,
     }
     return std.mem.indexOf(u8, result.stderr, "No installed application with bundle identifier") != null;
@@ -73,7 +73,7 @@ pub fn isMissingInstalledApp(result: command.ExecResult) bool {
 
 pub fn isAppNotRunning(result: command.ExecResult) bool {
     switch (result.term) {
-        .Exited => |code| if (code == 0) return false,
+        .exited => |code| if (code == 0) return false,
         else => return false,
     }
     return std.mem.indexOf(u8, result.stderr, "found nothing to terminate") != null;
@@ -89,7 +89,7 @@ test "simctl terminate missing running app is best-effort" {
     try std.testing.expect(isAppNotRunning(.{
         .stdout = stdout,
         .stderr = stderr,
-        .term = .{ .Exited = 3 },
+        .term = .{ .exited = 3 },
     }));
 }
 
@@ -103,6 +103,6 @@ test "simctl terminate success is not classified as already stopped" {
     try std.testing.expect(!isAppNotRunning(.{
         .stdout = stdout,
         .stderr = stderr,
-        .term = .{ .Exited = 0 },
+        .term = .{ .exited = 0 },
     }));
 }

package/src/json_rpc.zig

@@ -1,9 +1,12 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const errors = @import("errors.zig");
 const methods = @import("json_rpc_methods.zig");
 const protocol = @import("json_rpc_protocol.zig");
 const trace = @import("trace.zig");
 
+const net = std.Io.net;
+
 pub const ServeOptions = struct {
     transport: []const u8 = "stdio",
 };
@@ -13,12 +16,19 @@ pub fn serveStdio(allocator: std.mem.Allocator, device: anytype) !void {
 }
 
 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 protocol.writeError(stdout, null, -32700, @errorName(err));
+            try stdout_io.flush();
             continue;
         };
         const owned_line = line orelse break;
@@ -26,6 +36,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 dispatchLineWithTrace(allocator, device, trimmed, stdout, live_trace);
+        try stdout_io.flush();
     }
 }
 
@@ -34,45 +45,33 @@ pub fn serveTcp(allocator: std.mem.Allocator, device: anytype, port: u16) !void
 }
 
 pub fn serveTcpWithTrace(allocator: std.mem.Allocator, device: anytype, port: u16, live_trace: ?*trace.TraceWriter) !void {
-    const address = try std.net.Address.parseIp("127.0.0.1", port);
-    var server = try address.listen(.{ .reuse_address = true });
-    defer server.deinit();
+    const address = try net.IpAddress.parse("127.0.0.1", port);
+    var server = try address.listen(stdio.io(), .{ .reuse_address = true });
+    defer server.deinit(stdio.io());
 
     while (true) {
-        var connection = try server.accept();
-        defer connection.stream.close();
-        try serveTcpConnection(allocator, device, connection.stream, live_trace);
+        const connection = try server.accept(stdio.io());
+        defer connection.close(stdio.io());
+        try serveTcpConnection(allocator, device, connection, live_trace);
     }
 }
 
-fn serveTcpConnection(allocator: std.mem.Allocator, device: anytype, stream: std.net.Stream, live_trace: ?*trace.TraceWriter) !void {
+fn serveTcpConnection(allocator: std.mem.Allocator, device: anytype, stream: net.Stream, live_trace: ?*trace.TraceWriter) !void {
     var write_buffer: [8192]u8 = undefined;
-    var stream_writer = stream.writer(&write_buffer);
+    var stream_writer = stream.writer(stdio.io(), &write_buffer);
     const writer = &stream_writer.interface;
 
-    var line = std.ArrayList(u8).empty;
-    defer line.deinit(allocator);
-
     var read_buffer: [4096]u8 = undefined;
+    var stream_reader = stream.reader(stdio.io(), &read_buffer);
     while (true) {
-        const n = try stream.read(&read_buffer);
-        if (n == 0) break;
-        for (read_buffer[0..n]) |ch| {
-            if (ch == '\n') {
-                const trimmed = std.mem.trim(u8, line.items, " \t\r\n");
-                if (trimmed.len != 0) {
-                    try dispatchLineWithTrace(allocator, device, trimmed, writer, live_trace);
-                    try writer.flush();
-                }
-                line.clearRetainingCapacity();
-            } else {
-                try line.append(allocator, ch);
-            }
-        }
-    }
-
-    if (line.items.len != 0) {
-        const trimmed = std.mem.trim(u8, line.items, " \t\r\n");
+        const line = stdio.readLineAlloc(&stream_reader.interface, allocator, 16 * 1024 * 1024) catch |err| {
+            try protocol.writeError(writer, null, -32700, @errorName(err));
+            try writer.flush();
+            continue;
+        };
+        const owned_line = line orelse break;
+        defer allocator.free(owned_line);
+        const trimmed = std.mem.trim(u8, owned_line, " \t\r\n");
         if (trimmed.len != 0) {
             try dispatchLineWithTrace(allocator, device, trimmed, writer, live_trace);
             try writer.flush();
@@ -124,21 +123,21 @@ pub fn dispatchLineWithTrace(
 }
 
 fn recordRpcEvent(tw: *trace.TraceWriter, kind: []const u8, method: []const u8, id: ?std.json.Value) !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("{\"method\":");
     try trace.writeJsonString(writer, method);
     try writer.writeAll(",\"id\":");
     try protocol.writeId(writer, id);
     try writer.writeAll("}");
-    try tw.recordEvent(kind, payload.items);
+    try tw.recordEvent(kind, writer.buffered());
 }
 
 fn recordRpcErrorEvent(tw: *trace.TraceWriter, method: []const u8, id: ?std.json.Value, 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("{\"method\":");
     try trace.writeJsonString(writer, method);
     try writer.writeAll(",\"id\":");
@@ -146,5 +145,5 @@ fn recordRpcErrorEvent(tw: *trace.TraceWriter, method: []const u8, id: ?std.json
     try writer.writeAll(",\"error\":");
     try trace.writeJsonString(writer, @errorName(err));
     try writer.writeAll("}");
-    try tw.recordEvent("rpc.error", payload.items);
+    try tw.recordEvent("rpc.error", writer.buffered());
 }

package/src/json_rpc_methods.zig

@@ -107,13 +107,13 @@ fn dispatchAppMethod(
 }
 
 fn recordAppOpenLink(tw: *trace.TraceWriter, url: []const u8) !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\":\"ok\",\"url\":");
     try trace.writeJsonString(writer, url);
     try writer.writeAll("}");
-    try tw.recordEvent("app.openLink", payload.items);
+    try tw.recordEvent("app.openLink", writer.buffered());
 }
 
 fn dispatchObserveMethod(
@@ -312,10 +312,10 @@ fn dispatchScenarioMethod(
         const path = try params_parser.requiredString(params, "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 protocol.writeResultRaw(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 protocol.writeResultRaw(writer, id, std.mem.trimEnd(u8, payload.writer.buffered(), " \t\r\n"));
         return true;
     }
     return false;

package/src/json_rpc_observation.zig

@@ -20,12 +20,13 @@ pub fn writeResult(writer: anytype, id: ?std.json.Value, snap: types.Observation
 pub fn recordArtifact(tw: *trace.TraceWriter, kind: []const u8, snap: types.ObservationSnapshot) !void {
     const path = try tw.writeSnapshot(snap);
     defer tw.allocator.free(path);
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(tw.allocator);
-    try payload.writer(tw.allocator).writeAll("{\"path\":");
-    try trace.writeJsonString(payload.writer(tw.allocator), path);
-    try payload.writer(tw.allocator).writeAll(",\"snapshotId\":");
-    try trace.writeJsonString(payload.writer(tw.allocator), snap.id);
-    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 out = &payload.writer;
+    try out.writeAll("{\"path\":");
+    try trace.writeJsonString(out, path);
+    try out.writeAll(",\"snapshotId\":");
+    try trace.writeJsonString(out, snap.id);
+    try out.writeAll("}");
+    try tw.recordEvent(kind, out.buffered());
 }

package/src/json_rpc_params.zig

@@ -56,5 +56,5 @@ pub fn optionalDirection(params: ?std.json.Value, key: []const u8, default_value
     if (value != .string) return error.ParamMustBeString;
     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;
 }

package/src/json_rpc_trace.zig

@@ -4,6 +4,7 @@ const cli_explore = @import("cli_explore.zig");
 const protocol = @import("json_rpc_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 writeEventsResult(
@@ -23,7 +24,7 @@ pub fn writeEventsResult(
 
     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,
     };
@@ -35,9 +36,9 @@ pub fn writeEventsResult(
     try trace.writeJsonString(writer, tw.root_dir);
     try writer.print(",\"afterSeq\":{d},\"nextSeq\":", .{after_seq});
 
-    var events_json = std.ArrayList(u8).empty;
-    defer events_json.deinit(allocator);
-    var 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;
 
@@ -60,20 +61,20 @@ pub fn writeEventsResult(
     }
 
     try writer.print("{d},\"latestSeq\":{d},\"events\":[", .{ next_seq, tw.event_count });
-    try writer.writeAll(events_json.items);
+    try writer.writeAll(events_writer.buffered());
     try writer.writeAll("]}}\n");
 }
 
 pub fn recordSimplePayload(tw: *trace.TraceWriter, kind: []const u8, key: []const u8, value: []const u8) !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("{");
     try trace.writeJsonString(writer, key);
     try writer.writeAll(":");
     try trace.writeJsonString(writer, value);
     try writer.writeAll("}");
-    try tw.recordEvent(kind, payload.items);
+    try tw.recordEvent(kind, writer.buffered());
 }
 
 pub fn writeDiscoverResult(
@@ -113,10 +114,10 @@ pub fn writeDiscoverResult(
         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 protocol.writeResultRaw(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 protocol.writeResultRaw(writer, id, std.mem.trimEnd(u8, payload.writer.buffered(), " \t\r\n"));
 }
 
 pub fn writeExploreResult(
@@ -159,10 +160,10 @@ pub fn writeExploreResult(
         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 protocol.writeResultRaw(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 protocol.writeResultRaw(writer, id, std.mem.trimEnd(u8, payload.writer.buffered(), " \t\r\n"));
 }
 
 pub fn writeExplainResult(
@@ -177,9 +178,9 @@ pub fn writeExplainResult(
     };
 
     try tw.flushManifest();
-    var payload = std.ArrayList(u8).empty;
-    defer payload.deinit(allocator);
-    try report.writeTraceExplanationJson(allocator, tw.root_dir, payload.writer(allocator));
-    try protocol.writeResultRaw(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 protocol.writeResultRaw(writer, id, std.mem.trimEnd(u8, payload.writer.buffered(), " \t\r\n"));
     try tw.recordEvent("trace.explain", "{\"status\":\"ok\"}");
 }

package/src/main.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const stdio = @import("stdio.zig");
 const cli_devices = @import("cli_devices.zig");
 const cli_discover = @import("cli_discover.zig");
 const cli_doctor = @import("cli_doctor.zig");
@@ -14,14 +15,17 @@ const cli_trace = @import("cli_trace.zig");
 const cli_validate = @import("cli_validate.zig");
 const errors = @import("errors.zig");
 
-pub fn main() void {
-    mainInner() catch |err| {
+pub fn main(init: std.process.Init.Minimal) void {
+    mainInner(init) catch |err| {
+        // stdout's consumer went away (e.g. `zmr ... | head`); exit quietly
+        // with the conventional SIGPIPE status instead of reporting an error.
+        if (err == error.BrokenPipe) std.process.exit(141);
         writeTopLevelError(err);
         std.process.exit(exitCodeForError(err));
     };
 }
 
-fn mainInner() !void {
+fn mainInner(init: std.process.Init.Minimal) !void {
     const GeneralAllocator = if (@hasDecl(std.heap, "GeneralPurposeAllocator"))
         std.heap.GeneralPurposeAllocator
     else
@@ -29,8 +33,10 @@ fn mainInner() !void {
     var gpa = GeneralAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
+    stdio.initProcess(init, allocator);
+    defer stdio.deinitProcess();
 
-    var args = try std.process.argsWithAllocator(allocator);
+    var args = try std.process.Args.Iterator.initAllocator(init.args, allocator);
     defer args.deinit();
     _ = args.next();
     const command_name = args.next() orelse {
@@ -77,26 +83,29 @@ fn mainInner() !void {
     } else {
         std.debug.print("unknown command: {s}\n\n", .{command_name});
         try usage();
-        return error.UnknownCommand;
+        return error.unknownCommand;
     }
 }
 
 fn writeTopLevelError(err: anyerror) void {
     const public = errors.classify(err);
-    const stderr = std.fs.File.stderr().deprecatedWriter();
+    var stderr_io: stdio.Output = .{};
+    stderr_io.init(.stderr());
+    defer stderr_io.deinit();
+    const stderr = stderr_io.writer();
     stderr.print("error[{s}]: {s}\n", .{ public.code, public.message }) catch {};
     if (err == error.CommandFailed) {
         stderr.writeAll("hint: run `zmr doctor --json` for setup diagnostics.\n") catch {};
     }
-    if (err == error.UnknownFlag) {
+    if (err == error.unknownFlag) {
         stderr.writeAll("hint: run `zmr help` for each command's flags and arguments.\n") catch {};
     }
 }
 
 fn exitCodeForError(err: anyerror) u8 {
     return switch (err) {
-        error.UnknownCommand,
-        error.UnknownFlag,
+        error.unknownCommand,
+        error.unknownFlag,
         error.MissingScenarioPath,
         error.MissingDeviceSerial,
         error.MissingTraceDir,
@@ -122,7 +131,10 @@ fn exitCodeForError(err: anyerror) u8 {
 }
 
 fn usage() !void {
-    const stdout = std.fs.File.stdout().deprecatedWriter();
+    var stdout_io: stdio.Output = .{};
+    stdout_io.init(.stdout());
+    defer stdout_io.deinit();
+    const stdout = stdout_io.writer();
     try stdout.writeAll(
         \\zmr - Zeno Mobile Runner
         \\