as-test 1.0.5 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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

package/README.md

@@ -231,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/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/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/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));

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.5",
+  "version": "1.0.6",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",