@zigc/lib 0.16.0-dev.3091 → 0.16.0-dev.3128

package/std/Build/Step/Run.zig

@@ -1068,7 +1068,6 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
 pub fn rerunInFuzzMode(
     run: *Run,
     fuzz: *std.Build.Fuzz,
-    unit_test_name: []const u8,
     prog_node: std.Progress.Node,
 ) !void {
     const step = &run.step;
@@ -1139,7 +1138,6 @@ pub fn rerunInFuzzMode(
         .unit_test_timeout_ns = null, // don't time out fuzz tests for now
         .gpa = fuzz.gpa,
     }, .{
-        .unit_test_name = unit_test_name,
         .fuzz = fuzz,
     });
 }
@@ -1211,7 +1209,6 @@ fn termMatches(expected: ?process.Child.Term, actual: process.Child.Term) bool {
 
 const FuzzContext = struct {
     fuzz: *std.Build.Fuzz,
-    unit_test_name: []const u8,
 };
 
 fn runCommand(
@@ -1655,6 +1652,11 @@ fn evalZigTest(
     options: Step.MakeOptions,
     fuzz_context: ?FuzzContext,
 ) !void {
+    if (fuzz_context != null) {
+        try evalFuzzTest(run, spawn_options, options, fuzz_context.?);
+        return;
+    }
+
     const step_owner = run.step.owner;
     const gpa = step_owner.allocator;
     const arena = step_owner.allocator;
@@ -1693,7 +1695,6 @@ fn evalZigTest(
             run,
             &child,
             options,
-            fuzz_context,
             &multi_reader,
             &test_metadata,
             &test_results,
@@ -1815,7 +1816,6 @@ fn waitZigTest(
     run: *Run,
     child: *process.Child,
     options: Step.MakeOptions,
-    fuzz_context: ?FuzzContext,
     multi_reader: *Io.File.MultiReader,
     opt_metadata: *?TestMetadata,
     results: *Step.TestResults,
@@ -1837,29 +1837,7 @@ fn waitZigTest(
     var sub_prog_node: ?std.Progress.Node = null;
     defer if (sub_prog_node) |n| n.end();
 
-    if (fuzz_context) |ctx| {
-        assert(opt_metadata.* == null); // fuzz processes are never restarted
-        switch (ctx.fuzz.mode) {
-            .forever => {
-                sendRunFuzzTestMessage(
-                    io,
-                    child.stdin.?,
-                    ctx.unit_test_name,
-                    .forever,
-                    0, // instance ID; will be used by multiprocess forever fuzzing in the future
-                ) catch |err| return .{ .write_failed = err };
-            },
-            .limit => |limit| {
-                sendRunFuzzTestMessage(
-                    io,
-                    child.stdin.?,
-                    ctx.unit_test_name,
-                    .iterations,
-                    limit.amount,
-                ) catch |err| return .{ .write_failed = err };
-            },
-        }
-    } else if (opt_metadata.*) |*md| {
+    if (opt_metadata.*) |*md| {
         // Previous unit test process died or was killed; we're continuing where it left off
         requestNextTest(io, child.stdin.?, md, &sub_prog_node) catch |err| return .{ .write_failed = err };
     } else {
@@ -1872,14 +1850,11 @@ fn waitZigTest(
 
     var last_update: Io.Clock.Timestamp = .now(io, .awake);
 
-    var coverage_id: ?u64 = null;
-
     // This timeout is used when we're waiting on the test runner itself rather than a user-specified
     // test. For instance, if the test runner leaves this much time between us requesting a test to
     // start and it acknowledging the test starting, we terminate the child and raise an error. This
     // *should* never happen, but could in theory be caused by some very unlucky IB in a test.
-    const response_timeout: ?Io.Clock.Duration = t: {
-        if (fuzz_context != null) break :t null; // don't timeout fuzz tests
+    const response_timeout: Io.Clock.Duration = t: {
         const ns = @max(options.unit_test_timeout_ns orelse 0, 60 * std.time.ns_per_s);
         break :t .{ .clock = .awake, .raw = .fromNanoseconds(ns) };
     };
@@ -1947,8 +1922,6 @@ fn waitZigTest(
                 );
             },
             .test_metadata => {
-                assert(fuzz_context == null);
-
                 // `metadata` would only be populated if we'd already seen a `test_metadata`, but we
                 // only request it once (and importantly, we don't re-request it if we kill and
                 // restart the test runner).
@@ -1986,7 +1959,6 @@ fn waitZigTest(
                 last_update = .now(io, .awake);
             },
             .test_results => {
-                assert(fuzz_context == null);
                 const md = &opt_metadata.*.?;
 
                 const tr_hdr = body_r.takeStruct(std.zig.Server.Message.TestResults, .little) catch unreachable;
@@ -2033,44 +2005,523 @@ fn waitZigTest(
 
                 requestNextTest(io, child.stdin.?, md, &sub_prog_node) catch |err| return .{ .write_failed = err };
             },
+            else => {}, // ignore other messages
+        }
+    }
+}
+
+const FuzzTestRunner = struct {
+    run: *Run,
+    ctx: FuzzContext,
+    coverage_id: ?u64,
+
+    instances: []Instance,
+    /// The indexes of this are layed out such that it is effectively an array
+    /// of `[instances.len][3]Io.Operation.Storage` of stdin, stdout, stderr.
+    batch: Io.Batch,
+    /// LIFO. Stream of message bodies trailed by PendingBroadcastFooter.
+    pending_broadcasts: std.ArrayList(u8),
+    broadcast: std.ArrayList(u8),
+    broadcast_undelivered: u32,
+
+    const Instance = struct {
+        child: process.Child,
+        message: std.ArrayListAligned(u8, .@"4"),
+        broadcast_written: usize,
+        stderr: std.ArrayList(u8),
+        stdin_vec: [1][]u8,
+        stdout_vec: [1][]u8,
+        stderr_vec: [1][]u8,
+        progress_node: std.Progress.Node,
+
+        fn messageHeader(instance: *Instance) InHeader {
+            assert(instance.message.items.len >= @sizeOf(InHeader));
+            const header_ptr: *InHeader = @ptrCast(instance.message.items);
+            var header = header_ptr.*;
+            if (std.builtin.Endian.native != .little) {
+                std.mem.byteSwapAllFields(InHeader, &header);
+            }
+            return header;
+        }
+    };
+
+    const PendingBroadcastFooter = struct {
+        from_id: u32,
+        body_len: u32,
+    };
+
+    const InHeader = std.zig.Server.Message.Header;
+    const OutHeader = std.zig.Client.Message.Header;
+
+    const stdin_i = 0;
+    const stdout_i = 1;
+    const stderr_i = 2;
+
+    fn init(
+        run: *Run,
+        ctx: FuzzContext,
+        progress_node: std.Progress.Node,
+        spawn_options: process.SpawnOptions,
+    ) !FuzzTestRunner {
+        const step_owner = run.step.owner;
+        const gpa = step_owner.allocator;
+        const io = step_owner.graph.io;
+
+        const n_instances = switch (ctx.fuzz.mode) {
+            .forever => step_owner.graph.max_jobs orelse @min(
+                std.Thread.getCpuCount() catch 1,
+                (std.math.maxInt(u32) - 2) / 3,
+            ),
+            .limit => 1,
+        };
+        const instances = try gpa.alloc(Instance, n_instances);
+        errdefer gpa.free(instances);
+        const batch_storage = try gpa.alloc(Io.Operation.Storage, instances.len * 3);
+        errdefer gpa.free(batch_storage);
+
+        @memset(instances, .{
+            .child = undefined,
+            .message = .empty,
+            .broadcast_written = undefined,
+            .stderr = .empty,
+            .stdin_vec = undefined,
+            .stdout_vec = undefined,
+            .stderr_vec = undefined,
+            .progress_node = undefined,
+        });
+        for (0.., instances) |id, *instance| {
+            errdefer for (instances[0..id]) |*spawned| {
+                spawned.child.kill(io);
+                spawned.progress_node.end();
+            };
+            instance.child = try process.spawn(io, spawn_options);
+            instance.progress_node = progress_node.start("starting fuzzer", 0);
+        }
+
+        return .{
+            .run = run,
+            .ctx = ctx,
+            .coverage_id = null,
+
+            .instances = instances,
+            .batch = .init(batch_storage),
+            .pending_broadcasts = .empty,
+            .broadcast = .empty,
+            .broadcast_undelivered = 0,
+        };
+    }
+
+    fn deinit(f: *FuzzTestRunner) void {
+        const step_owner = f.run.step.owner;
+        const gpa = step_owner.allocator;
+        const io = step_owner.graph.io;
+
+        f.batch.cancel(io);
+        gpa.free(f.batch.storage);
+        var total_rss: usize = 0;
+        for (f.instances) |*instance| {
+            instance.child.kill(io);
+            instance.message.deinit(gpa);
+            instance.stderr.deinit(gpa);
+            instance.progress_node.end();
+            total_rss += instance.child.resource_usage_statistics.getMaxRss() orelse 0;
+        }
+        f.run.step.result_peak_rss = @max(f.run.step.result_peak_rss, total_rss);
+        gpa.free(f.instances);
+    }
+
+    fn startInstances(f: *FuzzTestRunner) !void {
+        const step_owner = f.run.step.owner;
+        const io = step_owner.graph.io;
+
+        for (0.., f.instances) |id, *instance| {
+            const id32: u32 = @intCast(id);
+            (switch (f.ctx.fuzz.mode) {
+                .forever => sendRunFuzzTestMessage(
+                    io,
+                    instance.child.stdin.?,
+                    f.run.fuzz_tests.items,
+                    .forever,
+                    id32,
+                ),
+                .limit => |limit| sendRunFuzzTestMessage(
+                    io,
+                    instance.child.stdin.?,
+                    f.run.fuzz_tests.items,
+                    .iterations,
+                    limit.amount,
+                ),
+            }) catch |write_err| {
+                // The runner unexpectedly closed stdin, which means it crashed during initialization.
+                // Clean up everything and wait for the child to exit.
+                instance.child.stdin.?.close(io);
+                instance.child.stdin = null;
+                const term = try instance.child.wait(io);
+                return f.run.step.fail(
+                    "unable to write stdin ({t}); test process unexpectedly {f}",
+                    .{ write_err, fmtTerm(term) },
+                );
+            };
+
+            try f.addStdoutRead(id32, @sizeOf(InHeader));
+            try f.addStderrRead(id32);
+        }
+    }
+
+    fn listen(f: *FuzzTestRunner) !void {
+        const step_owner = f.run.step.owner;
+        const io = step_owner.graph.io;
+
+        while (true) {
+            try f.batch.awaitConcurrent(io, .none);
+            while (f.batch.next()) |completion| {
+                const id = completion.index / 3;
+                const result = completion.result;
+                switch (completion.index % 3) {
+                    0 => try f.completeStdinWrite(id, result.file_write_streaming catch |e| switch (e) {
+                        error.BrokenPipe => return f.instanceEos(id),
+                        else => |write_e| return write_e,
+                    }),
+                    1 => try f.completeStdoutRead(id, result.file_read_streaming catch |e| switch (e) {
+                        error.EndOfStream => return f.instanceEos(id),
+                        else => |read_e| return read_e,
+                    }),
+                    2 => try f.completeStderrRead(id, result.file_read_streaming catch |e| switch (e) {
+                        error.EndOfStream => return f.instanceEos(id),
+                        else => |read_e| return read_e,
+                    }),
+                    else => unreachable,
+                }
+            }
+        }
+    }
+
+    fn completeStdoutRead(f: *FuzzTestRunner, id: u32, n: usize) !void {
+        const step_owner = f.run.step.owner;
+        const gpa = step_owner.allocator;
+        const io = step_owner.graph.io;
+        const instance = &f.instances[id];
+
+        instance.message.items.len += n;
+        const total_read = instance.message.items.len;
+        if (total_read < @sizeOf(InHeader)) {
+            try f.addStdoutRead(id, @sizeOf(InHeader));
+            return;
+        }
+
+        const header = instance.messageHeader();
+        const body = instance.message.items[@sizeOf(InHeader)..];
+        if (body.len != header.bytes_len) {
+            try f.addStdoutRead(id, @sizeOf(InHeader) + header.bytes_len);
+            return;
+        }
+
+        switch (header.tag) {
+            .zig_version => {
+                if (!std.mem.eql(u8, builtin.zig_version_string, body)) return f.run.step.fail(
+                    "zig version mismatch build runner vs compiler: '{s}' vs '{s}'",
+                    .{ builtin.zig_version_string, body },
+                );
+            },
             .coverage_id => {
-                coverage_id = body_r.takeInt(u64, .little) catch unreachable;
+                var body_r: Io.Reader = .fixed(body);
+                f.coverage_id = body_r.takeInt(u64, .little) catch unreachable;
                 const cumulative_runs = body_r.takeInt(u64, .little) catch unreachable;
                 const cumulative_unique = body_r.takeInt(u64, .little) catch unreachable;
                 const cumulative_coverage = body_r.takeInt(u64, .little) catch unreachable;
 
-                {
-                    const fuzz = fuzz_context.?.fuzz;
-                    fuzz.queue_mutex.lockUncancelable(io);
-                    defer fuzz.queue_mutex.unlock(io);
-                    try fuzz.msg_queue.append(fuzz.gpa, .{ .coverage = .{
-                        .id = coverage_id.?,
-                        .cumulative = .{
-                            .runs = cumulative_runs,
-                            .unique = cumulative_unique,
-                            .coverage = cumulative_coverage,
-                        },
-                        .run = run,
-                    } });
-                    fuzz.queue_cond.signal(io);
-                }
+                const fuzz = f.ctx.fuzz;
+                fuzz.queue_mutex.lockUncancelable(io);
+                defer fuzz.queue_mutex.unlock(io);
+                try fuzz.msg_queue.append(fuzz.gpa, .{ .coverage = .{
+                    .id = f.coverage_id.?,
+                    .cumulative = .{
+                        .runs = cumulative_runs,
+                        .unique = cumulative_unique,
+                        .coverage = cumulative_coverage,
+                    },
+                    .run = f.run,
+                } });
+                fuzz.queue_cond.signal(io);
             },
             .fuzz_start_addr => {
-                const fuzz = fuzz_context.?.fuzz;
+                var body_r: Io.Reader = .fixed(body);
+                const fuzz = f.ctx.fuzz;
                 const addr = body_r.takeInt(u64, .little) catch unreachable;
-                {
-                    fuzz.queue_mutex.lockUncancelable(io);
-                    defer fuzz.queue_mutex.unlock(io);
-                    try fuzz.msg_queue.append(fuzz.gpa, .{ .entry_point = .{
-                        .addr = addr,
-                        .coverage_id = coverage_id.?,
-                    } });
-                    fuzz.queue_cond.signal(io);
+
+                fuzz.queue_mutex.lockUncancelable(io);
+                defer fuzz.queue_mutex.unlock(io);
+                try fuzz.msg_queue.append(fuzz.gpa, .{ .entry_point = .{
+                    .addr = addr,
+                    .coverage_id = f.coverage_id.?,
+                } });
+                fuzz.queue_cond.signal(io);
+            },
+            .fuzz_test_change => {
+                const test_i = std.mem.readInt(u32, body[0..4], .little);
+                instance.progress_node.setName(f.run.fuzz_tests.items[test_i]);
+            },
+            .broadcast_fuzz_input => {
+                if (f.instances.len == 1) {
+                    // No other processes to broadcast to.
+                } else if (f.broadcast_undelivered == 0) {
+                    try f.instanceBroadcast(id, body);
+                } else {
+                    const footer: PendingBroadcastFooter = .{
+                        .from_id = id,
+                        .body_len = @intCast(body.len),
+                    };
+                    // There is another broadcast in progress so add this one to the queue.
+                    const size = @sizeOf(PendingBroadcastFooter) + body.len;
+                    try f.pending_broadcasts.ensureUnusedCapacity(gpa, size);
+                    f.pending_broadcasts.appendSliceAssumeCapacity(body);
+                    f.pending_broadcasts.appendSliceAssumeCapacity(@ptrCast(&footer));
                 }
             },
             else => {}, // ignore other messages
         }
+
+        instance.message.clearRetainingCapacity();
+        try f.addStdoutRead(id, @sizeOf(InHeader));
+    }
+
+    fn completeStderrRead(f: *FuzzTestRunner, id: u32, n: usize) !void {
+        const instance = &f.instances[id];
+        instance.stderr.items.len += n;
+        try f.addStderrRead(id);
+    }
+
+    fn completeStdinWrite(f: *FuzzTestRunner, id: u32, n: usize) !void {
+        const instance = &f.instances[id];
+
+        instance.broadcast_written += n;
+        if (instance.broadcast_written == f.broadcast.items.len) {
+            f.broadcast_undelivered -= 1;
+            if (f.broadcast_undelivered == 0) {
+                try f.broadcastComplete();
+            }
+        } else {
+            f.addStdinWrite(id);
+        }
     }
+
+    fn addStdoutRead(f: *FuzzTestRunner, id: u32, end: usize) !void {
+        const step_owner = f.run.step.owner;
+        const gpa = step_owner.allocator;
+        const instance = &f.instances[id];
+
+        try instance.message.ensureTotalCapacity(gpa, end);
+        const start = instance.message.items.len;
+        instance.stdout_vec = .{instance.message.allocatedSlice()[start..end]};
+        f.batch.addAt(id * 3 + stdout_i, .{ .file_read_streaming = .{
+            .file = instance.child.stdout.?,
+            .data = &instance.stdout_vec,
+        } });
+    }
+
+    fn addStderrRead(f: *FuzzTestRunner, id: u32) !void {
+        const step_owner = f.run.step.owner;
+        const gpa = step_owner.allocator;
+        const instance = &f.instances[id];
+
+        try instance.stderr.ensureUnusedCapacity(gpa, 1);
+        instance.stderr_vec = .{instance.stderr.unusedCapacitySlice()};
+        f.batch.addAt(id * 3 + stderr_i, .{ .file_read_streaming = .{
+            .file = instance.child.stderr.?,
+            .data = &instance.stderr_vec,
+        } });
+    }
+
+    fn addStdinWrite(f: *FuzzTestRunner, id: u32) void {
+        const instance = &f.instances[id];
+
+        assert(f.broadcast.items.len != instance.broadcast_written);
+        instance.stdin_vec = .{f.broadcast.items[instance.broadcast_written..]};
+        f.batch.addAt(id * 3 + stdin_i, .{ .file_write_streaming = .{
+            .file = instance.child.stdin.?,
+            .data = &instance.stdin_vec,
+        } });
+    }
+
+    fn instanceEos(f: *FuzzTestRunner, id: u32) !void {
+        const step_owner = f.run.step.owner;
+        const io = step_owner.graph.io;
+        const instance = &f.instances[id];
+
+        instance.child.stdin.?.close(io);
+        instance.child.stdin = null;
+        const term = try instance.child.wait(io);
+        if (!termMatches(.{ .exited = 0 }, term)) {
+            f.run.step.result_stderr = try f.mergedStderr();
+            try f.saveCrash(id, term);
+            return f.run.step.fail("test process unexpectedly {f}", .{fmtTerm(term)});
+        }
+    }
+
+    fn saveCrash(f: *FuzzTestRunner, id: u32, term: process.Child.Term) !void {
+        const step = &f.run.step;
+        const b = step.owner;
+        const io = b.graph.io;
+
+        if (f.coverage_id == null) return;
+
+        // Search for the input file corresponding to the instance
+        const InputHeader = Build.abi.fuzz.MmapInputHeader;
+        var in_r_buf: [@sizeOf(InputHeader)]u8 = undefined;
+        var in_r: Io.File.Reader = undefined;
+        var in_f: Io.File = undefined;
+        var in_name_buf: [12]u8 = undefined;
+        var in_name: []const u8 = undefined;
+        var i: u32 = 0;
+        const header: InputHeader = while (true) {
+            const name_prefix = "f" ++ Io.Dir.path.sep_str ++ "in";
+            in_name = std.fmt.bufPrint(&in_name_buf, name_prefix ++ "{x}", .{i}) catch unreachable;
+            in_f = b.cache_root.handle.openFile(io, in_name, .{
+                .lock = .exclusive,
+                .lock_nonblocking = true,
+            }) catch |e| switch (e) {
+                error.FileNotFound => return,
+                error.WouldBlock => continue, // Can not be from
+                // the crashed instance since it is still locked.
+                else => return step.fail("failed to open file '{f}{s}': {t}", .{
+                    b.cache_root, in_name, e,
+                }),
+            };
+
+            in_r = in_f.readerStreaming(io, &in_r_buf);
+            const header = in_r.interface.takeStruct(InputHeader, .little) catch |e| {
+                in_f.close(io);
+                switch (e) {
+                    error.ReadFailed => return step.fail("failed to read file '{f}{s}': {t}", .{
+                        b.cache_root, in_name, in_r.err.?,
+                    }),
+                    error.EndOfStream => continue,
+                }
+            };
+
+            if (header.pc_digest == f.coverage_id.? and
+                header.instance_id == id and
+                header.test_i < f.run.fuzz_tests.items.len)
+            {
+                break header;
+            }
+
+            in_f.close(io);
+            if (i == std.math.maxInt(u32)) return;
+            i += 1;
+        };
+        defer in_f.close(io);
+
+        // Save it to a seperate file
+        const crash_name = "f" ++ Io.Dir.path.sep_str ++ "crash";
+        const out = b.cache_root.handle.createFile(io, crash_name, .{
+            .lock = .exclusive, // Multiple run steps could have found a crash at the same time
+        }) catch |e| return step.fail("failed to create file '{f}{s}': {t}", .{
+            b.cache_root, crash_name, e,
+        });
+        defer out.close(io);
+
+        var out_w_buf: [512]u8 = undefined;
+        var out_w = out.writerStreaming(io, &out_w_buf);
+        _ = out_w.interface.sendFileAll(&in_r, .limited(header.len)) catch |e| switch (e) {
+            error.ReadFailed => return step.fail("failed to read file '{f}{s}': {t}", .{
+                b.cache_root, in_name, in_r.err.?,
+            }),
+            error.WriteFailed => return step.fail("failed to write file '{f}{s}': {t}", .{
+                b.cache_root, crash_name, out_w.err.?,
+            }),
+        };
+
+        return f.run.step.fail("test '{s}' {f}; input saved to '{f}{s}'", .{
+            f.run.fuzz_tests.items[header.test_i],
+            fmtTerm(term),
+            b.cache_root,
+            crash_name,
+        });
+    }
+
+    fn instanceBroadcast(f: *FuzzTestRunner, from_id: u32, bytes: []const u8) !void {
+        assert(f.instances.len > 1);
+        assert(f.broadcast_undelivered == 0); // no other broadcast is progress
+        assert(f.broadcast.items.len == 0);
+        assert(from_id < f.instances.len);
+
+        const step_owner = f.run.step.owner;
+        const gpa = step_owner.allocator;
+
+        var out_header: OutHeader = .{
+            .tag = .new_fuzz_input,
+            .bytes_len = @intCast(bytes.len),
+        };
+        if (std.builtin.Endian.native != .little) {
+            std.mem.byteSwapAllFields(OutHeader, &out_header);
+        }
+        try f.broadcast.ensureTotalCapacity(gpa, @sizeOf(OutHeader) + bytes.len);
+        f.broadcast.appendSliceAssumeCapacity(@ptrCast(&out_header));
+        f.broadcast.appendSliceAssumeCapacity(bytes);
+
+        f.broadcast_undelivered = @intCast(f.instances.len - 1);
+        for (0.., f.instances) |to_id, *instance| {
+            if (to_id == from_id) continue;
+            instance.broadcast_written = 0;
+            f.addStdinWrite(@intCast(to_id));
+        }
+    }
+
+    fn broadcastComplete(f: *FuzzTestRunner) !void {
+        assert(f.instances.len > 1);
+        assert(f.broadcast_undelivered == 0);
+        f.broadcast.clearRetainingCapacity();
+
+        const pending = &f.pending_broadcasts;
+        if (pending.items.len != 0) {
+            // Another broadcast is pending; copy it over to `broadcast`
+
+            const footer_len = @sizeOf(PendingBroadcastFooter);
+            const footer_bytes = pending.items[pending.items.len - footer_len ..];
+            const footer: *align(1) PendingBroadcastFooter = @ptrCast(footer_bytes);
+            pending.items.len -= footer_len;
+
+            const body = pending.items[pending.items.len - footer.body_len ..];
+            try f.instanceBroadcast(footer.from_id, body);
+            pending.items.len -= body.len;
+        }
+    }
+
+    fn mergedStderr(f: *FuzzTestRunner) std.mem.Allocator.Error![]const u8 {
+        const step_owner = f.run.step.owner;
+        const arena = step_owner.allocator;
+
+        // Collect any remaining stderr
+        while (f.batch.next()) |completion| {
+            if (completion.index % 3 != 2) continue;
+            const len = completion.result.file_read_streaming catch continue;
+            f.instances[completion.index / 3].stderr.items.len += len;
+        }
+
+        var stderr_len: usize = 0;
+        for (f.instances) |*instance| stderr_len += instance.stderr.items.len;
+        const stderr = try arena.alloc(u8, stderr_len);
+
+        stderr_len = 0;
+        for (f.instances) |*instance| {
+            @memcpy(stderr[stderr_len..][0..instance.stderr.items.len], instance.stderr.items);
+            stderr_len += instance.stderr.items.len;
+        }
+        return stderr;
+    }
+};
+
+fn evalFuzzTest(
+    run: *Run,
+    spawn_options: process.SpawnOptions,
+    options: Step.MakeOptions,
+    fuzz_context: FuzzContext,
+) !void {
+    var f: FuzzTestRunner = try .init(run, fuzz_context, options.progress_node, spawn_options);
+    defer f.deinit();
+    try f.startInstances();
+    try f.listen();
 }
 
 const TestMetadata = struct {
@@ -2149,30 +2600,41 @@ fn sendRunTestMessage(io: Io, file: Io.File, tag: std.zig.Client.Message.Tag, in
 fn sendRunFuzzTestMessage(
     io: Io,
     file: Io.File,
-    test_name: []const u8,
+    test_names: []const []const u8,
     kind: std.Build.abi.fuzz.LimitKind,
     amount_or_instance: u64,
 ) !void {
     const header: std.zig.Client.Message.Header = .{
         .tag = .start_fuzzing,
-        .bytes_len = 4 + 1 + 8,
+        .bytes_len = 1 + 8 + 4 + count: {
+            var c: u32 = @intCast(test_names.len * 4);
+            for (test_names) |name| {
+                c += @intCast(name.len);
+            }
+            break :count c;
+        },
     };
     var w = file.writerStreaming(io, &.{});
     w.interface.writeStruct(header, .little) catch |err| switch (err) {
         error.WriteFailed => return w.err.?,
     };
-    w.interface.writeInt(u32, @intCast(test_name.len), .little) catch |err| switch (err) {
-        error.WriteFailed => return w.err.?,
-    };
-    w.interface.writeAll(test_name) catch |err| switch (err) {
-        error.WriteFailed => return w.err.?,
-    };
     w.interface.writeByte(@intFromEnum(kind)) catch |err| switch (err) {
         error.WriteFailed => return w.err.?,
     };
     w.interface.writeInt(u64, amount_or_instance, .little) catch |err| switch (err) {
         error.WriteFailed => return w.err.?,
     };
+    w.interface.writeInt(u32, @intCast(test_names.len), .little) catch |err| switch (err) {
+        error.WriteFailed => return w.err.?,
+    };
+    for (test_names) |test_name| {
+        w.interface.writeInt(u32, @intCast(test_name.len), .little) catch |err| switch (err) {
+            error.WriteFailed => return w.err.?,
+        };
+        w.interface.writeAll(test_name) catch |err| switch (err) {
+            error.WriteFailed => return w.err.?,
+        };
+    }
 }
 
 fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResult {