zeno-mobile-runner 0.2.1 → 0.2.3

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");
@@ -15,6 +16,8 @@ const default_max_output = 32 * 1024 * 1024;
 const default_shim_timeout_ms = 5_400_000;
 const shim_timeout_env = "ZMR_IOS_SHIM_TIMEOUT_MS";
 const shim_best_effort_timeout_ms = 10_000;
+const open_link_interruption_attempts = 3;
+const open_link_interruption_retry_delay_ms = 1_000;
 const shim_command_attempts = 2;
 const shim_bootstrap_retry_delay_ms = 500;
 
@@ -190,11 +193,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;
@@ -239,7 +242,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,
@@ -257,21 +260,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);
     }
 
@@ -282,15 +285,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;
     }
 
@@ -308,7 +311,20 @@ pub const IosDevice = struct {
 
     fn acceptOpenURLConfirmationBestEffort(self: *IosDevice) void {
         if (self.shim_path == null) return;
-        self.runShimActionWithTimeout(.{ .kind = .accept_system_alert, .text = "Open" }, shim_best_effort_timeout_ms) catch {};
+        var attempt: usize = 0;
+        while (attempt < open_link_interruption_attempts) {
+            attempt += 1;
+            if (self.acceptOpenURLConfirmationOnce() catch return) return;
+            if (attempt < open_link_interruption_attempts) {
+                stdio.sleepNs(open_link_interruption_retry_delay_ms * std.time.ns_per_ms);
+            }
+        }
+    }
+
+    fn acceptOpenURLConfirmationOnce(self: *IosDevice) !bool {
+        const response = try self.runShimWithTimeout(.{ .kind = .accept_system_alert, .text = "Open" }, shim_best_effort_timeout_ms);
+        defer self.allocator.free(response);
+        return try ios_shim.parseAcceptSystemAlertResponse(response);
     }
 
     fn appIsRunningFromShimBestEffort(self: *IosDevice) bool {
@@ -340,19 +356,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;
@@ -391,7 +407,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
@@ -400,7 +416,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 {
@@ -410,6 +426,69 @@ fn parseShimTimeoutMs(raw: ?[]const u8) u64 {
     return parsed;
 }
 
+test "ios simulator openLink keeps sweeping delayed XCTest interruptions until accepted" {
+    const allocator = std.heap.page_allocator;
+    const argv = [_][*:0]const u8{"zmr-ios-test"};
+    stdio.initProcess(.{
+        .args = .{ .vector = argv[0..] },
+        .environ = .empty,
+    }, allocator);
+    defer stdio.deinitProcess();
+
+    var tmp = std.testing.tmpDir(.{});
+    defer tmp.cleanup();
+
+    var shim = try tmp.dir.createFile(stdio.io(), "fake-ios-shim-delayed.sh", .{ .truncate = true });
+    {
+        var buffer: [4096]u8 = undefined;
+        var writer = shim.writerStreaming(stdio.io(), &buffer);
+        try writer.interface.writeAll(
+            \\#!/usr/bin/env bash
+            \\set -euo pipefail
+            \\request="$(cat)"
+        );
+        const shim_tail = try std.fmt.allocPrint(allocator,
+            \\
+            \\printf '%s\n' "$request" >> ".zig-cache/tmp/{s}/shim.log"
+            \\count_file=".zig-cache/tmp/{s}/count.txt"
+            \\count=0
+            \\if [[ -f "$count_file" ]]; then
+            \\  count="$(cat "$count_file")"
+            \\fi
+            \\count=$((count + 1))
+            \\printf '%s' "$count" > "$count_file"
+            \\if [[ "$count" -lt 3 ]]; then
+            \\  printf '{{"status":"ok","accepted":false,"count":0}}\n'
+            \\else
+            \\  printf '{{"status":"ok","accepted":true,"label":"Brick Rewards Test","count":1}}\n'
+            \\fi
+            \\
+        , .{ tmp.sub_path, tmp.sub_path });
+        defer allocator.free(shim_tail);
+        try writer.interface.writeAll(shim_tail);
+        try writer.interface.flush();
+    }
+    shim.close(stdio.io());
+
+    const shim_path = try std.fmt.allocPrint(allocator, ".zig-cache/tmp/{s}/fake-ios-shim-delayed.sh", .{tmp.sub_path});
+    defer allocator.free(shim_path);
+    const shim_path_z = try allocator.dupeZ(u8, shim_path);
+    defer allocator.free(shim_path_z);
+    if (std.c.chmod(shim_path_z, 0o755) != 0) return error.ChmodFailed;
+
+    var device = try IosDevice.initWithShim(allocator, "./tests/fake-xcrun.sh", "fake-ios-1", "com.example.mobiletest", shim_path);
+    defer device.deinit();
+
+    try device.openLink("exampleapp:///e2e-auth?probe=1");
+
+    const count_path = try std.fmt.allocPrint(allocator, ".zig-cache/tmp/{s}/count.txt", .{tmp.sub_path});
+    defer allocator.free(count_path);
+    const count_raw = try stdio.readFileAlloc(allocator, count_path, 1024);
+    defer allocator.free(count_raw);
+    const count = try std.fmt.parseInt(u8, count_raw, 10);
+    try std.testing.expectEqual(@as(u8, 3), count);
+}
+
 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/ios_shim.zig

@@ -128,6 +128,18 @@ pub fn parseOkResponse(content: []const u8) !void {
     if (!std.mem.eql(u8, status, "ok")) return error.IosShimResponseNotOk;
 }
 
+pub fn parseAcceptSystemAlertResponse(content: []const u8) !bool {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const parsed = try std.json.parseFromSlice(std.json.Value, arena.allocator(), content, .{});
+    if (parsed.value != .object) return error.IosShimResponseMustBeObject;
+    const status = fieldString(parsed.value.object, "status") orelse return error.IosShimMissingStatus;
+    if (!std.mem.eql(u8, status, "ok")) return error.IosShimResponseNotOk;
+    const accepted = parsed.value.object.get("accepted") orelse return false;
+    if (accepted != .bool) return false;
+    return accepted.bool;
+}
+
 pub const SelectorActionResponse = enum {
     ok,
     selector_unavailable,

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\"}");
 }