as-test 1.0.5 → 1.0.7

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Change Log
 
+## Unreleased
+
+## 2026-03-31 - v1.0.7
+
+### Coverage
+
+- feat: make CLI coverage output easier to scan with a summarized coverage block, per-file breakdown, grouped uncovered points, clickable `file:line:column` locations, trimmed source snippets, aligned gap columns, source-aware labels such as `Function`, `Method`, `Constructor`, `Property`, and `Call`, and coverage-point ignore rules for labels, names, locations, and snippets.
+
+### Fuzzing
+
+- feat: allow `fuzz(...)` and `xfuzz(...)` targets to override their own operation count with an optional third argument, so one file can mix short smoke fuzzers and heavier targets without changing the global `fuzz.runs` config.
+- feat: make `--runs` / `--fuzz-runs` accept absolute and relative overrides such as `500`, `1.5x`, `+10%`, and `+100000`, applying them to each fuzzer's effective run count for that command.
+
+## 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

@@ -83,6 +83,23 @@ Minimal `as-test.config.json`:
 }
 ```
 
+Coverage point filtering is configurable when you want to ignore known-noisy gaps:
+
+```json
+{
+  "coverage": {
+    "enabled": true,
+    "include": ["assembly/src/**/*.ts"],
+    "ignore": {
+      "labels": ["Call"],
+      "names": ["panic", "serialize"],
+      "locations": ["assembly/src/fuzz.ts:38:*"],
+      "snippets": ["*message: string*"]
+    }
+  }
+}
+```
+
 ## Writing Tests
 
 Tests usually live in `assembly/__tests__/*.spec.ts`.
@@ -218,6 +235,23 @@ fuzz("bounded integer addition", (left: i32, right: i32): bool => {
 });
 ```
 
+Pass a third argument to override the operation count for one target without changing the global fuzz config:
+
+```ts
+fuzz("hot path stays stable", (): void => {
+  expect(1 + 1).toBe(2);
+}, 250);
+```
+
+You can still override fuzz runs from the CLI when you want to force a different count for the current command:
+
+```bash
+npx ast fuzz --runs 500
+npx ast fuzz --runs 1.5x
+npx ast fuzz --runs +10%
+npx ast fuzz --runs +100000
+```
+
 If you used `npx ast init` with a fuzzer example, the config is already there. Otherwise, add a `fuzz` block to `as-test.config.json` so `npx ast fuzz` knows what to build:
 
 ```json
@@ -231,6 +265,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/as-test.config.schema.json

@@ -121,6 +121,45 @@
                 "type": "string"
               },
               "default": []
+            },
+            "ignore": {
+              "type": "object",
+              "description": "Ignore specific coverage points by derived label, symbol name, location, or source snippet.",
+              "additionalProperties": true,
+              "properties": {
+                "labels": {
+                  "type": "array",
+                  "description": "Ignore all points whose rendered label matches, such as Call, Method, Constructor, Property, or Function.",
+                  "items": {
+                    "type": "string"
+                  },
+                  "default": []
+                },
+                "names": {
+                  "type": "array",
+                  "description": "Ignore declarations or calls whose extracted symbol name matches a glob pattern.",
+                  "items": {
+                    "type": "string"
+                  },
+                  "default": []
+                },
+                "locations": {
+                  "type": "array",
+                  "description": "Ignore points whose file:line:column location matches a glob pattern.",
+                  "items": {
+                    "type": "string"
+                  },
+                  "default": []
+                },
+                "snippets": {
+                  "type": "array",
+                  "description": "Ignore points whose trimmed source snippet matches a glob pattern.",
+                  "items": {
+                    "type": "string"
+                  },
+                  "default": []
+                }
+              }
             }
           }
         }

package/assembly/index.ts

@@ -169,8 +169,9 @@ export function xit(description: string, callback: () => void): void {
 export function fuzz<T extends Function>(
   description: string,
   callback: T,
+  operations: i32 = 0,
 ): FuzzerBase {
-  const entry = createFuzzer(description, callback);
+  const entry = createFuzzer(description, callback, false, operations);
   entryFuzzers.push(entry);
   return entry;
 }
@@ -178,8 +179,9 @@ export function fuzz<T extends Function>(
 export function xfuzz<T extends Function>(
   description: string,
   callback: T,
+  operations: i32 = 0,
 ): FuzzerBase {
-  const entry = createFuzzer(description, callback, true);
+  const entry = createFuzzer(description, callback, true, operations);
   entryFuzzers.push(entry);
   return entry;
 }
@@ -421,6 +423,8 @@ function containsOnlySuites(values: Suite[]): bool {
 class FuzzConfig {
   runs: i32 = 1000;
   seed: u64 = 1337;
+  runsOverrideKind: i32 = 0;
+  runsOverrideValue: f64 = 0.0;
 }
 
 class FuzzReport {
@@ -444,7 +448,10 @@ function runFuzzers(): void {
   for (let i = 0; i < entryFuzzers.length; i++) {
     const fuzzer = unchecked(entryFuzzers[i]);
     prepareFuzzIteration();
-    const result = fuzzer.run(config.seed, config.runs);
+    const result = fuzzer.run(
+      config.seed,
+      resolveFuzzerRuns(fuzzer, config),
+    );
     report.fuzzers.push(result);
   }
   sendReport(report.serialize());
@@ -455,9 +462,31 @@ function requestFuzzConfig(): FuzzConfig {
   const reply = requestHostFuzzConfig();
   out.runs = reply.runs;
   out.seed = reply.seed;
+  out.runsOverrideKind = reply.runsOverrideKind;
+  out.runsOverrideValue = reply.runsOverrideValue;
   return out;
 }
 
+function resolveFuzzerRuns(fuzzer: FuzzerBase, config: FuzzConfig): i32 {
+  const baseRuns = fuzzer.runsOr(config.runs);
+  const resolved = applyFuzzRunsOverride(
+    baseRuns,
+    config.runsOverrideKind,
+    config.runsOverrideValue,
+  );
+  return resolved > 0 ? resolved : 1;
+}
+
+function applyFuzzRunsOverride(baseRuns: i32, kind: i32, value: f64): i32 {
+  if (kind == 1) return <i32>value;
+  if (kind == 2) return <i32>Math.round(<f64>baseRuns * value);
+  if (kind == 3) return baseRuns + <i32>value;
+  if (kind == 4) {
+    return baseRuns + <i32>Math.round((<f64>baseRuns * value) / 100.0);
+  }
+  return baseRuns;
+}
+
 function registerSuite(
   description: string,
   callback: () => void,

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";
@@ -186,15 +186,21 @@ export class FuzzSeed {
 export abstract class FuzzerBase {
   public name: string;
   public skipped: bool;
-  constructor(name: string, skipped: bool = false) {
+  public operations: i32;
+  constructor(name: string, skipped: bool = false, operations: i32 = 0) {
     this.name = name;
     this.skipped = skipped;
+    this.operations = operations > 0 ? operations : 0;
   }
 
   generate<T extends Function>(_generator: T): this {
     return this;
   }
 
+  runsOr(defaultRuns: i32): i32 {
+    return this.operations > 0 ? this.operations : defaultRuns;
+  }
+
   abstract run(seed: u64, runs: i32): FuzzerResult;
 }
 
@@ -211,6 +217,7 @@ export class FuzzerResult {
   public failureLeft: string = "";
   public failureRight: string = "";
   public failureMessage: string = "";
+  public failures: FuzzFailure[] = [];
 
   serialize(): string {
     return (
@@ -238,7 +245,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 +356,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 +365,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++;
   }
@@ -351,8 +383,9 @@ export class Fuzzer0<R> extends FuzzerBase {
     name: string,
     private callback: () => R,
     skipped: bool = false,
+    operations: i32 = 0,
   ) {
-    super(name, skipped);
+    super(name, skipped, operations);
     this.returnsBool = !isVoid<R>();
   }
 
@@ -389,7 +422,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();
@@ -405,8 +438,9 @@ export class Fuzzer1<A, R> extends FuzzerBase {
     name: string,
     private callback: (a: A) => R,
     skipped: bool = false,
+    operations: i32 = 0,
   ) {
-    super(name, skipped);
+    super(name, skipped, operations);
     this.returnsBool = !isVoid<R>();
   }
 
@@ -438,7 +472,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 +485,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();
@@ -465,8 +502,9 @@ export class Fuzzer2<A, B, R> extends FuzzerBase {
     name: string,
     private callback: (a: A, b: B) => R,
     skipped: bool = false,
+    operations: i32 = 0,
   ) {
-    super(name, skipped);
+    super(name, skipped, operations);
     this.returnsBool = !isVoid<R>();
   }
 
@@ -500,7 +538,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 +552,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();
@@ -526,8 +568,9 @@ export class Fuzzer3<A, B, C, R> extends FuzzerBase {
     name: string,
     private callback: (a: A, b: B, c: C) => R,
     skipped: bool = false,
+    operations: i32 = 0,
   ) {
-    super(name, skipped);
+    super(name, skipped, operations);
     this.returnsBool = !isVoid<R>();
   }
 
@@ -564,7 +607,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 +627,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();
@@ -586,16 +639,23 @@ export function createFuzzer<T extends Function>(
   name: string,
   callback: T,
   skipped: bool = false,
+  operations: i32 = 0,
 ): FuzzerBase {
   const length = callback.length;
   if (length == 0) {
-    return new Fuzzer0<usize>(name, changetype<() => usize>(callback), skipped);
+    return new Fuzzer0<usize>(
+      name,
+      changetype<() => usize>(callback),
+      skipped,
+      operations,
+    );
   }
   if (length == 1) {
     return new Fuzzer1<usize, usize>(
       name,
       changetype<(a: usize) => usize>(callback),
       skipped,
+      operations,
     );
   }
   if (length == 2) {
@@ -603,6 +663,7 @@ export function createFuzzer<T extends Function>(
       name,
       changetype<(a: usize, b: usize) => usize>(callback),
       skipped,
+      operations,
     );
   }
   if (length == 3) {
@@ -610,10 +671,16 @@ export function createFuzzer<T extends Function>(
       name,
       changetype<(a: usize, b: usize, c: usize) => usize>(callback),
       skipped,
+      operations,
     );
   }
   panic();
-  return new Fuzzer0<usize>(name, changetype<() => usize>(callback), skipped);
+  return new Fuzzer0<usize>(
+    name,
+    changetype<() => usize>(callback),
+    skipped,
+    operations,
+  );
 }
 
 function buildAlphabet(options: StringOptions): i32[] {
@@ -694,6 +761,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 +770,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 +791,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/assembly/util/wipc.ts

@@ -52,6 +52,8 @@ export class SnapshotReply {
 export class FuzzConfigReply {
   public runs: i32 = 1000;
   public seed: u64 = 1337;
+  public runsOverrideKind: i32 = 0;
+  public runsOverrideValue: f64 = 0.0;
 }
 
 export function sendAssertionFailure(
@@ -141,13 +143,21 @@ export function requestFuzzConfig(): FuzzConfigReply {
   if (!body.length) {
     return new FuzzConfigReply();
   }
-  const sep = body.indexOf("\n");
-  if (sep < 0) return new FuzzConfigReply();
+  const first = body.indexOf("\n");
+  if (first < 0) return new FuzzConfigReply();
   const reply = new FuzzConfigReply();
-  const runs = body.slice(0, sep);
-  const seed = body.slice(sep + 1);
+  const second = body.indexOf("\n", first + 1);
+  const third = second >= 0 ? body.indexOf("\n", second + 1) : -1;
+  const runs = body.slice(0, first);
+  const seed =
+    second >= 0 ? body.slice(first + 1, second) : body.slice(first + 1);
+  const kind =
+    second >= 0 && third >= 0 ? body.slice(second + 1, third) : "";
+  const value = third >= 0 ? body.slice(third + 1) : "";
   if (runs.length) reply.runs = I32.parseInt(runs);
   if (seed.length) reply.seed = U64.parseInt(seed);
+  if (kind.length) reply.runsOverrideKind = I32.parseInt(kind);
+  if (value.length) reply.runsOverrideValue = parseFloat(value);
   return reply;
 }
 

package/bin/commands/fuzz-core.js

@@ -29,12 +29,39 @@ export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], mod
     return results;
 }
 function resolveFuzzConfig(raw, overrides) {
-    const config = Object.assign({}, raw, overrides);
+    const config = Object.assign({}, raw);
+    if (typeof overrides.seed == "number") {
+        config.seed = overrides.seed;
+    }
+    if (typeof overrides.runs == "number") {
+        config.runs = overrides.runs;
+    }
+    config.runsOverrideKind = 0;
+    config.runsOverrideValue = 0;
+    if (overrides.runsOverride) {
+        config.runsOverrideKind = encodeRunsOverrideKind(overrides.runsOverride.kind);
+        config.runsOverrideValue = overrides.runsOverride.value;
+        if (overrides.runsOverride.kind == "set") {
+            config.runs = Math.max(1, Math.round(overrides.runsOverride.value));
+        }
+    }
     if (config.target != "bindings") {
         throw new Error(`fuzz target must be "bindings"; received "${config.target}"`);
     }
     return config;
 }
+function encodeRunsOverrideKind(kind) {
+    switch (kind) {
+        case "set":
+            return 1;
+        case "scale":
+            return 2;
+        case "add":
+            return 3;
+        case "percent-add":
+            return 4;
+    }
+}
 async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStartedAt, buildFinishedAt, buildTime, modeName) {
     const startedAt = Date.now();
     const artifact = resolveArtifactFileName(file, duplicateBasenames, modeName);
@@ -48,7 +75,8 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
         if (type == 0x02) {
             const event = JSON.parse(payload.toString("utf8"));
             if (String(event.kind ?? "") == "fuzz:config") {
-                respond(`${config.runs}\n${config.seed}`);
+                const resolved = config;
+                respond(`${config.runs}\n${config.seed}\n${resolved.runsOverrideKind ?? 0}\n${resolved.runsOverrideValue ?? 0}`);
             }
             else {
                 respond("");
@@ -68,6 +96,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 +123,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 +145,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 +184,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/init-core.js

@@ -961,7 +961,7 @@ function buildBasicFuzzerExample() {
 fuzz("basic string fuzzer", (value: string): bool => {
   expect(value.length >= 0).toBe(true);
   return value.length <= 24;
-}).generate((seed: FuzzSeed, run: (value: string) => bool): void => {
+}, 250).generate((seed: FuzzSeed, run: (value: string) => bool): void => {
   run(
     seed.string({
       charset: "ascii",

package/bin/commands/run-core.js

@@ -10,6 +10,7 @@ import { buildWebRunnerSource } from "./web-runner-source.js";
 import { createReporter as createDefaultReporter } from "../reporters/default.js";
 import { createTapReporter } from "../reporters/tap.js";
 import { persistCrashRecord } from "../crash-store.js";
+import { describeCoveragePoint } from "../coverage-points.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 class SnapshotStore {
     constructor(specFile, snapshotDir, duplicateSpecBasenames = new Set()) {
@@ -1091,6 +1092,8 @@ function collectCoverageSummary(reports, enabled, showPoints, coverage) {
         for (const point of report.coverage.points) {
             if (isIgnoredCoverageFile(point.file, coverage))
                 continue;
+            if (isIgnoredCoveragePoint(point, coverage))
+                continue;
             const key = `${point.file}::${point.hash}`;
             const existing = uniquePoints.get(key);
             if (!existing) {
@@ -1246,10 +1249,19 @@ function resolveCoverageOptions(raw) {
             includeSpecs: false,
             include: [],
             exclude: [],
+            ignore: {
+                labels: [],
+                names: [],
+                locations: [],
+                snippets: [],
+            },
         };
     }
     if (raw && typeof raw == "object") {
         const obj = raw;
+        const ignore = obj.ignore && typeof obj.ignore == "object" && !Array.isArray(obj.ignore)
+            ? obj.ignore
+            : null;
         return {
             enabled: obj.enabled == null ? false : Boolean(obj.enabled),
             includeSpecs: Boolean(obj.includeSpecs),
@@ -1259,6 +1271,20 @@ function resolveCoverageOptions(raw) {
             exclude: Array.isArray(obj.exclude)
                 ? obj.exclude.filter((item) => typeof item == "string")
                 : [],
+            ignore: {
+                labels: Array.isArray(ignore?.labels)
+                    ? ignore.labels.filter((item) => typeof item == "string")
+                    : [],
+                names: Array.isArray(ignore?.names)
+                    ? ignore.names.filter((item) => typeof item == "string")
+                    : [],
+                locations: Array.isArray(ignore?.locations)
+                    ? ignore.locations.filter((item) => typeof item == "string")
+                    : [],
+                snippets: Array.isArray(ignore?.snippets)
+                    ? ignore.snippets.filter((item) => typeof item == "string")
+                    : [],
+            },
         };
     }
     return {
@@ -1266,8 +1292,49 @@ function resolveCoverageOptions(raw) {
         includeSpecs: false,
         include: [],
         exclude: [],
+        ignore: {
+            labels: [],
+            names: [],
+            locations: [],
+            snippets: [],
+        },
     };
 }
+function isIgnoredCoveragePoint(point, coverage) {
+    const ignore = coverage.ignore;
+    if (!ignore.labels.length &&
+        !ignore.names.length &&
+        !ignore.locations.length &&
+        !ignore.snippets.length) {
+        return false;
+    }
+    const info = describeCoveragePoint(point.file, point.line, point.column, point.type);
+    const location = `${point.file.replace(/\\/g, "/")}:${point.line}:${point.column}`;
+    const label = info.displayType.toLowerCase();
+    const name = info.subjectName?.toLowerCase() ?? "";
+    const snippet = info.visible.toLowerCase();
+    if (ignore.labels.some((pattern) => matchesCoverageTextPattern(label, pattern.toLowerCase()))) {
+        return true;
+    }
+    if (name.length &&
+        ignore.names.some((pattern) => matchesCoverageTextPattern(name, pattern.toLowerCase()))) {
+        return true;
+    }
+    if (ignore.locations.some((pattern) => matchesCoverageTextPattern(location, pattern.replace(/\\/g, "/")))) {
+        return true;
+    }
+    if (snippet.length &&
+        ignore.snippets.some((pattern) => matchesCoverageTextPattern(snippet, pattern.toLowerCase()))) {
+        return true;
+    }
+    return false;
+}
+function matchesCoverageTextPattern(value, pattern) {
+    const normalized = pattern.trim();
+    if (!normalized.length)
+        return false;
+    return globPatternToRegExp(normalized).test(value);
+}
 function compareCoveragePoints(a, b) {
     if (a.line !== b.line)
         return a.line - b.line;

package/bin/coverage-points.js

@@ -0,0 +1,173 @@
+import { readFileSync } from "fs";
+import * as path from "path";
+const sourceLineCache = new Map();
+export function describeCoveragePoint(file, line, column, fallbackType) {
+    const context = getCoverageSourceContext(file, line, column);
+    if (!context) {
+        return {
+            displayType: fallbackType,
+            subjectName: null,
+            visible: "",
+            focus: 0,
+            highlightStart: 0,
+            highlightEnd: 0,
+        };
+    }
+    const declaration = detectCoverageDeclaration(context.visible);
+    if (declaration) {
+        const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(context.visible, context.focus);
+        return {
+            displayType: declaration.type,
+            subjectName: declaration.name,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart,
+            highlightEnd,
+        };
+    }
+    const call = detectCoverageCall(context.visible, context.focus);
+    if (call) {
+        return {
+            displayType: "Call",
+            subjectName: call.name,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: call.start,
+            highlightEnd: call.end,
+        };
+    }
+    const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(context.visible, context.focus);
+    return {
+        displayType: fallbackType,
+        subjectName: null,
+        visible: context.visible,
+        focus: context.focus,
+        highlightStart,
+        highlightEnd,
+    };
+}
+export function readCoverageSourceLine(file, line) {
+    const resolved = path.resolve(process.cwd(), file);
+    let lines = sourceLineCache.get(resolved);
+    if (lines === undefined) {
+        try {
+            lines = readFileSync(resolved, "utf8").split(/\r?\n/);
+        }
+        catch {
+            lines = null;
+        }
+        sourceLineCache.set(resolved, lines);
+    }
+    if (!lines)
+        return "";
+    return lines[line - 1] ?? "";
+}
+export function resolveCoverageHighlightSpan(visible, focus) {
+    if (!visible.length)
+        return [0, 0];
+    const index = Math.max(0, Math.min(visible.length - 1, focus));
+    if (isCoverageBoundary(visible.charAt(index))) {
+        return [index, Math.min(visible.length, index + 1)];
+    }
+    let start = index;
+    let end = index + 1;
+    while (start > 0 && !isCoverageBoundary(visible.charAt(start - 1)))
+        start--;
+    while (end < visible.length && !isCoverageBoundary(visible.charAt(end)))
+        end++;
+    return [start, end];
+}
+function getCoverageSourceContext(file, line, column) {
+    const sourceLine = readCoverageSourceLine(file, line);
+    if (!sourceLine)
+        return null;
+    const expanded = sourceLine.replace(/\t/g, "  ");
+    const firstNonWhitespace = expanded.search(/\S/);
+    if (firstNonWhitespace == -1)
+        return null;
+    const visible = expanded.slice(firstNonWhitespace).trimEnd();
+    if (!visible.length)
+        return null;
+    const focus = Math.max(0, Math.min(visible.length - 1, Math.max(0, column - 1 - firstNonWhitespace)));
+    return { visible, focus };
+}
+function detectCoverageDeclaration(visible) {
+    const trimmed = visible.trim();
+    if (!trimmed.length)
+        return null;
+    let match = trimmed.match(/^(?:export\s+)?function\s+([A-Za-z_]\w*)(?:<[^>]+>)?\s*\(/);
+    if (match)
+        return { type: "Function", name: match[1] ?? null };
+    if (trimmed.startsWith("constructor(") ||
+        /^(?:public\s+|private\s+|protected\s+)constructor\s*\(/.test(trimmed)) {
+        return { type: "Constructor", name: "constructor" };
+    }
+    match = trimmed.match(/^(?:export\s+)?(?:public\s+|private\s+|protected\s+)?(?:static\s+)?([A-Za-z_]\w*)(?:<[^>]+>)?\([^)]*\)\s*:\s*[^{=]+[{]?$/);
+    if (match)
+        return { type: "Method", name: match[1] ?? null };
+    match = trimmed.match(/^(?:public\s+|private\s+|protected\s+)?(?:readonly\s+)?([A-Za-z_]\w*)(?:<[^>]+>)?\s*:\s*[^=;{]+(?:=.*)?;?$/);
+    if (match)
+        return { type: "Property", name: match[1] ?? null };
+    if (/^(?:export\s+)?class\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:export\s+)?class\s+([A-Za-z_]\w*)/);
+        return { type: "Class", name: match?.[1] ?? null };
+    }
+    if (/^(?:export\s+)?enum\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:export\s+)?enum\s+([A-Za-z_]\w*)/);
+        return { type: "Enum", name: match?.[1] ?? null };
+    }
+    if (/^(?:export\s+)?interface\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:export\s+)?interface\s+([A-Za-z_]\w*)/);
+        return { type: "Interface", name: match?.[1] ?? null };
+    }
+    if (/^(?:export\s+)?namespace\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:export\s+)?namespace\s+([A-Za-z_]\w*)/);
+        return { type: "Namespace", name: match?.[1] ?? null };
+    }
+    if (/^(?:const|let|var)\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:const|let|var)\s+([A-Za-z_]\w*)/);
+        return { type: "Variable", name: match?.[1] ?? null };
+    }
+    return null;
+}
+function detectCoverageCall(visible, focus) {
+    const matches = [...visible.matchAll(/\b([A-Za-z_]\w*)(?:<[^>()]+>)?\s*\(/g)];
+    if (!matches.length)
+        return null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    let bestMatch = null;
+    for (const match of matches) {
+        const start = match.index ?? -1;
+        if (start == -1)
+            continue;
+        const end = start + match[0].length;
+        const distance = focus < start ? start - focus : focus >= end ? focus - end + 1 : 0;
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            bestMatch = match;
+        }
+    }
+    if (!bestMatch)
+        return null;
+    const name = bestMatch[1] ?? null;
+    if (name == "if" ||
+        name == "for" ||
+        name == "while" ||
+        name == "switch" ||
+        name == "return" ||
+        name == "function") {
+        return null;
+    }
+    if (bestDistance > Math.max(12, Math.floor(visible.length / 3))) {
+        return null;
+    }
+    const start = bestMatch.index ?? 0;
+    return {
+        name,
+        start,
+        end: start + (name?.length ?? 1),
+    };
+}
+function isCoverageBoundary(ch) {
+    return /[\s()[\]{}.,;:+\-*/%&|^!?=<>]/.test(ch);
+}

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

@@ -281,7 +281,7 @@ function printCommandHelp(command) {
         process.stdout.write("  --enable <feature>       Enable feature (coverage|try-as)\n");
         process.stdout.write("  --disable <feature>      Disable feature (coverage|try-as)\n");
         process.stdout.write("  --fuzz                   Run fuzz targets after the normal test pass\n");
-        process.stdout.write("  --fuzz-runs <n>          Override fuzz iteration count for this run\n");
+        process.stdout.write("  --fuzz-runs <value>      Override fuzz iteration count, e.g. 500, 1.5x, +10%, +100000\n");
         process.stdout.write("  --fuzz-seed <n>          Override fuzz seed for this run\n");
         process.stdout.write("  --parallel              Run files through an ordered worker pool using an automatic worker count\n");
         process.stdout.write("  --jobs <n>               Run files through an ordered worker pool\n");
@@ -302,7 +302,7 @@ function printCommandHelp(command) {
         process.stdout.write(chalk.bold("Flags:\n"));
         process.stdout.write("  --config <path>          Use a specific config file\n");
         process.stdout.write("  --mode <name[,name...]>  Run one or multiple named config modes\n");
-        process.stdout.write("  --runs <n>               Override fuzz iteration count\n");
+        process.stdout.write("  --runs <value>           Override fuzz iteration count, e.g. 500, 1.5x, +10%, +100000\n");
         process.stdout.write("  --seed <n>               Override fuzz seed\n");
         process.stdout.write("  --jobs <n>               Run files through an ordered worker pool\n");
         process.stdout.write("  --build-jobs <n>         Limit concurrent build tasks (defaults to --jobs)\n");
@@ -482,9 +482,10 @@ function resolveFuzzOverrides(rawArgs, command) {
                 runs: "--fuzz-runs",
                 seed: "--fuzz-seed",
             };
-        const runs = parseNumberFlag(rawArgs, i, direct.runs);
+        const runs = parseFuzzRunsFlag(rawArgs, i, direct.runs);
         if (runs) {
-            out.runs = runs.number;
+            out.runs = runs.absoluteRuns;
+            out.runsOverride = runs.override;
             if (runs.consumeNext)
                 i++;
             continue;
@@ -499,6 +500,63 @@ function resolveFuzzOverrides(rawArgs, command) {
     }
     return out;
 }
+function parseFuzzRunsFlag(rawArgs, index, flag) {
+    const arg = rawArgs[index];
+    let value = "";
+    let consumeNext = false;
+    if (arg == flag) {
+        const next = rawArgs[index + 1];
+        if (!next || !next.length) {
+            throw new Error(`${flag} requires a value such as 500, 1.5x, +10%, or +100000`);
+        }
+        value = next;
+        consumeNext = true;
+    }
+    else if (arg.startsWith(`${flag}=`)) {
+        value = arg.slice(flag.length + 1);
+        if (!value.length) {
+            throw new Error(`${flag} requires a value such as 500, 1.5x, +10%, or +100000`);
+        }
+    }
+    else {
+        return null;
+    }
+    const parsed = parseFuzzRunsValue(flag, value.trim());
+    return {
+        key: flag,
+        absoluteRuns: parsed.kind == "set" ? parsed.value : undefined,
+        override: parsed,
+        consumeNext,
+    };
+}
+function parseFuzzRunsValue(flag, value) {
+    if (/^\d+$/.test(value)) {
+        const parsed = parseIntegerFlag(flag, value);
+        return { kind: "set", value: parsed };
+    }
+    if (/^[+-]\d+$/.test(value)) {
+        const delta = Number(value);
+        if (!Number.isFinite(delta) || !Number.isInteger(delta)) {
+            throw new Error(`${flag} additive run override must be an integer`);
+        }
+        return { kind: "add", value: delta };
+    }
+    if (/^\d+(?:\.\d+)?x$/i.test(value)) {
+        const factor = Number(value.slice(0, -1));
+        if (!Number.isFinite(factor) || factor <= 0) {
+            throw new Error(`${flag} multiplier must be greater than 0`);
+        }
+        return { kind: "scale", value: factor };
+    }
+    if (/^[+-]\d+(?:\.\d+)?%$/.test(value)) {
+        const percent = Number(value.slice(0, -1));
+        if (!Number.isFinite(percent)) {
+            throw new Error(`${flag} percentage must be numeric`);
+        }
+        return { kind: "percent-add", value: percent };
+    }
+    throw new Error(`${flag} must be a run count or expression such as 500, 1.5x, +10%, or +100000`);
+}
 function resolveListFlags(rawArgs, command) {
     const out = {
         list: false,

package/bin/reporters/default.js

@@ -3,6 +3,7 @@ import { diff } from "typer-diff";
 import { readFileSync } from "fs";
 import * as path from "path";
 import { formatTime } from "../util.js";
+import { describeCoveragePoint, readCoverageSourceLine, resolveCoverageHighlightSpan, } from "../coverage-points.js";
 export const createReporter = (context) => {
     return new DefaultReporter(context);
 };
@@ -360,7 +361,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 +405,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));
@@ -617,21 +634,60 @@ function renderSummaryLine(label, summary, layout = {
     process.stdout.write(totalText.padStart(layout.totalWidth) + "\n");
 }
 function renderCoverageSummary(summary) {
+    console.log("");
+    console.log(chalk.bold("Coverage"));
+    if (!summary.files.length || summary.total <= 0) {
+        console.log(`  ${chalk.dim("No eligible source files were tracked for coverage.")}`);
+        return;
+    }
     const pct = summary.total
         ? ((summary.covered * 100) / summary.total).toFixed(2)
         : "100.00";
+    const missingLabel = summary.uncovered == 1 ? "1 point missing" : `${summary.uncovered} points missing`;
+    const fileLabel = summary.files.length == 1 ? "1 file" : `${summary.files.length} files`;
     const color = Number(pct) >= 90
         ? chalk.greenBright
         : Number(pct) >= 75
             ? chalk.yellowBright
             : chalk.redBright;
-    console.log("");
-    console.log(`${chalk.bold("Coverage:")} ${color(pct + "%")} ${chalk.dim(`(${summary.covered}/${summary.total} points, ${summary.uncovered} uncovered)`)}`);
+    console.log(`  ${color(pct + "%")} ${renderCoverageBar(summary.percent)} ${chalk.dim(`(${summary.covered}/${summary.total} covered, ${missingLabel}, ${fileLabel})`)}`);
+    const ranked = [...summary.files].sort((a, b) => {
+        if (a.percent != b.percent)
+            return a.percent - b.percent;
+        if (a.uncovered != b.uncovered)
+            return b.uncovered - a.uncovered;
+        return a.file.localeCompare(b.file);
+    });
+    console.log(chalk.bold("  File Breakdown"));
+    for (const file of ranked.slice(0, 8)) {
+        const filePct = file.total
+            ? ((file.covered * 100) / file.total).toFixed(2)
+            : "100.00";
+        const fileColor = Number(filePct) >= 90
+            ? chalk.greenBright
+            : Number(filePct) >= 75
+                ? chalk.yellowBright
+                : chalk.redBright;
+        const suffix = file.uncovered > 0
+            ? `${file.uncovered} missing`
+            : "fully covered";
+        console.log(`    ${fileColor(filePct.padStart(6) + "%")}  ${toRelativeResultPath(file.file).padEnd(36)} ${chalk.dim(`${file.covered}/${file.total} covered, ${suffix}`)}`);
+    }
+    if (ranked.length > 8) {
+        console.log(chalk.dim(`    ... ${ranked.length - 8} more files`));
+    }
 }
 function renderCoveragePoints(files) {
     console.log("");
-    console.log(chalk.bold("Coverage Points:"));
+    console.log(chalk.bold("Coverage Gaps"));
     const sortedFiles = [...files].sort((a, b) => a.file.localeCompare(b.file));
+    const missingPoints = sortedFiles.flatMap((file) => file.points
+        .filter((point) => !point.executed)
+        .map((point) => ({
+        ...point,
+        displayType: describeCoveragePoint(point.file, point.line, point.column, point.type).displayType,
+    })));
+    const layout = createCoverageGapLayout(missingPoints);
     for (const file of sortedFiles) {
         const points = [...file.points].sort((a, b) => {
             if (a.line != b.line)
@@ -640,10 +696,69 @@ function renderCoveragePoints(files) {
                 return a.column - b.column;
             return a.type.localeCompare(b.type);
         });
+        const missing = points.filter((point) => !point.executed);
+        if (!missing.length)
+            continue;
+        console.log(`  ${chalk.bold(toRelativeResultPath(file.file))} ${chalk.dim(`(${missing.length} uncovered)`)}`);
         for (const point of points) {
             if (point.executed)
                 continue;
-            console.log(`${chalk.bgRed(" MISS ")} ${chalk.dim(`${point.file}:${point.line}:${point.column}`)} ${chalk.dim(point.type)}`);
+            const location = `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`;
+            const snippet = formatCoverageSnippet(point.file, point.line, point.column);
+            const typeLabel = describeCoveragePoint(point.file, point.line, point.column, point.type).displayType.padEnd(layout.typeWidth + 4);
+            const locationLabel = location.padEnd(layout.locationWidth + 4);
+            console.log(`    ${chalk.red("x")} ${chalk.dim(typeLabel)}${chalk.dim(locationLabel)}${snippet}`);
         }
     }
 }
+function renderCoverageBar(percent) {
+    const slots = 12;
+    const filled = Math.max(0, Math.min(slots, Math.round((Math.max(0, Math.min(100, percent)) / 100) * slots)));
+    return `[${"=".repeat(filled)}${"-".repeat(slots - filled)}]`;
+}
+function createCoverageGapLayout(points) {
+    return {
+        typeWidth: Math.max(...points.map((point) => point.displayType.length), 5),
+        locationWidth: Math.max(...points.map((point) => `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`.length), 1),
+    };
+}
+function formatCoverageSnippet(file, line, column) {
+    const sourceLine = readCoverageSourceLine(file, line);
+    if (!sourceLine)
+        return "";
+    const expanded = sourceLine.replace(/\t/g, "  ");
+    const firstNonWhitespace = expanded.search(/\S/);
+    if (firstNonWhitespace == -1)
+        return "";
+    const visible = expanded.slice(firstNonWhitespace).trimEnd();
+    if (!visible.length)
+        return "";
+    const maxWidth = 72;
+    const focus = Math.max(0, Math.min(visible.length - 1, Math.max(0, column - 1 - firstNonWhitespace)));
+    if (visible.length <= maxWidth) {
+        return styleCoverageSnippetWindow(visible, 0, visible.length, focus);
+    }
+    const start = Math.max(0, Math.min(visible.length - maxWidth, focus - Math.floor(maxWidth / 2)));
+    const end = Math.min(visible.length, start + maxWidth);
+    return styleCoverageSnippetWindow(visible, start, end, focus);
+}
+function styleCoverageSnippetWindow(visible, start, end, focus) {
+    const prefix = start > 0 ? "..." : "";
+    const suffix = end < visible.length ? "..." : "";
+    const slice = visible.slice(start, end);
+    const localFocus = Math.max(0, Math.min(slice.length - 1, focus - start));
+    const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(visible, focus);
+    const localStart = Math.max(0, Math.min(slice.length, highlightStart - start));
+    const localEnd = Math.max(localStart + 1, Math.min(slice.length, highlightEnd - start));
+    if (!slice.length)
+        return "";
+    if (localStart >= slice.length) {
+        return chalk.dim(`${prefix}${slice}${suffix}`);
+    }
+    const head = slice.slice(0, localStart);
+    const body = slice.slice(localStart, localEnd || localStart + 1);
+    const tail = slice.slice(localEnd || localStart + 1);
+    return (chalk.dim(prefix + head) +
+        chalk.dim.underline(body.length ? body : slice.charAt(localFocus)) +
+        chalk.dim(tail + suffix));
+}

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/bin/types.js

@@ -21,6 +21,15 @@ export class CoverageOptions {
         this.includeSpecs = false;
         this.include = [];
         this.exclude = [];
+        this.ignore = new CoverageIgnoreOptions();
+    }
+}
+export class CoverageIgnoreOptions {
+    constructor() {
+        this.labels = [];
+        this.names = [];
+        this.locations = [];
+        this.snippets = [];
     }
 }
 export class Suite {

package/bin/util.js

@@ -340,6 +340,22 @@ function validateCoverageValue(value, path, issues) {
     }
     validateStringArrayField(obj, "include", path, issues);
     validateStringArrayField(obj, "exclude", path, issues);
+    if ("ignore" in obj && obj.ignore != undefined) {
+        if (!obj.ignore || typeof obj.ignore != "object" || Array.isArray(obj.ignore)) {
+            issues.push({
+                path: `${path}.ignore`,
+                message: "must be an object",
+                fix: 'set "ignore" to an object such as { "labels": ["Call"], "names": ["panic"] }',
+            });
+        }
+        else {
+            const ignore = obj.ignore;
+            validateStringArrayField(ignore, "labels", `${path}.ignore`, issues);
+            validateStringArrayField(ignore, "names", `${path}.ignore`, issues);
+            validateStringArrayField(ignore, "locations", `${path}.ignore`, issues);
+            validateStringArrayField(ignore, "snippets", `${path}.ignore`, issues);
+        }
+    }
 }
 function validateStringArrayField(raw, key, pathPrefix, issues) {
     if (!(key in raw) || raw[key] == undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",