as-test 1.0.12 → 1.0.13

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## 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

package/bin/commands/fuzz-core.js

@@ -9,7 +9,7 @@ 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);
@@ -25,7 +25,7 @@ export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], mod
         await build(configPath, [file], modeName, { coverage: false }, { target: "bindings", args: ["--use", "AS_TEST_FUZZ=1"], kind: "fuzz" });
         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, mode.config.outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName));
     }
     return results;
 }
@@ -69,7 +69,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 +210,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 +225,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 +240,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 +355,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;
     });

package/bin/commands/fuzz.js

@@ -1,10 +1,11 @@
 export async function executeFuzzCommand(rawArgs, configPath, selectedModes, deps) {
     const commandArgs = deps.resolveCommandArgs(rawArgs, "fuzz");
+    const fuzzerSelectors = deps.resolveFuzzerSelectors(rawArgs, "fuzz");
     const listFlags = deps.resolveListFlags(rawArgs, "fuzz");
     const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
     if (listFlags.list || listFlags.listModes) {
         await deps.listExecutionPlan("fuzz", configPath, commandArgs, modeTargets, listFlags);
         return;
     }
-    await deps.runFuzzModes(configPath, commandArgs, modeTargets, rawArgs);
+    await deps.runFuzzModes(configPath, commandArgs, fuzzerSelectors, modeTargets, rawArgs);
 }

package/bin/commands/run-core.js

@@ -327,6 +327,9 @@ function formatReadableLog(file, suites, modeName, buildCommand, runCommand, sna
         lines.push("", "Failures:");
         for (const failure of failures) {
             lines.push(`FAIL  ${failure.title}${failure.where.length ? ` (${failure.where})` : ""}`);
+            if (failure.suitePath.length) {
+                lines.push(`Repro: ${buildSuiteReproCommand(file, failure.suitePath, modeName)}`);
+            }
             if (failure.message.length)
                 lines.push(`Message: ${failure.message}`);
             if (failure.left.length)
@@ -352,6 +355,139 @@ function formatInvocation(invocation) {
         .map((part) => (/[\s"'\\]/.test(part) ? JSON.stringify(part) : part))
         .join(" ");
 }
+function filterSelectedSuites(suites, selectors, file, modeName) {
+    const annotated = annotateSuitePaths(suites, []);
+    const matches = resolveSuiteSelectionMatches(annotated, selectors, file);
+    const selected = new Set(matches.map((match) => match.resolvedPath));
+    return cloneSelectedSuites(annotated, selected, file, modeName);
+}
+function annotateSuitePaths(suites, pathParts) {
+    return suites.map((suite) => annotateSuiteNode(suite, pathParts));
+}
+function annotateSuiteNode(suite, pathParts) {
+    const description = String(suite?.description ?? "unknown");
+    const slug = slugifySelectorSegment(description);
+    const nextParts = [...pathParts, slug];
+    const nextSuites = Array.isArray(suite?.suites)
+        ? suite.suites
+        : [];
+    const annotatedSuites = annotateSuitePaths(nextSuites, nextParts);
+    return {
+        ...suite,
+        path: nextParts.join("/"),
+        suites: annotatedSuites,
+    };
+}
+function resolveSuiteSelectionMatches(suites, selectors, file) {
+    const matches = [];
+    for (const selector of selectors) {
+        const normalized = selector.trim();
+        if (!normalized.length)
+            continue;
+        if (normalized.includes("/")) {
+            const resolved = resolveExplicitSuitePath(suites, normalized);
+            if (!resolved) {
+                throw new Error(`No suites matched "${selector}" in ${path.basename(file)}.`);
+            }
+            matches.push({
+                kind: "path",
+                raw: selector,
+                resolvedPath: resolved.path,
+                depth: resolved.depth,
+            });
+            continue;
+        }
+        const resolved = resolveBareSuiteSelector(suites, normalized);
+        if (!resolved) {
+            throw new Error(`No suites matched "${selector}" in ${path.basename(file)}.`);
+        }
+        matches.push({
+            kind: "bare",
+            raw: selector,
+            resolvedPath: resolved.path,
+            depth: resolved.depth,
+        });
+    }
+    return matches;
+}
+function resolveExplicitSuitePath(suites, selector) {
+    const normalized = selector
+        .split("/")
+        .map((part) => slugifySelectorSegment(part))
+        .filter((part) => part.length)
+        .join("/");
+    if (!normalized.length)
+        return null;
+    let match = null;
+    walkSuites(suites, (suite, depth) => {
+        if (suite.path == normalized) {
+            match = { path: suite.path, depth };
+            return true;
+        }
+        return false;
+    });
+    return match;
+}
+function resolveBareSuiteSelector(suites, selector) {
+    const slug = slugifySelectorSegment(selector);
+    if (!slug.length)
+        return null;
+    const matches = [];
+    walkSuites(suites, (suite, depth) => {
+        const leaf = String(suite.path ?? "").split("/").pop() ?? "";
+        if (leaf == slug) {
+            matches.push({ path: String(suite.path), depth });
+        }
+        return false;
+    });
+    if (!matches.length)
+        return null;
+    matches.sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path));
+    const shallowest = matches[0];
+    const ambiguous = matches.filter((match) => match.depth == shallowest.depth);
+    if (ambiguous.length > 1) {
+        throw new Error(`Suite selector "${selector}" is ambiguous. Matches: ${ambiguous.map((match) => match.path).join(", ")}`);
+    }
+    return shallowest;
+}
+function walkSuites(suites, visitor, depth = 0) {
+    for (const suite of suites) {
+        if (visitor(suite, depth))
+            return true;
+        const childSuites = Array.isArray(suite?.suites) ? suite.suites : [];
+        if (walkSuites(childSuites, visitor, depth + 1))
+            return true;
+    }
+    return false;
+}
+function cloneSelectedSuites(suites, selected, file, modeName) {
+    const out = [];
+    for (const suite of suites) {
+        const childSuites = Array.isArray(suite.suites) ? suite.suites : [];
+        const selectedChildren = cloneSelectedSuites(childSuites, selected, file, modeName);
+        const keep = selected.has(String(suite.path ?? "")) || selectedChildren.length > 0;
+        if (!keep)
+            continue;
+        out.push({
+            ...suite,
+            file,
+            modeName,
+            suites: selectedChildren,
+        });
+    }
+    return out;
+}
+function slugifySelectorSegment(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function buildSuiteReproCommand(file, suitePath, modeName) {
+    const modeArg = modeName && modeName != "default" ? ` --mode ${modeName}` : "";
+    return `ast run ${file}${modeArg} --suite ${suitePath}`;
+}
 function collectReadableFailures(suites, file, pathParts) {
     const out = [];
     for (const suite of suites) {
@@ -372,6 +508,7 @@ function collectReadableFailures(suites, file, pathParts) {
                 message: String(test.message ?? ""),
                 left: JSON.stringify(test.left ?? ""),
                 right: JSON.stringify(test.right ?? ""),
+                suitePath: String(suiteAny.path ?? ""),
             });
         }
         const childSuites = Array.isArray(suiteAny.suites)
@@ -492,6 +629,9 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
             throw new Error(`Failed to run ${path.basename(file)} in mode ${modeLabel} with ${details}`);
         }
         const normalized = normalizeReport(report);
+        const selectedSuites = options.suiteSelectors?.length
+            ? filterSelectedSuites(normalized.suites, options.suiteSelectors, file, options.modeName ?? "default")
+            : normalized.suites;
         snapshotStore.flush();
         snapshotSummary.matched += snapshotStore.matched;
         snapshotSummary.created += snapshotStore.created;
@@ -500,7 +640,7 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
         reports.push({
             file,
             modeName: options.modeName ?? "default",
-            suites: normalized.suites,
+            suites: selectedSuites,
             coverage: normalized.coverage,
             runCommand: runCommandForLog,
             snapshotSummary: {
@@ -1665,8 +1805,9 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
     if (stderrPendingLine.length && !shouldSuppressWasiWarningLine(stderrPendingLine)) {
         stderrBuffer += stderrPendingLine;
     }
-    if (spawnError) {
-        const errorText = spawnError.stack ?? spawnError.message;
+    const processSpawnError = spawnError;
+    if (processSpawnError) {
+        const errorText = processSpawnError.stack ?? processSpawnError.message;
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,

package/bin/commands/run.js

@@ -1,6 +1,7 @@
 export { createRunReporter, run } from "./run-core.js";
 export async function executeRunCommand(rawArgs, flags, configPath, selectedModes, deps) {
     const commandArgs = deps.resolveCommandArgs(rawArgs, "run");
+    const suiteSelectors = deps.resolveSuiteSelectors(rawArgs, "run");
     const listFlags = deps.resolveListFlags(rawArgs, "run");
     const featureToggles = deps.resolveFeatureToggles(rawArgs, "run");
     const runFlags = {
@@ -20,5 +21,5 @@ export async function executeRunCommand(rawArgs, flags, configPath, selectedMode
         await deps.listExecutionPlan("run", configPath, commandArgs, modeTargets, listFlags);
         return;
     }
-    await deps.runRuntimeModes(runFlags, configPath, commandArgs, modeTargets);
+    await deps.runRuntimeModes(runFlags, configPath, commandArgs, suiteSelectors, modeTargets);
 }

package/bin/commands/test.js

@@ -1,5 +1,7 @@
 export async function executeTestCommand(rawArgs, flags, configPath, selectedModes, deps) {
     const commandArgs = deps.resolveCommandArgs(rawArgs, "test");
+    const suiteSelectors = deps.resolveSuiteSelectors(rawArgs, "test");
+    const fuzzerSelectors = deps.resolveFuzzerSelectors(rawArgs, "test");
     const listFlags = deps.resolveListFlags(rawArgs, "test");
     const featureToggles = deps.resolveFeatureToggles(rawArgs, "test");
     const buildFeatureToggles = {
@@ -25,5 +27,5 @@ export async function executeTestCommand(rawArgs, flags, configPath, selectedMod
         await deps.listExecutionPlan("test", configPath, commandArgs, modeTargets, listFlags, fuzzEnabled);
         return;
     }
-    await deps.runTestModes(runFlags, configPath, commandArgs, modeTargets, buildFeatureToggles, fuzzEnabled, fuzzOverrides);
+    await deps.runTestModes(runFlags, configPath, commandArgs, suiteSelectors, fuzzerSelectors, modeTargets, buildFeatureToggles, fuzzEnabled, fuzzOverrides);
 }