as-test 1.0.12 → 1.0.14

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Change Log
 
+## 2026-05-04 - v1.0.14
+
+### Fuzzing
+
+- feat: add `FuzzSeed` helpers for `i8`, `u8`, `i16`, `u16`, `i64`, `u64`, and `bool()`.
+- feat: make integer `FuzzSeed` helpers default to the full range of their target type when no options are provided, instead of collapsing to `0`.
+- perf: add unchecked full-range fast paths for default integer seed generation while keeping explicit user-provided ranges validated.
+
+## 2025-05-03 - v1.0.13
+
+- feat: add `--fuzzer` / `--fuzzers` filtering for `ast fuzz` and `ast test --fuzz`, accept `--suite` / `--suites` as fuzz aliases, and include target-specific repro commands in fuzz failure output.
+- feat: add `--suite` / `--suites` filtering for `ast run` and `ast test`, and print suite-specific repro commands on failing test assertions.
+
 ## 2026-04-28 - v1.0.12
 
 - perf: faster seed generation

package/README.md

@@ -134,6 +134,13 @@ Run one matching file:
 npx ast test math
 ```
 
+Re-run one suite inside a matching file:
+
+```bash
+npx ast run math --suite array-check
+npx ast run math --suite array-manipulation/array-check
+```
+
 You do not need to learn every CLI flag to get started. Most projects can begin with `npx ast test`, then add more configuration only when they need it.
 
 ## Mocking
@@ -286,6 +293,12 @@ Run only fuzzers:
 npx ast fuzz
 ```
 
+Run one matching fuzz target:
+
+```bash
+npx ast fuzz string --fuzzer ascii-strings-survive-concatenation-boundaries
+```
+
 Run tests and fuzzers together:
 
 ```bash
@@ -352,6 +365,36 @@ If you want to keep more than one runtime around, use modes:
 }
 ```
 
+Modes can also be full config objects. That means a mode can override fuzzing, input globs, output aliases, runtime, build flags, and the rest of the normal config surface:
+
+```json
+{
+  "modes": {
+    "web": {
+      "fuzz": {
+        "input": ["./assembly/__fuzz__/web/*.fuzz.ts"],
+        "runs": 200
+      },
+      "runOptions": {
+        "runtime": {
+          "browser": "chromium"
+        }
+      }
+    }
+  }
+}
+```
+
+If you prefer to keep one mode in a separate file, point the mode directly at that config file:
+
+```json
+{
+  "modes": {
+    "simd": "./as-test.config.simd.json"
+  }
+}
+```
+
 Run a specific mode with:
 
 ```bash

package/as-test.config.schema.json

@@ -294,11 +294,43 @@
     },
     "modes": {
       "type": "object",
-      "description": "Named build/run modes. Each mode can override target/args/runtime/env and artifact directories.",
+      "description": "Named build/run modes. Each mode can be a config object or a path to another as-test config file.",
       "additionalProperties": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
+        "oneOf": [
+          {
+            "type": "string",
+            "description": "Path to another as-test config file used as the selected mode's override config."
+          },
+          {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "$schema": {
+                "type": "string"
+              },
+              "input": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "output": {
+                "oneOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "build": { "type": "string" },
+                      "logs": { "type": "string" },
+                      "coverage": { "type": "string" },
+                      "snapshots": { "type": "string" }
+                    }
+                  }
+                ]
+              },
           "outDir": {
             "type": "string",
             "description": "Mode-specific build output directory. If omitted, defaults to <outDir>/<mode-name>."
@@ -339,6 +371,38 @@
               }
             ]
           },
+          "fuzz": {
+            "type": "object",
+            "additionalProperties": false,
+            "description": "Mode-specific fuzz overrides applied before running `ast fuzz` or `ast test --fuzz` in this mode.",
+            "properties": {
+              "input": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "runs": {
+                "type": "number"
+              },
+              "seed": {
+                "type": "number"
+              },
+              "maxInputBytes": {
+                "type": "number"
+              },
+              "target": {
+                "type": "string",
+                "enum": ["bindings"]
+              },
+              "corpusDir": {
+                "type": "string"
+              },
+              "crashDir": {
+                "type": "string"
+              }
+            }
+          },
           "buildOptions": {
             "type": "object",
             "additionalProperties": false,
@@ -469,7 +533,9 @@
               }
             ]
           }
-        }
+            }
+          }
+        ]
       },
       "default": {}
     },

package/assembly/as-test.intellisense.d.ts

@@ -45,8 +45,16 @@ declare module "as-test" {
   }
 
   export interface FuzzSeed {
+    boolean(): boolean;
+    bool(): boolean;
+    i8(options?: IntellisenseIntegerOptions): number;
+    u8(options?: IntellisenseIntegerOptions): number;
+    i16(options?: IntellisenseIntegerOptions): number;
+    u16(options?: IntellisenseIntegerOptions): number;
     i32(options?: IntellisenseIntegerOptions): number;
     u32(options?: IntellisenseIntegerOptions): number;
+    i64(options?: IntellisenseIntegerOptions): number;
+    u64(options?: IntellisenseIntegerOptions): number;
     f32(options?: IntellisenseFloatOptions): number;
     f64(options?: IntellisenseFloatOptions): number;
     bytes(options?: IntellisenseBytesOptions): Uint8Array;

package/assembly/src/fuzz.ts

@@ -34,13 +34,20 @@ export class ArrayOptions {
   max: i32 = 16;
 }
 
-const DEFAULT_I32_OPTIONS = new IntegerOptions<i32>();
-const DEFAULT_U32_OPTIONS = new IntegerOptions<u32>();
 const DEFAULT_F32_OPTIONS = new FloatOptions<f32>();
 const DEFAULT_F64_OPTIONS = new FloatOptions<f64>();
 const DEFAULT_STRING_OPTIONS = new StringOptions();
 const DEFAULT_BYTES_OPTIONS = new BytesOptions();
 const DEFAULT_ARRAY_OPTIONS = new ArrayOptions();
+const I64_SIGN_MASK: u64 = 0x8000000000000000;
+const EMPTY_I8_EXCLUDE: i8[] = [];
+const EMPTY_U8_EXCLUDE: u8[] = [];
+const EMPTY_I16_EXCLUDE: i16[] = [];
+const EMPTY_U16_EXCLUDE: u16[] = [];
+const EMPTY_I32_EXCLUDE: i32[] = [];
+const EMPTY_U32_EXCLUDE: u32[] = [];
+const EMPTY_I64_EXCLUDE: i64[] = [];
+const EMPTY_U64_EXCLUDE: u64[] = [];
 
 export class FuzzSeed {
   private state: u32;
@@ -61,19 +68,99 @@ export class FuzzSeed {
     return (this.nextU32() & 1) == 1;
   }
 
+  bool(): bool {
+    return this.boolean();
+  }
+
   pick<T>(values: T[]): T {
     if (!values.length) panic();
     return unchecked(values[this.nextRange(0, values.length - 1)]);
   }
 
+  i8(options: IntegerOptions<i8> | null = null): i8 {
+    if (options == null) {
+      return this.nextI8InRange(i8.MIN_VALUE, i8.MAX_VALUE, EMPTY_I8_EXCLUDE, false);
+    }
+    return this.nextI8InRange(options.min, options.max, options.exclude, true);
+  }
+
+  u8(options: IntegerOptions<u8> | null = null): u8 {
+    if (options == null) {
+      return this.nextU8InRange(u8.MIN_VALUE, u8.MAX_VALUE, EMPTY_U8_EXCLUDE, false);
+    }
+    return this.nextU8InRange(options.min, options.max, options.exclude, true);
+  }
+
+  i16(options: IntegerOptions<i16> | null = null): i16 {
+    if (options == null) {
+      return this.nextI16InRange(
+        i16.MIN_VALUE,
+        i16.MAX_VALUE,
+        EMPTY_I16_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextI16InRange(options.min, options.max, options.exclude, true);
+  }
+
+  u16(options: IntegerOptions<u16> | null = null): u16 {
+    if (options == null) {
+      return this.nextU16InRange(
+        u16.MIN_VALUE,
+        u16.MAX_VALUE,
+        EMPTY_U16_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextU16InRange(options.min, options.max, options.exclude, true);
+  }
+
   i32(options: IntegerOptions<i32> | null = null): i32 {
-    const config = options != null ? options : DEFAULT_I32_OPTIONS;
-    return this.nextI32InRange(config.min, config.max, config.exclude);
+    if (options == null) {
+      return this.nextI32InRange(
+        i32.MIN_VALUE,
+        i32.MAX_VALUE,
+        EMPTY_I32_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextI32InRange(options.min, options.max, options.exclude, true);
   }
 
   u32(options: IntegerOptions<u32> | null = null): u32 {
-    const config = options != null ? options : DEFAULT_U32_OPTIONS;
-    return this.nextU32InRange(config.min, config.max, config.exclude);
+    if (options == null) {
+      return this.nextU32InRange(
+        u32.MIN_VALUE,
+        u32.MAX_VALUE,
+        EMPTY_U32_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextU32InRange(options.min, options.max, options.exclude, true);
+  }
+
+  i64(options: IntegerOptions<i64> | null = null): i64 {
+    if (options == null) {
+      return this.nextI64InRange(
+        i64.MIN_VALUE,
+        i64.MAX_VALUE,
+        EMPTY_I64_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextI64InRange(options.min, options.max, options.exclude, true);
+  }
+
+  u64(options: IntegerOptions<u64> | null = null): u64 {
+    if (options == null) {
+      return this.nextU64InRange(
+        u64.MIN_VALUE,
+        u64.MAX_VALUE,
+        EMPTY_U64_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextU64InRange(options.min, options.max, options.exclude, true);
   }
 
   f32(options: FloatOptions<f32> | null = null): f32 {
@@ -201,8 +288,16 @@ export class FuzzSeed {
     return 0;
   }
 
-  private nextI32InRange(min: i32, max: i32, exclude: i32[]): i32 {
-    if (max < min) panic();
+  private nextI32InRange(
+    min: i32,
+    max: i32,
+    exclude: i32[],
+    validateRange: bool = true,
+  ): i32 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == i32.MIN_VALUE && max == i32.MAX_VALUE) {
+      return <i32>this.nextU32();
+    }
     if (!exclude.length) {
       return max <= min ? min : min + <i32>(this.nextU32() % <u32>(max - min + 1));
     }
@@ -215,8 +310,120 @@ export class FuzzSeed {
     return min;
   }
 
-  private nextU32InRange(min: u32, max: u32, exclude: u32[]): u32 {
-    if (max < min) panic();
+  private nextI8InRange(
+    min: i8,
+    max: i8,
+    exclude: i8[],
+    validateRange: bool = true,
+  ): i8 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == i8.MIN_VALUE && max == i8.MAX_VALUE) {
+      return <i8>this.nextU32();
+    }
+    const left = <i32>min;
+    const right = <i32>max;
+    if (!exclude.length) {
+      return <i8>(
+        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+      );
+    }
+    for (let attempts = 0; attempts < 1024; attempts++) {
+      const value = <i8>(
+        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+      );
+      if (!containsValue<i8>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextU8InRange(
+    min: u8,
+    max: u8,
+    exclude: u8[],
+    validateRange: bool = true,
+  ): u8 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == u8.MIN_VALUE && max == u8.MAX_VALUE) {
+      return <u8>this.nextU32();
+    }
+    const left = <u32>min;
+    const right = <u32>max;
+    if (!exclude.length) {
+      return <u8>(right <= left ? left : left + (this.nextU32() % (right - left + 1)));
+    }
+    for (let attempts = 0; attempts < 1024; attempts++) {
+      const value = <u8>(
+        right <= left ? left : left + (this.nextU32() % (right - left + 1))
+      );
+      if (!containsValue<u8>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextI16InRange(
+    min: i16,
+    max: i16,
+    exclude: i16[],
+    validateRange: bool = true,
+  ): i16 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == i16.MIN_VALUE && max == i16.MAX_VALUE) {
+      return <i16>this.nextU32();
+    }
+    const left = <i32>min;
+    const right = <i32>max;
+    if (!exclude.length) {
+      return <i16>(
+        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+      );
+    }
+    for (let attempts = 0; attempts < 1024; attempts++) {
+      const value = <i16>(
+        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+      );
+      if (!containsValue<i16>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextU16InRange(
+    min: u16,
+    max: u16,
+    exclude: u16[],
+    validateRange: bool = true,
+  ): u16 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == u16.MIN_VALUE && max == u16.MAX_VALUE) {
+      return <u16>this.nextU32();
+    }
+    const left = <u32>min;
+    const right = <u32>max;
+    if (!exclude.length) {
+      return <u16>(right <= left ? left : left + (this.nextU32() % (right - left + 1)));
+    }
+    for (let attempts = 0; attempts < 1024; attempts++) {
+      const value = <u16>(
+        right <= left ? left : left + (this.nextU32() % (right - left + 1))
+      );
+      if (!containsValue<u16>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextU32InRange(
+    min: u32,
+    max: u32,
+    exclude: u32[],
+    validateRange: bool = true,
+  ): u32 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == u32.MIN_VALUE && max == u32.MAX_VALUE) {
+      return this.nextU32();
+    }
     if (!exclude.length) {
       return max <= min ? min : min + (this.nextU32() % (max - min + 1));
     }
@@ -228,6 +435,52 @@ export class FuzzSeed {
     return min;
   }
 
+  private nextI64InRange(
+    min: i64,
+    max: i64,
+    exclude: i64[],
+    validateRange: bool = true,
+  ): i64 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == i64.MIN_VALUE && max == i64.MAX_VALUE) {
+      return <i64>this.nextU64();
+    }
+    const left = this.toOrderedU64(min);
+    const right = this.toOrderedU64(max);
+    if (!exclude.length) {
+      return this.fromOrderedU64(
+        left + this.nextU64Offset(left, right),
+      );
+    }
+    for (let attempts = 0; attempts < 1024; attempts++) {
+      const value = this.fromOrderedU64(left + this.nextU64Offset(left, right));
+      if (!containsValue<i64>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextU64InRange(
+    min: u64,
+    max: u64,
+    exclude: u64[],
+    validateRange: bool = true,
+  ): u64 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == u64.MIN_VALUE && max == u64.MAX_VALUE) {
+      return this.nextU64();
+    }
+    if (!exclude.length) {
+      return min + this.nextU64Offset(min, max);
+    }
+    for (let attempts = 0; attempts < 1024; attempts++) {
+      const value = min + this.nextU64Offset(min, max);
+      if (!containsValue<u64>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
   private nextF64InRange<T>(min: T, max: T, exclude: T[]): f64 {
     const left = <f64>min;
     const right = <f64>max;
@@ -268,6 +521,20 @@ export class FuzzSeed {
     const lo = <u64>this.nextU32();
     return (hi << 32) | lo;
   }
+
+  private nextU64Offset(min: u64, max: u64): u64 {
+    if (max <= min) return 0;
+    if (min == 0 && max == u64.MAX_VALUE) return this.nextU64();
+    return this.nextU64() % (max - min + 1);
+  }
+
+  private toOrderedU64(value: i64): u64 {
+    return <u64>value ^ I64_SIGN_MASK;
+  }
+
+  private fromOrderedU64(value: u64): i64 {
+    return <i64>(value ^ I64_SIGN_MASK);
+  }
 }
 
 const ASCII_ALPHABET: i32[] = rangeChars(32, 126);

package/bin/commands/build-core.js

@@ -20,8 +20,8 @@ class BuildFailureError extends Error {
         this.kind = args.kind;
     }
 }
-export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, featureToggles = {}, overrides = {}) {
-    const loadedConfig = loadConfig(configPath, false);
+export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, featureToggles = {}, overrides = {}, resolvedConfig) {
+    const loadedConfig = resolvedConfig ?? 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);
@@ -44,7 +44,9 @@ export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], mo
         ...config.buildOptions.env,
         AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
     };
-    if (!process.env.AS_TEST_BUILD_API && !hasCustomBuildCommand(config)) {
+    if (!resolvedConfig &&
+        !process.env.AS_TEST_BUILD_API &&
+        !hasCustomBuildCommand(config)) {
         const pool = getSerialBuildWorkerPool();
         for (const file of inputFiles) {
             await pool.buildFileMode({

package/bin/commands/fuzz-core.js

@@ -9,10 +9,11 @@ const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 const MAGIC = Buffer.from("WIPC");
 const HEADER_SIZE = 9;
 const MAX_DEFAULT_SEED = 0x7fffffff;
-export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, overrides = {}) {
+export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, overrides = {}, fuzzerSelectors = []) {
     const loadedConfig = loadConfig(configPath, false);
     const mode = applyMode(loadedConfig, modeName);
-    const config = resolveFuzzConfig(loadedConfig.fuzz, overrides);
+    const activeConfig = mode.config;
+    const config = resolveFuzzConfig(activeConfig.fuzz, overrides);
     const inputPatterns = resolveFuzzInputPatterns(config.input, selectors);
     const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
     if (!inputFiles.length) {
@@ -22,10 +23,10 @@ export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], mod
     const results = [];
     for (const file of inputFiles) {
         const buildStartedAt = Date.now();
-        await build(configPath, [file], modeName, { coverage: false }, { target: "bindings", args: ["--use", "AS_TEST_FUZZ=1"], kind: "fuzz" });
+        await build(configPath, [file], modeName, { coverage: false }, { target: "bindings", args: ["--use", "AS_TEST_FUZZ=1"], kind: "fuzz" }, activeConfig);
         const buildFinishedAt = Date.now();
         const buildTime = buildFinishedAt - buildStartedAt;
-        results.push(await runFuzzTarget(file, mode.config.outDir, duplicateBasenames, config, buildStartedAt, buildFinishedAt, buildTime, modeName));
+        results.push(await runFuzzTarget(file, activeConfig.outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName));
     }
     return results;
 }
@@ -69,7 +70,7 @@ function encodeRunsOverrideKind(kind) {
             return 4;
     }
 }
-async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStartedAt, buildFinishedAt, buildTime, modeName) {
+async function runFuzzTarget(file, outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName) {
     const startedAt = Date.now();
     const artifact = resolveArtifactFileName(file, duplicateBasenames, modeName);
     const wasmPath = path.resolve(process.cwd(), outDir, artifact);
@@ -210,7 +211,10 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
         };
     }
     const crashFiles = [];
-    for (const fuzzer of report.fuzzers) {
+    const selectedFuzzers = fuzzerSelectors.length
+        ? filterSelectedFuzzers(report.fuzzers, fuzzerSelectors, file)
+        : report.fuzzers;
+    for (const fuzzer of selectedFuzzers) {
         if (fuzzer.failed <= 0 && fuzzer.crashed <= 0)
             continue;
         const firstFailureSeed = typeof fuzzer.failures?.[0]?.seed == "number"
@@ -222,7 +226,7 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
             entryKey: buildFuzzFailureEntryKey(file, fuzzer.name, modeName ?? "default"),
             mode: modeName ?? "default",
             seed: firstFailureSeed,
-            reproCommand: buildFuzzReproCommand(file, firstFailureSeed, modeName ?? "default", 1),
+            reproCommand: buildFuzzReproCommand(file, firstFailureSeed, modeName ?? "default", fuzzer.selector, 1),
             error: fuzzer.failure?.message ||
                 `fuzz failure in ${fuzzer.name} after ${fuzzer.runs} runs`,
             stdout: passthrough.stdout,
@@ -237,21 +241,49 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
         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),
+        runs: selectedFuzzers.reduce((sum, item) => sum + item.runs, 0),
+        crashes: selectedFuzzers.reduce((sum, item) => sum + item.crashed, 0),
         crashFiles,
         seed: config.seed,
         time: Date.now() - startedAt,
         buildTime,
         buildStartedAt,
         buildFinishedAt,
-        fuzzers: report.fuzzers,
+        fuzzers: selectedFuzzers,
     };
 }
-function buildFuzzReproCommand(file, seed, modeName, runs) {
+function filterSelectedFuzzers(fuzzers, selectors, file) {
+    const annotated = fuzzers.map((fuzzer) => ({
+        ...fuzzer,
+        selector: slugifyFuzzerSelector(fuzzer.name),
+    }));
+    const selected = new Set();
+    for (const selector of selectors) {
+        const slug = slugifyFuzzerSelector(selector);
+        if (!slug.length)
+            continue;
+        const matches = annotated.filter((fuzzer) => fuzzer.selector == slug);
+        if (!matches.length) {
+            throw new Error(`No fuzz targets matched "${selector}" in ${path.basename(file)}.`);
+        }
+        for (const match of matches) {
+            selected.add(match.selector);
+        }
+    }
+    return annotated.filter((fuzzer) => selected.has(fuzzer.selector ?? ""));
+}
+function slugifyFuzzerSelector(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function buildFuzzReproCommand(file, seed, modeName, fuzzer, runs) {
     const modeArg = modeName != "default" ? ` --mode ${modeName}` : "";
+    const fuzzerArg = fuzzer?.length ? ` --fuzzer ${fuzzer}` : "";
     const runsArg = typeof runs == "number" ? ` --runs ${runs}` : "";
-    return `ast fuzz ${file}${modeArg} --seed ${seed}${runsArg}`;
+    return `ast fuzz ${file}${modeArg}${fuzzerArg} --seed ${seed}${runsArg}`;
 }
 function buildFuzzFailureEntryKey(file, name, modeName) {
     return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}.${sanitizeEntryName(name)}`;
@@ -324,12 +356,12 @@ function captureFrames(onFrame) {
         }
     });
     process.stdin.read = ((size) => {
-        const max = Number(size ?? 0);
+        const max = size == null ? 0 : Number(size);
         if (max > 0 && replies.length) {
             return dequeueReply(max);
         }
         if (originalRead) {
-            return originalRead(size);
+            return originalRead(size === null ? undefined : size);
         }
         return null;
     });