as-test 1.0.4 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Change Log
 
+## 2026-03-31 - v1.0.6
+
+### Fuzzing
+
+- feat: print exact failing fuzz seeds and one-run repro commands on logical fuzz failures, and persist captured `run(...)` inputs in `.as-test/crashes` so side-effectful generators still leave behind replayable failure data.
+
+### Reporting
+
+- fix: correct reporter override output behavior.
+
+## 2026-03-30 - v1.0.5
+
+### CLI
+
+- fix: preserve selectors passed after `--parallel` so commands like `ast test --parallel math` still target the requested suite.
+- fix: treat uncaught runtime stderr / missing report payloads as normal failed test results instead of transport-level crashes, with cleaner default reporter output.
+- perf: reuse build artifacts across modes when the resolved non-custom build invocation and build environment are identical, copying the first artifact instead of recompiling.
+
 ## 2026-03-27 - v1.0.4
 
 ### Build Command

package/README.md

@@ -66,6 +66,23 @@ By default, `as-test` looks for:
 
 Generated files go into `.as-test/`.
 
+Minimal `as-test.config.json`:
+
+```json
+{
+  "input": ["assembly/__tests__/*.spec.ts"],
+  "output": ".as-test/",
+  "buildOptions": {
+    "target": "wasi"
+  },
+  "runOptions": {
+    "runtime": {
+      "cmd": "node .as-test/runners/default.wasi.js <file>"
+    }
+  }
+}
+```
+
 ## Writing Tests
 
 Tests usually live in `assembly/__tests__/*.spec.ts`.
@@ -214,6 +231,8 @@ If you used `npx ast init` with a fuzzer example, the config is already there. O
 
 `ast fuzz` runs fuzz files across the selected modes, reports one result per file, and keeps the final summary separate from the normal test totals. If you want one combined command, use `ast test --fuzz`.
 
+When a fuzzer fails, `as-test` now prints the exact failing seeds and one-run repro commands such as `ast fuzz ... --seed <seed+n> --runs 1`. Crash records in `.as-test/crashes` also include the captured inputs passed to `run(...)`, which helps when the generator itself has side effects.
+
 Run only fuzzers:
 
 ```bash

package/assembly/src/fuzz.ts

@@ -1,4 +1,4 @@
-import { quote } from "../util/json";
+import { quote, rawOrNull, stringifyValue } from "../util/json";
 
 export class StringOptions {
   charset: string = "ascii";
@@ -211,6 +211,7 @@ export class FuzzerResult {
   public failureLeft: string = "";
   public failureRight: string = "";
   public failureMessage: string = "";
+  public failures: FuzzFailure[] = [];
 
   serialize(): string {
     return (
@@ -238,7 +239,27 @@ export class FuzzerResult {
       quote(this.failureRight) +
       ',"message":' +
       quote(this.failureMessage) +
-      "}}"
+      '},"failures":' +
+      serializeFuzzFailures(this.failures) +
+      "}"
+    );
+  }
+}
+
+export class FuzzFailure {
+  public run: i32 = 0;
+  public seed: u64 = 0;
+  public input: string = "";
+
+  serialize(): string {
+    return (
+      '{"run":' +
+      this.run.toString() +
+      ',"seed":' +
+      this.seed.toString() +
+      ',"input":' +
+      rawOrNull(this.input) +
+      "}"
     );
   }
 }
@@ -329,7 +350,7 @@ function createSkippedResult(name: string): FuzzerResult {
   return result;
 }
 
-function recordResult(result: FuzzerResult): void {
+function recordResult(result: FuzzerResult, run: i32, seed: u64): void {
   if (__as_test_fuzz_failed) {
     result.failed++;
     if (!result.failureInstr.length && __as_test_fuzz_failure_instr.length) {
@@ -338,6 +359,11 @@ function recordResult(result: FuzzerResult): void {
       result.failureRight = __as_test_fuzz_failure_right;
       result.failureMessage = __as_test_fuzz_failure_message;
     }
+    const failure = new FuzzFailure();
+    failure.run = run;
+    failure.seed = seed;
+    failure.input = __as_test_fuzz_input;
+    result.failures.push(failure);
   } else {
     result.passed++;
   }
@@ -389,7 +415,7 @@ export class Fuzzer0<R> extends FuzzerBase {
           "fuzz generator must call run() exactly once",
         );
       }
-      recordResult(result);
+      recordResult(result, i, seedBase + <u64>i);
     }
     __fuzz_callback0 = null;
     result.timeEnd = performance.now();
@@ -438,7 +464,10 @@ export class Fuzzer1<A, R> extends FuzzerBase {
           "fuzzers with arguments must call .generate(...)",
         );
       } else {
-        this.generator(seed, changetype<(a: A) => R>(__fuzz_run1));
+        this.generator(seed, (a: A): R => {
+          __as_test_fuzz_input = "[" + stringifyValue<A>(a) + "]";
+          return changetype<(a: A) => R>(__fuzz_run1)(a);
+        });
       }
       if (__fuzz_calls != 1) {
         failFuzzIteration(
@@ -448,7 +477,7 @@ export class Fuzzer1<A, R> extends FuzzerBase {
           "fuzz generator must call run() exactly once",
         );
       }
-      recordResult(result);
+      recordResult(result, i, seedBase + <u64>i);
     }
     __fuzz_callback1 = null;
     result.timeEnd = performance.now();
@@ -500,7 +529,11 @@ export class Fuzzer2<A, B, R> extends FuzzerBase {
           "fuzzers with arguments must call .generate(...)",
         );
       } else {
-        this.generator(seed, changetype<(a: A, b: B) => R>(__fuzz_run2));
+        this.generator(seed, (a: A, b: B): R => {
+          __as_test_fuzz_input =
+            "[" + stringifyValue<A>(a) + "," + stringifyValue<B>(b) + "]";
+          return changetype<(a: A, b: B) => R>(__fuzz_run2)(a, b);
+        });
       }
       if (__fuzz_calls != 1) {
         failFuzzIteration(
@@ -510,7 +543,7 @@ export class Fuzzer2<A, B, R> extends FuzzerBase {
           "fuzz generator must call run() exactly once",
         );
       }
-      recordResult(result);
+      recordResult(result, i, seedBase + <u64>i);
     }
     __fuzz_callback2 = null;
     result.timeEnd = performance.now();
@@ -564,7 +597,17 @@ export class Fuzzer3<A, B, C, R> extends FuzzerBase {
       } else {
         changetype<(seed: FuzzSeed, run: (a: A, b: B, c: C) => R) => void>(
           this.generator,
-        )(seed, changetype<(a: A, b: B, c: C) => R>(__fuzz_run3));
+        )(seed, (a: A, b: B, c: C): R => {
+          __as_test_fuzz_input =
+            "[" +
+            stringifyValue<A>(a) +
+            "," +
+            stringifyValue<B>(b) +
+            "," +
+            stringifyValue<C>(c) +
+            "]";
+          return changetype<(a: A, b: B, c: C) => R>(__fuzz_run3)(a, b, c);
+        });
       }
       if (__fuzz_calls != 1) {
         failFuzzIteration(
@@ -574,7 +617,7 @@ export class Fuzzer3<A, B, C, R> extends FuzzerBase {
           "fuzz generator must call run() exactly once",
         );
       }
-      recordResult(result);
+      recordResult(result, i, seedBase + <u64>i);
     }
     __fuzz_callback3 = null;
     result.timeEnd = performance.now();
@@ -694,6 +737,8 @@ function containsFloatValue<T>(values: T[], needle: T): bool {
 @global export let __as_test_fuzz_failure_right: string = "";
 // @ts-ignore
 @global export let __as_test_fuzz_failure_message: string = "";
+// @ts-ignore
+@global export let __as_test_fuzz_input: string = "";
 
 export function prepareFuzzIteration(): void {
   __as_test_fuzz_failed = false;
@@ -701,6 +746,7 @@ export function prepareFuzzIteration(): void {
   __as_test_fuzz_failure_left = "";
   __as_test_fuzz_failure_right = "";
   __as_test_fuzz_failure_message = "";
+  __as_test_fuzz_input = "[]";
 }
 
 export function failFuzzIteration(
@@ -721,3 +767,15 @@ export function failFuzzIteration(
 function panic(): void {
   unreachable();
 }
+
+function serializeFuzzFailures(values: FuzzFailure[]): string {
+  if (!values.length) return "[]";
+
+  let out = "[";
+  for (let i = 0; i < values.length; i++) {
+    if (i) out += ",";
+    out += unchecked(values[i]).serialize();
+  }
+  out += "]";
+  return out;
+}

package/bin/commands/build-core.js

@@ -124,6 +124,39 @@ export async function getBuildInvocationPreview(configPath = DEFAULT_CONFIG_PATH
     const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
     return getBuildCommand(config, getPkgRunner(), file, outFile, modeName, featureToggles);
 }
+export async function getBuildReuseInfo(configPath = DEFAULT_CONFIG_PATH, file, modeName, featureToggles = {}, overrides = {}) {
+    const loadedConfig = loadConfig(configPath, false);
+    const mode = applyMode(loadedConfig, modeName);
+    const config = Object.assign(Object.create(Object.getPrototypeOf(mode.config)), mode.config);
+    config.buildOptions = Object.assign(Object.create(Object.getPrototypeOf(mode.config.buildOptions)), mode.config.buildOptions);
+    if (overrides.target) {
+        config.buildOptions.target = overrides.target;
+    }
+    if (overrides.args?.length) {
+        config.buildOptions.args = [...config.buildOptions.args, ...overrides.args];
+    }
+    if (hasCustomBuildCommand(config)) {
+        return null;
+    }
+    const duplicateSpecBasenames = resolveDuplicateBasenames([file]);
+    const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+    const invocation = getBuildCommand(config, getPkgRunner(), file, outFile, modeName, featureToggles);
+    const coverageEnabled = resolveCoverageEnabled(config.coverage, featureToggles.coverage);
+    const buildEnv = {
+        ...mode.env,
+        ...config.buildOptions.env,
+        AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
+    };
+    return {
+        signature: JSON.stringify({
+            command: invocation.command,
+            args: stripOutputArgs(invocation.args),
+            apiArgs: invocation.apiArgs ? stripOutputArgs(invocation.apiArgs) : [],
+            env: sortRecord(buildEnv),
+        }),
+        outFile,
+    };
+}
 function hasCustomBuildCommand(config) {
     return !!config.buildOptions.cmd.trim().length;
 }
@@ -176,6 +209,23 @@ function getUserBuildArgs(config) {
     }
     return args;
 }
+function stripOutputArgs(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg == "-o" || arg == "--outFile") {
+            i++;
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+function sortRecord(record) {
+    return Object.fromEntries(Object.entries(record)
+        .filter((entry) => typeof entry[1] == "string")
+        .sort((a, b) => a[0].localeCompare(b[0])));
+}
 function expandBuildCommand(template, file, outFile, target, modeName) {
     const name = path
         .basename(file)

package/bin/commands/build.js

@@ -1,6 +1,6 @@
 import { closeSerialBuildWorkerPool, } from "./build-core.js";
 export { build } from "./build-core.js";
-export { formatInvocation, getBuildInvocationPreview } from "./build-core.js";
+export { formatInvocation, getBuildInvocationPreview, getBuildReuseInfo, } from "./build-core.js";
 export async function executeBuildCommand(rawArgs, configPath, selectedModes, deps) {
     const commandArgs = deps.resolveCommandArgs(rawArgs, "build");
     const listFlags = deps.resolveListFlags(rawArgs, "build");

package/bin/commands/fuzz-core.js

@@ -68,6 +68,7 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
         const crash = persistCrashRecord(config.crashDir, {
             kind: "fuzz",
             file,
+            entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
             mode: modeName ?? "default",
             seed: config.seed,
             error: crashMessage,
@@ -94,6 +95,7 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
         const crash = persistCrashRecord(config.crashDir, {
             kind: "fuzz",
             file,
+            entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
             mode: modeName ?? "default",
             seed: config.seed,
             error: `missing fuzz report payload from ${path.basename(file)}`,
@@ -115,13 +117,37 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
             fuzzers: [],
         };
     }
+    const crashFiles = [];
+    for (const fuzzer of report.fuzzers) {
+        if (fuzzer.failed <= 0 && fuzzer.crashed <= 0)
+            continue;
+        const firstFailureSeed = typeof fuzzer.failures?.[0]?.seed == "number"
+            ? fuzzer.failures[0].seed
+            : config.seed;
+        const crash = persistCrashRecord(config.crashDir, {
+            kind: "fuzz",
+            file,
+            entryKey: buildFuzzFailureEntryKey(file, fuzzer.name, modeName ?? "default"),
+            mode: modeName ?? "default",
+            seed: firstFailureSeed,
+            reproCommand: buildFuzzReproCommand(file, firstFailureSeed, modeName ?? "default", 1),
+            error: fuzzer.failure?.message ||
+                `fuzz failure in ${fuzzer.name} after ${fuzzer.runs} runs`,
+            stdout: passthrough.stdout,
+            stderr: "",
+            failure: fuzzer.failure,
+            failures: fuzzer.failures,
+        });
+        crashFiles.push(crash.jsonPath);
+        fuzzer.crashFile = crash.jsonPath;
+    }
     return {
         file,
         target: path.basename(file),
         modeName: modeName ?? "default",
         runs: report.fuzzers.reduce((sum, item) => sum + item.runs, 0),
         crashes: report.fuzzers.reduce((sum, item) => sum + item.crashed, 0),
-        crashFiles: [],
+        crashFiles,
         seed: config.seed,
         time: Date.now() - startedAt,
         buildTime,
@@ -130,6 +156,23 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
         fuzzers: report.fuzzers,
     };
 }
+function buildFuzzReproCommand(file, seed, modeName, runs) {
+    const modeArg = modeName != "default" ? ` --mode ${modeName}` : "";
+    const runsArg = typeof runs == "number" ? ` --runs ${runs}` : "";
+    return `ast fuzz ${file}${modeArg} --seed ${seed}${runsArg}`;
+}
+function buildFuzzFailureEntryKey(file, name, modeName) {
+    return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}.${sanitizeEntryName(name)}`;
+}
+function buildFuzzCrashEntryKey(file, modeName) {
+    return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}`;
+}
+function sanitizeEntryName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "fuzzer";
+}
 function captureFrames(onFrame) {
     const originalWrite = process.stdout.write.bind(process.stdout);
     const originalRead = typeof process.stdin.read == "function"

package/bin/commands/run-core.js

@@ -1286,26 +1286,22 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
     let report = null;
     let parseError = null;
     let stderrBuffer = "";
+    let stderrPendingLine = "";
     let stdoutBuffer = "";
-    let suppressTraceWarningLine = false;
     let spawnError = null;
     child.on("error", (error) => {
         spawnError = error;
     });
     child.stderr.on("data", (chunk) => {
-        stderrBuffer += chunk.toString("utf8");
-        let newline = stderrBuffer.indexOf("\n");
+        stderrPendingLine += chunk.toString("utf8");
+        let newline = stderrPendingLine.indexOf("\n");
         while (newline >= 0) {
-            const line = stderrBuffer.slice(0, newline + 1);
-            stderrBuffer = stderrBuffer.slice(newline + 1);
-            if (shouldSuppressWasiWarningLine(line, suppressTraceWarningLine)) {
-                suppressTraceWarningLine = true;
+            const line = stderrPendingLine.slice(0, newline + 1);
+            stderrPendingLine = stderrPendingLine.slice(newline + 1);
+            if (!shouldSuppressWasiWarningLine(line)) {
+                stderrBuffer += line;
             }
-            else {
-                suppressTraceWarningLine = false;
-                process.stderr.write(line);
-            }
-            newline = stderrBuffer.indexOf("\n");
+            newline = stderrPendingLine.indexOf("\n");
         }
     });
     class TestChannel extends Channel {
@@ -1409,55 +1405,138 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
     const code = await new Promise((resolve) => {
         child.on("close", (exitCode) => resolve(exitCode ?? 1));
     });
-    if (stderrBuffer.length) {
-        if (!shouldSuppressWasiWarningLine(stderrBuffer, suppressTraceWarningLine)) {
-            process.stderr.write(stderrBuffer);
-        }
+    if (stderrPendingLine.length && !shouldSuppressWasiWarningLine(stderrPendingLine)) {
+        stderrBuffer += stderrPendingLine;
     }
     if (spawnError) {
+        const errorText = spawnError.stack ?? spawnError.message;
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
             mode: modeName ?? "default",
-            error: spawnError.stack ?? spawnError.message,
+            error: errorText,
             stdout: stdoutBuffer,
             stderr: stderrBuffer,
         });
-        throw spawnError;
+        return createRuntimeFailureReport(specFile, modeName, "failed to start test runtime", errorText, stdoutBuffer, stderrBuffer);
     }
     if (parseError) {
+        const errorText = `could not parse report payload: ${parseError}`;
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
             mode: modeName ?? "default",
-            error: `could not parse report payload: ${parseError}`,
+            error: errorText,
             stdout: stdoutBuffer,
             stderr: stderrBuffer,
         });
-        throw new Error(`could not parse report payload: ${parseError}`);
+        return createRuntimeFailureReport(specFile, modeName, "runtime returned an invalid report payload", errorText, stdoutBuffer, stderrBuffer);
     }
     if (!report) {
+        const errorText = "missing report payload from test runtime";
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
             mode: modeName ?? "default",
-            error: "missing report payload from test runtime",
+            error: errorText,
             stdout: stdoutBuffer,
             stderr: stderrBuffer,
         });
-        throw new Error("missing report payload from test runtime");
+        return createRuntimeFailureReport(specFile, modeName, "test runtime exited without sending a report", errorText, stdoutBuffer, stderrBuffer);
     }
-    if (code !== 0) {
-        // Let report determine failure counts, but keep non-zero child exits visible.
-        process.stderr.write(chalk.dim(`child process exited with code ${code}\n`));
+    if (code !== 0 || hasMeaningfulRuntimeOutput(stderrBuffer)) {
+        const errorParts = [];
+        if (code !== 0) {
+            errorParts.push(`child process exited with code ${code}`);
+        }
+        const stderrText = normalizeRuntimeOutput(stderrBuffer);
+        if (stderrText.length) {
+            errorParts.push(stderrText);
+        }
+        const errorText = errorParts.join("\n\n");
+        persistCrashRecord(crashDir, {
+            kind: "test",
+            file: specFile,
+            mode: modeName ?? "default",
+            error: errorText || "runtime reported an unknown error",
+            stdout: stdoutBuffer,
+            stderr: stderrBuffer,
+        });
+        return appendRuntimeFailureReport(report, specFile, modeName, code !== 0
+            ? `test runtime failed with exit code ${code}`
+            : "test runtime wrote to stderr", errorText, stdoutBuffer, stderrBuffer);
     }
     return report;
 }
-function shouldSuppressWasiWarningLine(line, suppressTraceWarningLine) {
+function createRuntimeFailureReport(specFile, modeName, title, details, stdout, stderr) {
+    return appendRuntimeFailureReport({
+        suites: [],
+        coverage: {
+            total: 0,
+            covered: 0,
+            uncovered: 0,
+            percent: 100,
+            points: [],
+        },
+    }, specFile, modeName, title, details, stdout, stderr);
+}
+function appendRuntimeFailureReport(report, specFile, modeName, title, details, stdout, stderr) {
+    const suites = Array.isArray(report?.suites) ? report.suites : [];
+    suites.push({
+        file: specFile,
+        description: path.basename(specFile),
+        depth: 0,
+        kind: "runtime-error",
+        verdict: "fail",
+        time: {
+            start: 0,
+            end: 0,
+        },
+        suites: [],
+        logs: [],
+        tests: [
+            {
+                order: 0,
+                type: "runtime-error",
+                verdict: "fail",
+                left: null,
+                right: null,
+                instr: title,
+                message: formatRuntimeFailureMessage(details, stdout, stderr),
+                location: "",
+            },
+        ],
+        modeName: modeName ?? "default",
+    });
+    report.suites = suites;
+    return report;
+}
+function formatRuntimeFailureMessage(details, stdout, stderr) {
+    const parts = [];
+    const normalizedDetails = normalizeRuntimeOutput(details);
+    const normalizedStderr = normalizeRuntimeOutput(stderr);
+    const normalizedStdout = normalizeRuntimeOutput(stdout);
+    if (normalizedDetails.length)
+        parts.push(normalizedDetails);
+    if (normalizedStderr.length && normalizedStderr !== normalizedDetails) {
+        parts.push(`stderr:\n${normalizedStderr}`);
+    }
+    if (normalizedStdout.length) {
+        parts.push(`stdout:\n${normalizedStdout}`);
+    }
+    return parts.join("\n\n");
+}
+function normalizeRuntimeOutput(value) {
+    return value.replace(/\r\n/g, "\n").trim();
+}
+function hasMeaningfulRuntimeOutput(value) {
+    return normalizeRuntimeOutput(value).length > 0;
+}
+function shouldSuppressWasiWarningLine(line) {
     if (line.includes("ExperimentalWarning: WASI is an experimental feature")) {
         return true;
     }
-    if (suppressTraceWarningLine && line.includes("--trace-warnings")) {
+    if (line.includes("--trace-warnings")) {
         return true;
     }
     return false;
@@ -1506,6 +1585,7 @@ function readFileReport(stats, fileReport) {
 }
 function readSuite(stats, suite, file, modeName) {
     const suiteAny = suite;
+    const kind = String(suiteAny.kind ?? "");
     let verdict = normalizeVerdict(suiteAny.verdict);
     const time = suiteAny.time;
     const start = Number(time?.start ?? 0);
@@ -1533,6 +1613,20 @@ function readSuite(stats, suite, file, modeName) {
             stats.skippedTests++;
         }
     }
+    if (isTestCaseSuiteKind(kind)) {
+        if (!subSuites.length && !tests.length) {
+            if (verdict == "fail") {
+                stats.failedTests++;
+            }
+            else if (verdict == "ok") {
+                stats.passedTests++;
+            }
+            else if (verdict == "skip") {
+                stats.skippedTests++;
+            }
+        }
+        return verdict;
+    }
     if (verdict == "fail") {
         stats.failedSuites++;
         stats.failedEntries.push({
@@ -1549,6 +1643,15 @@ function readSuite(stats, suite, file, modeName) {
     }
     return verdict;
 }
+function isTestCaseSuiteKind(kind) {
+    return (kind == "test" ||
+        kind == "it" ||
+        kind == "only" ||
+        kind == "xtest" ||
+        kind == "xit" ||
+        kind == "xonly" ||
+        kind == "todo");
+}
 function normalizeVerdict(value) {
     const verdict = String(value ?? "none");
     if (verdict == "fail")

package/bin/commands/run.js

@@ -13,6 +13,7 @@ export async function executeRunCommand(rawArgs, flags, configPath, selectedMode
         ...deps.resolveParallelJobs(rawArgs, "run"),
         coverage: featureToggles.coverage,
         browser: deps.resolveBrowserOverride(rawArgs, "run"),
+        reporterPath: deps.resolveReporterOverride(rawArgs, "run"),
     };
     const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
     if (listFlags.list || listFlags.listModes) {

package/bin/commands/test.js

@@ -16,6 +16,7 @@ export async function executeTestCommand(rawArgs, flags, configPath, selectedMod
         ...deps.resolveParallelJobs(rawArgs, "test"),
         coverage: featureToggles.coverage,
         browser: deps.resolveBrowserOverride(rawArgs, "test"),
+        reporterPath: deps.resolveReporterOverride(rawArgs, "test"),
     };
     const fuzzEnabled = flags.includes("--fuzz");
     const fuzzOverrides = deps.resolveFuzzOverrides(rawArgs, "test");

package/bin/crash-store.js

@@ -1,7 +1,7 @@
 import { mkdirSync, writeFileSync } from "fs";
 import * as path from "path";
 export function persistCrashRecord(rootDir, record) {
-    const entry = crashEntryKey(record.file);
+    const entry = record.entryKey?.length ? record.entryKey : crashEntryKey(record.file);
     const dir = path.resolve(process.cwd(), rootDir);
     mkdirSync(dir, { recursive: true });
     const jsonPath = path.join(dir, `${entry}.json`);
@@ -53,6 +53,17 @@ function buildCrashLog(payload) {
             lines.push(`message: ${payload.failure.message}`);
         }
     }
+    if (payload.failures?.length) {
+        lines.push("");
+        lines.push("[fuzz-failures]");
+        for (const failure of payload.failures) {
+            lines.push(`run: ${failure.run}`);
+            lines.push(`seed: ${failure.seed}`);
+            if (failure.input)
+                lines.push(`input: ${JSON.stringify(failure.input)}`);
+            lines.push("");
+        }
+    }
     lines.push("");
     lines.push("[stdout]");
     lines.push(payload.stdout ?? "");

package/bin/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import chalk from "chalk";
-import { build, formatInvocation as formatBuildInvocation, getBuildInvocationPreview, } from "./commands/build.js";
+import { build, formatInvocation as formatBuildInvocation, getBuildInvocationPreview, getBuildReuseInfo, } from "./commands/build.js";
 import { createRunReporter, run } from "./commands/run.js";
 import { executeBuildCommand } from "./commands/build.js";
 import { executeRunCommand } from "./commands/run.js";
@@ -14,7 +14,7 @@ import * as path from "path";
 import { spawnSync } from "child_process";
 import { glob } from "glob";
 import { createInterface } from "readline";
-import { existsSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync } from "fs";
 import { availableParallelism, cpus } from "os";
 import { BuildWorkerPool } from "./build-worker-pool.js";
 const _args = process.argv.slice(2);
@@ -66,6 +66,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveFeatureToggles,
                 resolveParallelJobs,
                 resolveBrowserOverride,
+                resolveReporterOverride,
                 resolveExecutionModes,
                 listExecutionPlan,
                 runRuntimeModes,
@@ -81,6 +82,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveFeatureToggles,
                 resolveParallelJobs,
                 resolveBrowserOverride,
+                resolveReporterOverride,
                 resolveFuzzOverrides,
                 resolveExecutionModes,
                 listExecutionPlan,
@@ -400,7 +402,6 @@ function resolveCommandArgs(rawArgs, command) {
         }
         if (arg == "--runs" ||
             arg == "--seed" ||
-            arg == "--parallel" ||
             arg == "--jobs" ||
             arg == "--build-jobs" ||
             arg == "--run-jobs" ||
@@ -410,6 +411,9 @@ function resolveCommandArgs(rawArgs, command) {
             i++;
             continue;
         }
+        if (arg == "--parallel") {
+            continue;
+        }
         if (arg.startsWith("--runs=") ||
             arg.startsWith("--seed=") ||
             arg.startsWith("--jobs=") ||
@@ -577,6 +581,32 @@ function resolveBrowserOverride(rawArgs, command) {
     }
     return undefined;
 }
+function resolveReporterOverride(rawArgs, command) {
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == command)
+                seenCommand = true;
+            continue;
+        }
+        if (arg == "--reporter") {
+            const next = rawArgs[i + 1];
+            if (next && !next.startsWith("-")) {
+                return next;
+            }
+            return undefined;
+        }
+        if (arg.startsWith("--reporter=")) {
+            const value = arg.slice("--reporter=".length);
+            return value.length ? value : undefined;
+        }
+        if (arg == "--tap") {
+            return "tap";
+        }
+    }
+    return undefined;
+}
 function resolveJobs(rawArgs, command) {
     let seenCommand = false;
     let parallel = false;
@@ -731,9 +761,9 @@ function createBufferedStream() {
         },
     };
 }
-async function createBufferedReporter(configPath, modeName) {
+async function createBufferedReporter(configPath, reporterPath, modeName) {
     const stream = createBufferedStream();
-    const session = await createRunReporter(configPath, undefined, modeName, {
+    const session = await createRunReporter(configPath, reporterPath, modeName, {
         stdout: stream,
         stderr: stream,
     });
@@ -882,6 +912,32 @@ function resolveCommandTokens(rawArgs, command) {
     }
     return values;
 }
+async function buildFileForMode(cache, args) {
+    const reuse = await getBuildReuseInfo(args.configPath, args.file, args.modeName, args.buildFeatureToggles);
+    if (reuse) {
+        const source = cache.get(reuse.signature);
+        if (source && source != reuse.outFile && existsSync(source)) {
+            mkdirSync(path.dirname(reuse.outFile), { recursive: true });
+            copyFileSync(source, reuse.outFile);
+            return true;
+        }
+    }
+    if (args.buildPool) {
+        await args.buildPool.buildFileMode({
+            configPath: args.configPath,
+            file: args.file,
+            modeName: args.modeName,
+            featureToggles: args.buildFeatureToggles,
+        });
+    }
+    else {
+        await build(args.configPath, [args.file], args.modeName, args.buildFeatureToggles);
+    }
+    if (reuse) {
+        cache.set(reuse.signature, reuse.outFile);
+    }
+    return false;
+}
 async function runTestSequential(runFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, allowNoSpecFiles = false, modeName, reporterOverride, emitRunComplete = true) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
@@ -889,7 +945,7 @@ async function runTestSequential(runFlags, configPath, selectors, buildFeatureTo
             throw await buildNoTestFilesMatchedError(configPath, selectors);
         }
     }
-    const reporterSession = await createRunReporter(configPath, undefined, modeName);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath, modeName);
     const reporter = reporterOverride ?? reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -963,17 +1019,19 @@ async function runBuildModes(configPath, selectors, modes, buildFeatureToggles,
     const loadedConfig = loadConfig(resolvedConfigPath, true);
     const allStartedAt = Date.now();
     let builtCount = 0;
+    const buildReuseCache = new Map();
     for (const modeName of modes) {
         const startedAt = Date.now();
         if (effective.buildJobs > 1) {
             const pool = new BuildWorkerPool(effective.buildJobs);
             try {
                 await runOrderedPool(files, effective.buildJobs, async (file) => {
-                    await pool.buildFileMode({
+                    await buildFileForMode(buildReuseCache, {
                         configPath,
                         file,
                         modeName,
-                        featureToggles: buildFeatureToggles,
+                        buildFeatureToggles,
+                        buildPool: pool,
                     });
                 });
             }
@@ -982,7 +1040,14 @@ async function runBuildModes(configPath, selectors, modes, buildFeatureToggles,
             }
         }
         else {
-            await build(configPath, selectors, modeName, buildFeatureToggles);
+            for (const file of files) {
+                await buildFileForMode(buildReuseCache, {
+                    configPath,
+                    file,
+                    modeName,
+                    buildFeatureToggles,
+                });
+            }
         }
         builtCount += files.length;
         const active = applyMode(loadedConfig, modeName).config;
@@ -1022,6 +1087,7 @@ async function runRuntimeModes(runFlags, configPath, selectors, modes) {
     const buildCommandsByFile = await previewBuildCommands(configPath, selectors, modes[0], {});
     for (const modeName of modes) {
         const result = await run(effectiveRunFlags, configPath, selectors, false, {
+            reporterPath: effectiveRunFlags.reporterPath,
             modeName,
             modeSummaryTotal,
             modeSummaryExecuted: 1,
@@ -1063,11 +1129,13 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
     }));
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     const buildIntervals = [];
+    const buildReuseCache = new Map();
     for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
         const file = files[fileIndex];
         const fileName = path.basename(file);
         const fileResults = [];
         const modeTimes = modes.map(() => "...");
+        const buildReuseCache = new Map();
         if (liveMatrix) {
             renderMatrixLiveLine(fileName, modeLabels, modeTimes, showPerModeTimes);
         }
@@ -1104,7 +1172,9 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
                 throw error;
             }
         }
-        renderMatrixFileResult(fileName, modeLabels, fileResults, modeTimes, liveMatrix, showPerModeTimes);
+        if (reporterSession.reporterKind == "default") {
+            renderMatrixFileResult(fileName, modeLabels, fileResults, modeTimes, liveMatrix, showPerModeTimes);
+        }
         const verdict = resolveMatrixVerdict(fileResults);
         if (verdict == "fail") {
             fileState[fileIndex].failed = true;
@@ -1158,7 +1228,7 @@ async function runTestModes(runFlags, configPath, selectors, modes, buildFeature
     }
     let failed = false;
     for (const modeName of modes) {
-        const reporterSession = await createRunReporter(configPath, undefined, modeName);
+        const reporterSession = await createRunReporter(configPath, effectiveRunFlags.reporterPath, modeName);
         const modeResult = await runTestSequential(effectiveRunFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, modeName, reporterSession.reporter, !fuzzEnabled);
         if (modeResult.failed)
             failed = true;
@@ -1228,6 +1298,7 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
         const fileName = path.basename(file);
         const fileResults = [];
         const modeTimes = modes.map(() => "...");
+        const buildReuseCache = new Map();
         if (liveMatrix) {
             renderMatrixLiveLine(fileName, modeLabels, modeTimes, showPerModeTimes);
         }
@@ -1235,7 +1306,12 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
             const modeName = modes[i];
             try {
                 const buildStartedAt = Date.now();
-                await build(configPath, [file], modeName, buildFeatureToggles);
+                await buildFileForMode(buildReuseCache, {
+                    configPath,
+                    file,
+                    modeName,
+                    buildFeatureToggles,
+                });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
                 const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
@@ -1267,7 +1343,9 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
                 throw error;
             }
         }
-        renderMatrixFileResult(fileName, modeLabels, fileResults, modeTimes, liveMatrix, showPerModeTimes);
+        if (reporterSession.reporterKind == "default") {
+            renderMatrixFileResult(fileName, modeLabels, fileResults, modeTimes, liveMatrix, showPerModeTimes);
+        }
         const verdict = resolveMatrixVerdict(fileResults);
         if (verdict == "fail") {
             fileState[fileIndex].failed = true;
@@ -1330,7 +1408,7 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeNam
     if (!files.length) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
     }
-    const reporterSession = await createRunReporter(configPath, undefined, modeName);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath, modeName);
     const reporter = reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -1342,15 +1420,20 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeNam
     });
     const buildCommandsByFile = await previewBuildCommands(configPath, selectors, modeName, {});
     const results = new Array(files.length);
-    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const useQueueDisplay = reporterSession.reporterKind == "default";
+    const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
     const runLimit = createAsyncLimiter(runFlags.runJobs);
     const poolWidth = Math.max(runFlags.buildJobs, runFlags.runJobs);
     await runOrderedPool(files, poolWidth, async (file, index) => {
-        const token = renderQueuedFileStart(queueDisplay, path.basename(file));
-        const buffered = await createBufferedReporter(configPath, modeName);
+        const token = useQueueDisplay
+            ? renderQueuedFileStart(queueDisplay, path.basename(file))
+            : null;
+        const buffered = useQueueDisplay
+            ? await createBufferedReporter(configPath, runFlags.reporterPath, modeName)
+            : null;
         const result = await runLimit(() => run({ ...runFlags, clean: true }, configPath, [file], false, {
-            reporter: buffered.reporter,
-            reporterKind: buffered.reporterKind,
+            reporter: buffered?.reporter,
+            reporterKind: buffered?.reporterKind,
             modeName,
             emitRunComplete: false,
             fileSummaryTotal: 1,
@@ -1358,9 +1441,11 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeNam
             modeSummaryExecuted: 1,
             buildCommandsByFile: { [file]: buildCommandsByFile[file] ?? "" },
         }));
-        buffered.reporter.flush?.();
+        buffered?.reporter.flush?.();
         results[index] = result;
-        queueDisplay.complete(token, buffered.output());
+        if (buffered && token != null) {
+            queueDisplay.complete(token, buffered.output());
+        }
     });
     queueDisplay.flush();
     const summary = aggregateRunResults(results);
@@ -1384,7 +1469,7 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes,
     if (!files.length) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
     }
-    const reporterSession = await createRunReporter(configPath);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath);
     const reporter = reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -1399,23 +1484,29 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes,
     const showPerModeTimes = Boolean(runFlags.verbose);
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     const ordered = new Array(files.length);
-    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const useQueueDisplay = reporterSession.reporterKind == "default";
+    const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
     const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
     const buildPool = new BuildWorkerPool(runFlags.buildJobs);
     const buildIntervals = [];
     try {
         await runOrderedPool(files, poolWidth, async (file, fileIndex) => {
             const fileName = path.basename(file);
-            const token = renderQueuedFileStart(queueDisplay, fileName);
+            const token = useQueueDisplay
+                ? renderQueuedFileStart(queueDisplay, fileName)
+                : null;
             const fileResults = [];
             const modeTimes = modes.map(() => "...");
+            const buildReuseCache = new Map();
             for (let i = 0; i < modes.length; i++) {
                 const modeName = modes[i];
                 const buildStartedAt = Date.now();
-                await buildPool.buildFileMode({
+                await buildFileForMode(buildReuseCache, {
                     configPath,
                     file,
                     modeName,
+                    buildFeatureToggles: {},
+                    buildPool,
                 });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, {});
@@ -1434,7 +1525,9 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes,
                 fileResults.push(result);
             }
             ordered[fileIndex] = { fileName, fileResults, modeTimes };
-            queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+            if (token != null) {
+                queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+            }
         });
     }
     finally {
@@ -1481,7 +1574,7 @@ async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatu
     if (!files.length && !fuzzEnabled) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
     }
-    const reporterSession = await createRunReporter(configPath, undefined, modeName);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath, modeName);
     const reporter = reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -1493,37 +1586,45 @@ async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatu
     });
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     const results = new Array(files.length);
-    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const useQueueDisplay = reporterSession.reporterKind == "default";
+    const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
     const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
     const buildIntervals = [];
     if (files.length) {
         const buildPool = new BuildWorkerPool(runFlags.buildJobs);
         try {
             await runOrderedPool(files, poolWidth, async (file, index) => {
-                const token = renderQueuedFileStart(queueDisplay, path.basename(file));
+                const token = useQueueDisplay
+                    ? renderQueuedFileStart(queueDisplay, path.basename(file))
+                    : null;
                 const buildStartedAt = Date.now();
-                await buildPool.buildFileMode({
+                await buildFileForMode(new Map(), {
                     configPath,
                     file,
                     modeName,
-                    featureToggles: buildFeatureToggles,
+                    buildFeatureToggles,
+                    buildPool,
                 });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
                 const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
-                const buffered = await createBufferedReporter(configPath, modeName);
+                const buffered = useQueueDisplay
+                    ? await createBufferedReporter(configPath, runFlags.reporterPath, modeName)
+                    : null;
                 const result = await run({ ...runFlags, clean: true }, configPath, [file], false, {
-                    reporter: buffered.reporter,
-                    reporterKind: buffered.reporterKind,
+                    reporter: buffered?.reporter,
+                    reporterKind: buffered?.reporterKind,
                     emitRunComplete: false,
                     logFileName: `test.${artifactKey}.log.json`,
                     coverageFileName: `coverage.${artifactKey}.log.json`,
                     buildCommand: formatBuildInvocation(buildInvocation),
                     modeName,
                 });
-                buffered.reporter.flush?.();
+                buffered?.reporter.flush?.();
                 results[index] = result;
-                queueDisplay.complete(token, buffered.output());
+                if (buffered && token != null) {
+                    queueDisplay.complete(token, buffered.output());
+                }
             });
         }
         finally {
@@ -1572,7 +1673,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
             throw await buildNoTestFilesMatchedError(configPath, selectors, true);
         }
     }
-    const reporterSession = await createRunReporter(configPath);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath);
     const reporter = reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -1587,24 +1688,29 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
     const showPerModeTimes = Boolean(runFlags.verbose);
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     const ordered = new Array(files.length);
-    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const useQueueDisplay = reporterSession.reporterKind == "default";
+    const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
     const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
     const buildPool = new BuildWorkerPool(runFlags.buildJobs);
     const buildIntervals = [];
     try {
         await runOrderedPool(files, poolWidth, async (file, fileIndex) => {
             const fileName = path.basename(file);
-            const token = renderQueuedFileStart(queueDisplay, fileName);
+            const token = useQueueDisplay
+                ? renderQueuedFileStart(queueDisplay, fileName)
+                : null;
             const fileResults = [];
             const modeTimes = modes.map(() => "...");
+            const buildReuseCache = new Map();
             for (let i = 0; i < modes.length; i++) {
                 const modeName = modes[i];
                 const buildStartedAt = Date.now();
-                await buildPool.buildFileMode({
+                await buildFileForMode(buildReuseCache, {
                     configPath,
                     file,
                     modeName,
-                    featureToggles: buildFeatureToggles,
+                    buildFeatureToggles,
+                    buildPool,
                 });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
@@ -1623,7 +1729,9 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
                 fileResults.push(result);
             }
             ordered[fileIndex] = { fileName, fileResults, modeTimes };
-            queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+            if (token != null) {
+                queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+            }
         });
     }
     finally {

package/bin/reporters/default.js

@@ -360,7 +360,19 @@ function renderFailedFuzzers(results) {
                 console.log(chalk.dim(`Runs: ${fuzzer.passed + fuzzer.failed + fuzzer.crashed} completed (${fuzzer.passed} passed, ${fuzzer.failed} failed, ${fuzzer.crashed} crashed)`));
                 console.log(chalk.dim(`Repro: ${repro}`));
                 console.log(chalk.dim(`Seed: ${modeResult.seed}`));
-                if (modeResult.crashFiles.length) {
+                if (fuzzer.failures?.length) {
+                    console.log(chalk.dim(`Failing seeds: ${formatFailingSeeds(fuzzer)}`));
+                    for (const failure of fuzzer.failures) {
+                        console.log(chalk.dim(`Repro ${failure.run + 1}: ${buildFuzzReproCommand(relativeFile, failure.seed, modeResult.modeName, 1)}`));
+                        if (failure.input) {
+                            console.log(chalk.dim(`Input ${failure.run + 1}: ${JSON.stringify(failure.input)}`));
+                        }
+                    }
+                }
+                if (fuzzer.crashFile?.length) {
+                    console.log(chalk.dim(`Crash: ${fuzzer.crashFile}`));
+                }
+                else if (modeResult.crashFiles.length) {
                     console.log(chalk.dim(`Crash: ${modeResult.crashFiles[0]}`));
                 }
                 console.log("");
@@ -392,9 +404,13 @@ function averageFuzzModeTime(results) {
         return 0;
     return results.reduce((sum, result) => sum + result.time, 0) / results.length;
 }
-function buildFuzzReproCommand(file, seed, modeName) {
+function buildFuzzReproCommand(file, seed, modeName, runs) {
     const modeArg = modeName != "default" ? ` --mode ${modeName}` : "";
-    return `ast fuzz ${file}${modeArg} --seed ${seed}`;
+    const runsArg = typeof runs == "number" ? ` --runs ${runs}` : "";
+    return `ast fuzz ${file}${modeArg} --seed ${seed}${runsArg}`;
+}
+function formatFailingSeeds(fuzzer) {
+    return (fuzzer.failures ?? []).map((failure) => String(failure.seed)).join(", ");
 }
 function toRelativeResultPath(file) {
     const relative = path.relative(process.cwd(), path.resolve(process.cwd(), file));
@@ -465,12 +481,30 @@ function collectSuiteFailures(suite, file, path, printed) {
         const loc = String(test.location ?? "");
         const where = loc.length ? `${file}:${loc}` : file;
         const modeName = String(suiteAny.modeName ?? "");
-        const dedupeKey = `${file}::${modeName}::${title}::${String(test.left)}::${String(test.right)}`;
+        const message = String(test.message ?? "");
+        const dedupeKey = `${file}::${modeName}::${title}::${String(test.left)}::${String(test.right)}::${message}`;
         if (printed.has(dedupeKey))
             continue;
         printed.add(dedupeKey);
         const left = JSON.stringify(test.left);
         const right = JSON.stringify(test.right);
+        if (left == "null" && right == "null") {
+            console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(title)} ${chalk.dim("(" + where + ")")}`);
+            if (modeName.length) {
+                console.log(chalk.dim(`Mode: ${modeName}`));
+            }
+            const normalizedMessage = normalizeFailureMessage(message);
+            if (normalizedMessage.length) {
+                for (const line of normalizedMessage.split("\n")) {
+                    console.log(chalk.dim(line));
+                }
+            }
+            else {
+                console.log(chalk.dim("runtime error"));
+            }
+            console.log("");
+            continue;
+        }
         const diffResult = diff(left, right);
         let expected = "";
         for (const res of diffResult.diff) {
@@ -506,6 +540,9 @@ function collectSuiteFailures(suite, file, path, printed) {
         collectSuiteFailures(sub, file, nextPath, printed);
     }
 }
+function normalizeFailureMessage(message) {
+    return message.replace(/\r\n/g, "\n").trim();
+}
 function renderSnapshotSummary(snapshotSummary, leadingGap = true) {
     if (leadingGap) {
         console.log("");

package/bin/reporters/tap.js

@@ -221,10 +221,13 @@ function buildFuzzerFailureMessage(result, fuzzer) {
     if (fuzzer.crashed > 0 || result.crashes > 0) {
         return buildFuzzMessage(result.runs, result.seed, result.crashFiles[0]);
     }
+    const failureSeeds = fuzzer.failures?.length
+        ? `, failing seeds ${fuzzer.failures.map((failure) => failure.seed).join(", ")}`
+        : "";
     if (fuzzer.failure?.message?.length) {
-        return `${fuzzer.failure.message} (runs ${fuzzer.runs}, seed ${result.seed})`;
+        return `${fuzzer.failure.message} (runs ${fuzzer.runs}, seed ${result.seed}${failureSeeds})`;
     }
-    return `fuzz failed after ${fuzzer.runs} runs (seed ${result.seed})`;
+    return `fuzz failed after ${fuzzer.runs} runs (seed ${result.seed}${failureSeeds})`;
 }
 function buildFuzzMessage(runs, seed, crashFile) {
     const crashSuffix = crashFile?.length ? `, crash ${crashFile}` : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -64,9 +64,9 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node ./bin/index.js test",
+    "test": "node ./bin/index.js test --parallel",
+    "test:ci": "node ./bin/index.js test --parallel --tap --config ./as-test.ci.config.json",
     "fuzz": "node ./bin/index.js fuzz",
-    "test:ci": "node ./bin/index.js test --tap --config ./as-test.ci.config.json",
     "test:examples": "npm --prefix ./examples run test",
     "ci:act": "bash ./tools/act.sh push",
     "ci:act:pr": "bash ./tools/act.sh pull_request",