as-test 1.0.12 → 1.0.13

package/bin/index.js

@@ -62,6 +62,7 @@ else if (COMMANDS.includes(args[0])) {
         else if (command === "run") {
             executeRunCommand(_args, flags, configPath, selectedModes, {
                 resolveCommandArgs,
+                resolveSuiteSelectors,
                 resolveListFlags,
                 resolveFeatureToggles,
                 resolveParallelJobs,
@@ -78,6 +79,8 @@ else if (COMMANDS.includes(args[0])) {
         else if (command === "test") {
             executeTestCommand(_args, flags, configPath, selectedModes, {
                 resolveCommandArgs,
+                resolveSuiteSelectors,
+                resolveFuzzerSelectors,
                 resolveListFlags,
                 resolveFeatureToggles,
                 resolveParallelJobs,
@@ -95,6 +98,7 @@ else if (COMMANDS.includes(args[0])) {
         else if (command === "fuzz") {
             executeFuzzCommand(_args, configPath, selectedModes, {
                 resolveCommandArgs,
+                resolveFuzzerSelectors,
                 resolveListFlags,
                 resolveJobs,
                 resolveExecutionModes,
@@ -252,6 +256,8 @@ function printCommandHelp(command) {
         process.stdout.write("  --overwrite-snapshots    Overwrite existing snapshot entries on mismatch\n");
         process.stdout.write("  --no-snapshot            Disable snapshot assertions for this run\n");
         process.stdout.write("  --show-coverage          Print uncovered coverage point details\n");
+        process.stdout.write("  --suite <name[,name...]> Filter results to matching suite names or suite slug paths\n");
+        process.stdout.write("  --suites <name[,name...]> Alias for --suite\n");
         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("  --reporter <name|path>   Use built-in reporter (default|tap) or custom module path\n");
@@ -278,6 +284,8 @@ function printCommandHelp(command) {
         process.stdout.write("  --overwrite-snapshots    Overwrite existing snapshot entries on mismatch\n");
         process.stdout.write("  --no-snapshot            Disable snapshot assertions for this run\n");
         process.stdout.write("  --show-coverage          Print uncovered coverage point details\n");
+        process.stdout.write("  --suite <name[,name...]> Filter results to matching suite names or suite slug paths\n");
+        process.stdout.write("  --suites <name[,name...]> Alias for --suite\n");
         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");
@@ -304,6 +312,10 @@ function printCommandHelp(command) {
         process.stdout.write("  --mode <name[,name...]>  Run one or multiple named config modes\n");
         process.stdout.write("  --runs <value>           Override fuzz iteration count, e.g. 500, 1.5x, +10%, +100000\n");
         process.stdout.write("  --seed <n>               Pin fuzz seed (default uses random seed)\n");
+        process.stdout.write("  --fuzzer <name[,name...]> Filter results to matching fuzz target names\n");
+        process.stdout.write("  --fuzzers <name[,name...]> Alias for --fuzzer\n");
+        process.stdout.write("  --suite <name[,name...]> Alias for --fuzzer\n");
+        process.stdout.write("  --suites <name[,name...]> Alias for --fuzzer\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");
         process.stdout.write("  --run-jobs <n>           Limit concurrent run tasks (defaults to --jobs)\n");
@@ -384,9 +396,22 @@ function resolveCommandArgs(rawArgs, command) {
             i++;
             continue;
         }
+        if (arg == "--suite" ||
+            arg == "--suites" ||
+            arg == "--fuzzer" ||
+            arg == "--fuzzers") {
+            i++;
+            continue;
+        }
         if (arg.startsWith("--reporter=")) {
             continue;
         }
+        if (arg.startsWith("--suite=") ||
+            arg.startsWith("--suites=") ||
+            arg.startsWith("--fuzzer=") ||
+            arg.startsWith("--fuzzers=")) {
+            continue;
+        }
         if (arg == "--tap") {
             continue;
         }
@@ -500,6 +525,47 @@ function resolveFuzzOverrides(rawArgs, command) {
     }
     return out;
 }
+function resolveSuiteSelectors(rawArgs, command) {
+    return resolveNamedSelectors(rawArgs, command, ["--suite", "--suites"]);
+}
+function resolveFuzzerSelectors(rawArgs, command) {
+    const flags = command == "fuzz"
+        ? ["--fuzzer", "--fuzzers", "--suite", "--suites"]
+        : ["--fuzzer", "--fuzzers"];
+    return resolveNamedSelectors(rawArgs, command, flags);
+}
+function resolveNamedSelectors(rawArgs, command, flags) {
+    const out = [];
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == command)
+                seenCommand = true;
+            continue;
+        }
+        let parsed = null;
+        for (const flag of flags) {
+            parsed = parseStringFlag(rawArgs, i, flag);
+            if (parsed)
+                break;
+        }
+        if (!parsed)
+            continue;
+        appendNamedSelectorTokens(out, parsed.value);
+        if (parsed.consumeNext)
+            i++;
+    }
+    return [...new Set(out)];
+}
+function appendNamedSelectorTokens(out, value) {
+    for (const token of value.split(",")) {
+        const normalized = token.trim();
+        if (!normalized.length)
+            continue;
+        out.push(normalized);
+    }
+}
 function parseFuzzRunsFlag(rawArgs, index, flag) {
     const arg = rawArgs[index];
     let value = "";
@@ -996,7 +1062,7 @@ async function buildFileForMode(cache, args) {
     }
     return false;
 }
-async function runTestSequential(runFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, allowNoSpecFiles = false, modeName, reporterOverride, emitRunComplete = true) {
+async function runTestSequential(runFlags, configPath, selectors, suiteSelectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, allowNoSpecFiles = false, modeName, reporterOverride, emitRunComplete = true) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
         if (!allowNoSpecFiles) {
@@ -1025,6 +1091,7 @@ async function runTestSequential(runFlags, configPath, selectors, buildFeatureTo
         const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
         const result = await run(runFlags, configPath, [file], false, {
             reporter,
+            suiteSelectors,
             emitRunStart: false,
             emitRunComplete: false,
             logFileName: `test.${artifactKey}.log.json`,
@@ -1113,7 +1180,7 @@ async function runBuildModes(configPath, selectors, modes, buildFeatureToggles,
     }
     process.stdout.write(`${chalk.bold("Summary:")} built ${builtCount} file(s) across ${modes.length || 1} mode(s) in ${formatTime(Date.now() - allStartedAt)}\n`);
 }
-async function runRuntimeModes(runFlags, configPath, selectors, modes) {
+async function runRuntimeModes(runFlags, configPath, selectors, suiteSelectors, modes) {
     await ensureWebBrowsersReady(configPath, modes, runFlags.browser);
     const modeSummaryTotal = Math.max(modes.length, 1);
     const fileSummaryTotal = await resolveConfiguredFileTotal(configPath);
@@ -1123,13 +1190,13 @@ async function runRuntimeModes(runFlags, configPath, selectors, modes) {
     };
     if (effectiveRunFlags.jobs > 1) {
         if (modes.length > 1) {
-            const failed = await runRuntimeMatrixParallel(effectiveRunFlags, configPath, selectors, modes, modeSummaryTotal, fileSummaryTotal);
+            const failed = await runRuntimeMatrixParallel(effectiveRunFlags, configPath, selectors, suiteSelectors, modes, modeSummaryTotal, fileSummaryTotal);
             process.exit(failed ? 1 : 0);
             return;
         }
         let failed = false;
         for (const modeName of modes) {
-            const result = await runRuntimeSingleParallel(effectiveRunFlags, configPath, selectors, modeName, modeSummaryTotal, fileSummaryTotal);
+            const result = await runRuntimeSingleParallel(effectiveRunFlags, configPath, selectors, suiteSelectors, modeName, modeSummaryTotal, fileSummaryTotal);
             if (result)
                 failed = true;
         }
@@ -1137,7 +1204,7 @@ async function runRuntimeModes(runFlags, configPath, selectors, modes) {
         return;
     }
     if (modes.length > 1) {
-        const failed = await runRuntimeMatrix(effectiveRunFlags, configPath, selectors, modes, modeSummaryTotal, fileSummaryTotal);
+        const failed = await runRuntimeMatrix(effectiveRunFlags, configPath, selectors, suiteSelectors, modes, modeSummaryTotal, fileSummaryTotal);
         process.exit(failed ? 1 : 0);
         return;
     }
@@ -1147,6 +1214,7 @@ async function runRuntimeModes(runFlags, configPath, selectors, modes) {
         const result = await run(effectiveRunFlags, configPath, selectors, false, {
             reporterPath: effectiveRunFlags.reporterPath,
             modeName,
+            suiteSelectors,
             modeSummaryTotal,
             modeSummaryExecuted: 1,
             fileSummaryTotal,
@@ -1157,7 +1225,7 @@ async function runRuntimeModes(runFlags, configPath, selectors, modes) {
     }
     process.exit(failed ? 1 : 0);
 }
-async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSummaryTotal, fileSummaryTotal) {
+async function runRuntimeMatrix(runFlags, configPath, selectors, suiteSelectors, modes, modeSummaryTotal, fileSummaryTotal) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
@@ -1205,6 +1273,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
                 const result = await run(runFlags, configPath, [file], false, {
                     reporter: silentReporter,
                     reporterKind: "default",
+                    suiteSelectors,
                     emitRunStart: false,
                     emitRunComplete: false,
                     logFileName: `run.${artifactKey}.log.json`,
@@ -1256,7 +1325,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
     });
     return allResults.some((result) => result.failed);
 }
-async function runTestModes(runFlags, configPath, selectors, modes, buildFeatureToggles, fuzzEnabled, fuzzOverrides) {
+async function runTestModes(runFlags, configPath, selectors, suiteSelectors, fuzzerSelectors, modes, buildFeatureToggles, fuzzEnabled, fuzzOverrides) {
     await ensureWebBrowsersReady(configPath, modes, runFlags.browser);
     const modeSummaryTotal = Math.max(modes.length, 1);
     const fileSummaryTotal = await resolveConfiguredFileTotal(configPath, selectors);
@@ -1266,13 +1335,13 @@ async function runTestModes(runFlags, configPath, selectors, modes, buildFeature
     };
     if (effectiveRunFlags.jobs > 1) {
         if (modes.length > 1) {
-            const failed = await runTestMatrixParallel(effectiveRunFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides);
+            const failed = await runTestMatrixParallel(effectiveRunFlags, configPath, selectors, suiteSelectors, fuzzerSelectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides);
             process.exit(failed ? 1 : 0);
             return;
         }
         let failed = false;
         for (const modeName of modes) {
-            const modeFailed = await runTestSingleParallel(effectiveRunFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides, modeName);
+            const modeFailed = await runTestSingleParallel(effectiveRunFlags, configPath, selectors, suiteSelectors, fuzzerSelectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides, modeName);
             if (modeFailed)
                 failed = true;
         }
@@ -1280,21 +1349,21 @@ async function runTestModes(runFlags, configPath, selectors, modes, buildFeature
         return;
     }
     if (modes.length > 1) {
-        const failed = await runTestMatrix(effectiveRunFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides);
+        const failed = await runTestMatrix(effectiveRunFlags, configPath, selectors, suiteSelectors, fuzzerSelectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides);
         process.exit(failed ? 1 : 0);
         return;
     }
     let failed = false;
     for (const modeName of modes) {
         const reporterSession = await createRunReporter(configPath, effectiveRunFlags.reporterPath, modeName);
-        const modeResult = await runTestSequential(effectiveRunFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, modeName, reporterSession.reporter, !fuzzEnabled);
+        const modeResult = await runTestSequential(effectiveRunFlags, configPath, selectors, suiteSelectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, modeName, reporterSession.reporter, !fuzzEnabled);
         if (modeResult.failed)
             failed = true;
         if (fuzzEnabled) {
             if (reporterSession.reporterKind == "default") {
                 process.stdout.write("\n");
             }
-            const fuzzResults = await runFuzzMatrixResults(configPath, selectors, [modeName], fuzzOverrides, reporterSession.reporter);
+            const fuzzResults = await runFuzzMatrixResults(configPath, selectors, fuzzerSelectors, [modeName], fuzzOverrides, reporterSession.reporter);
             if (fuzzResults.some(hasFuzzFailures))
                 failed = true;
             reporterSession.reporter.onRunComplete?.({
@@ -1315,7 +1384,7 @@ async function runTestModes(runFlags, configPath, selectors, modes, buildFeature
     }
     process.exit(failed ? 1 : 0);
 }
-async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides) {
+async function runTestMatrix(runFlags, configPath, selectors, suiteSelectors, fuzzerSelectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
         if (!fuzzEnabled) {
@@ -1420,7 +1489,7 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
         if (reporterSession.reporterKind == "default") {
             process.stdout.write("\n");
         }
-        const fuzzResults = await runFuzzMatrixResults(configPath, selectors, modes, fuzzOverrides, reporter);
+        const fuzzResults = await runFuzzMatrixResults(configPath, selectors, fuzzerSelectors, modes, fuzzOverrides, reporter);
         if (fuzzResults.some(hasFuzzFailures))
             failed = true;
         fuzzSummary = summarizeFuzzExecutions(fuzzResults);
@@ -1441,14 +1510,14 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
     reporter.flush?.();
     return failed;
 }
-async function runFuzzModes(configPath, selectors, modes, rawArgs) {
+async function runFuzzModes(configPath, selectors, fuzzerSelectors, modes, rawArgs) {
     const overrides = resolveFuzzOverrides(rawArgs, "fuzz");
     const parallelSettings = resolveFuzzParallelJobs(rawArgs);
     const clean = rawArgs.includes("--clean");
     const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors);
     const { jobs, buildJobs, runJobs } = resolveEffectiveParallelJobs(parallelSettings, fuzzFiles.length);
     if (jobs > 1) {
-        const results = await runFuzzMatrixResultsParallel(configPath, selectors, modes, overrides, jobs, buildJobs, runJobs, clean);
+        const results = await runFuzzMatrixResultsParallel(configPath, selectors, fuzzerSelectors, modes, overrides, jobs, buildJobs, runJobs, clean);
         const reporterSession = await createRunReporter(configPath);
         reporterSession.reporter.onFuzzComplete?.(buildFuzzCompleteEvent(results, modes));
         reporterSession.reporter.flush?.();
@@ -1456,12 +1525,12 @@ async function runFuzzModes(configPath, selectors, modes, rawArgs) {
         return;
     }
     const reporterSession = await createRunReporter(configPath);
-    const results = await runFuzzMatrixResults(configPath, selectors, modes, overrides, reporterSession.reporter);
+    const results = await runFuzzMatrixResults(configPath, selectors, fuzzerSelectors, modes, overrides, reporterSession.reporter);
     reporterSession.reporter.onFuzzComplete?.(buildFuzzCompleteEvent(results, modes));
     reporterSession.reporter.flush?.();
     process.exit(results.some(hasFuzzFailures) ? 1 : 0);
 }
-async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeName, modeSummaryTotal, fileSummaryTotal) {
+async function runRuntimeSingleParallel(runFlags, configPath, selectors, suiteSelectors, modeName, modeSummaryTotal, fileSummaryTotal) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
@@ -1493,6 +1562,7 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeNam
             reporter: buffered?.reporter,
             reporterKind: buffered?.reporterKind,
             modeName,
+            suiteSelectors,
             emitRunComplete: false,
             fileSummaryTotal: 1,
             modeSummaryTotal,
@@ -1522,7 +1592,7 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeNam
     reporter.flush?.();
     return results.some((result) => result.failed);
 }
-async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes, modeSummaryTotal, fileSummaryTotal) {
+async function runRuntimeMatrixParallel(runFlags, configPath, selectors, suiteSelectors, modes, modeSummaryTotal, fileSummaryTotal) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
@@ -1572,6 +1642,7 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes,
                 const result = await run(runFlags, configPath, [file], false, {
                     reporter: silentReporter,
                     reporterKind: "default",
+                    suiteSelectors,
                     emitRunStart: false,
                     emitRunComplete: false,
                     logFileName: `run.${artifactKey}.log.json`,
@@ -1627,7 +1698,7 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes,
     reporter.flush?.();
     return allResults.some((result) => result.failed);
 }
-async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides, modeName) {
+async function runTestSingleParallel(runFlags, configPath, selectors, suiteSelectors, fuzzerSelectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides, modeName) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length && !fuzzEnabled) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
@@ -1672,6 +1743,7 @@ async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatu
                 const result = await run({ ...runFlags, clean: true }, configPath, [file], false, {
                     reporter: buffered?.reporter,
                     reporterKind: buffered?.reporterKind,
+                    suiteSelectors,
                     emitRunComplete: false,
                     logFileName: `test.${artifactKey}.log.json`,
                     coverageFileName: `coverage.${artifactKey}.log.json`,
@@ -1699,7 +1771,7 @@ async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatu
         if (reporterSession.reporterKind == "default") {
             process.stdout.write("\n");
         }
-        const fuzzResults = await runFuzzMatrixResultsParallel(configPath, selectors, [modeName], fuzzOverrides, runFlags.jobs, runFlags.buildJobs, runFlags.runJobs, runFlags.clean);
+        const fuzzResults = await runFuzzMatrixResultsParallel(configPath, selectors, fuzzerSelectors, [modeName], fuzzOverrides, runFlags.jobs, runFlags.buildJobs, runFlags.runJobs, runFlags.clean);
         if (fuzzResults.some(hasFuzzFailures))
             failed = true;
         fuzzSummary = summarizeFuzzExecutions(fuzzResults);
@@ -1720,7 +1792,7 @@ async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatu
     reporter.flush?.();
     return failed;
 }
-async function runTestMatrixParallel(runFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides) {
+async function runTestMatrixParallel(runFlags, configPath, selectors, suiteSelectors, fuzzerSelectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
         if (!fuzzEnabled) {
@@ -1776,6 +1848,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
                 const result = await run(runFlags, configPath, [file], false, {
                     reporter: silentReporter,
                     reporterKind: "default",
+                    suiteSelectors,
                     emitRunStart: false,
                     emitRunComplete: false,
                     logFileName: `test.${artifactKey}.log.json`,
@@ -1823,7 +1896,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
         if (reporterSession.reporterKind == "default") {
             process.stdout.write("\n");
         }
-        const fuzzResults = await runFuzzMatrixResultsParallel(configPath, selectors, modes, fuzzOverrides, runFlags.jobs, runFlags.buildJobs, runFlags.runJobs, runFlags.clean);
+        const fuzzResults = await runFuzzMatrixResultsParallel(configPath, selectors, fuzzerSelectors, modes, fuzzOverrides, runFlags.jobs, runFlags.buildJobs, runFlags.runJobs, runFlags.clean);
         if (fuzzResults.some(hasFuzzFailures))
             failed = true;
         fuzzSummary = summarizeFuzzExecutions(fuzzResults);
@@ -1844,7 +1917,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
     reporter.flush?.();
     return failed;
 }
-async function runFuzzMatrixResultsParallel(configPath, selectors, modes, overrides, jobs, buildJobs, runJobs, clean) {
+async function runFuzzMatrixResultsParallel(configPath, selectors, fuzzerSelectors, modes, overrides, jobs, buildJobs, runJobs, clean) {
     const files = await resolveSelectedFuzzFiles(configPath, selectors);
     if (!files.length) {
         throw new Error(`No fuzz files matched: ${selectors.length ? selectors.join(", ") : "configured input patterns"}`);
@@ -1856,7 +1929,7 @@ async function runFuzzMatrixResultsParallel(configPath, selectors, modes, overri
         const token = renderQueuedFileStart(queueDisplay, path.basename(file));
         const fileResults = [];
         for (const modeName of modes) {
-            const modeResults = await fuzz(configPath, [file], modeName, overrides);
+            const modeResults = await fuzz(configPath, [file], modeName, overrides, fuzzerSelectors);
             fileResults.push(...modeResults);
         }
         ordered[index] = fileResults;
@@ -1868,7 +1941,7 @@ async function runFuzzMatrixResultsParallel(configPath, selectors, modes, overri
     queueDisplay.flush();
     return ordered.flat();
 }
-async function runFuzzMatrixResults(configPath, selectors, modes, overrides, reporter) {
+async function runFuzzMatrixResults(configPath, selectors, fuzzerSelectors, modes, overrides, reporter) {
     const files = await resolveSelectedFuzzFiles(configPath, selectors);
     if (!files.length) {
         throw new Error(`No fuzz files matched: ${selectors.length ? selectors.join(", ") : "configured input patterns"}`);
@@ -1877,7 +1950,7 @@ async function runFuzzMatrixResults(configPath, selectors, modes, overrides, rep
     for (const file of files) {
         const fileResults = [];
         for (const modeName of modes) {
-            const modeResults = await fuzz(configPath, [file], modeName, overrides);
+            const modeResults = await fuzz(configPath, [file], modeName, overrides, fuzzerSelectors);
             fileResults.push(...modeResults);
             results.push(...modeResults);
         }

package/bin/reporters/default.js

@@ -329,7 +329,7 @@ function renderFailedFuzzers(results) {
     for (const result of results) {
         for (const modeResult of result.modes) {
             const relativeFile = toRelativeResultPath(modeResult.file);
-            const repro = buildFuzzReproCommand(relativeFile, modeResult.seed, modeResult.modeName);
+            const repro = buildFuzzReproCommand(relativeFile, modeResult.seed, modeResult.modeName, modeResult.fuzzers[0]?.selector);
             if (modeResult.crashes > 0 && !modeResult.fuzzers.length) {
                 if (!rendered) {
                     console.log("");
@@ -353,18 +353,19 @@ function renderFailedFuzzers(results) {
                     console.log("");
                     rendered = true;
                 }
+                const fuzzerRepro = buildFuzzReproCommand(relativeFile, modeResult.seed, modeResult.modeName, fuzzer.selector);
                 console.log(`${chalk.bgRed(" FAIL ")} ${formatFuzzFailureTitle(modeResult.file, fuzzer.name)}`);
                 if (fuzzer.failure) {
                     renderAssertionFailureDetails(fuzzer.failure.left, fuzzer.failure.right, fuzzer.failure.message);
                 }
                 console.log(chalk.dim(`Mode: ${modeResult.modeName}`));
                 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(`Repro: ${fuzzerRepro}`));
                 console.log(chalk.dim(`Seed: ${modeResult.seed}`));
                 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)}`));
+                        console.log(chalk.dim(`Repro ${failure.run + 1}: ${buildFuzzReproCommand(relativeFile, failure.seed, modeResult.modeName, fuzzer.selector, 1)}`));
                         if (failure.input) {
                             console.log(chalk.dim(`Input ${failure.run + 1}: ${JSON.stringify(failure.input)}`));
                         }
@@ -405,10 +406,11 @@ function averageFuzzModeTime(results) {
         return 0;
     return results.reduce((sum, result) => sum + result.time, 0) / results.length;
 }
-function buildFuzzReproCommand(file, seed, modeName, runs) {
+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 formatFailingSeeds(fuzzer) {
     return (fuzzer.failures ?? []).map((failure) => String(failure.seed)).join(", ");
@@ -467,9 +469,10 @@ function renderFailedSuites(failedEntries) {
         collectSuiteFailures(failed, file, [], printed);
     }
 }
-function collectSuiteFailures(suite, file, path, printed) {
+function collectSuiteFailures(suite, file, path, printed, inheritedModeName = "") {
     const suiteAny = suite;
     const nextPath = [...path, String(suiteAny.description ?? "unknown")];
+    const modeName = String(suiteAny.modeName ?? inheritedModeName);
     const tests = Array.isArray(suiteAny.tests)
         ? suiteAny.tests
         : [];
@@ -481,7 +484,7 @@ function collectSuiteFailures(suite, file, path, printed) {
         const title = `${nextPath.join(" > ")}#${assertionIndex}`;
         const loc = String(test.location ?? "");
         const where = loc.length ? `${file}:${loc}` : file;
-        const modeName = String(suiteAny.modeName ?? "");
+        const suitePath = String(suiteAny.path ?? "");
         const message = String(test.message ?? "");
         const dedupeKey = `${file}::${modeName}::${title}::${String(test.left)}::${String(test.right)}::${message}`;
         if (printed.has(dedupeKey))
@@ -491,15 +494,22 @@ function collectSuiteFailures(suite, file, path, printed) {
         if (modeName.length) {
             console.log(chalk.dim(`Mode: ${modeName}`));
         }
+        if (suitePath.length) {
+            console.log(chalk.dim(`Repro: ${buildSuiteReproCommand(toRelativeResultPath(file), suitePath, modeName)}`));
+        }
         renderAssertionFailureDetails(test.left, test.right, message);
     }
     const suites = Array.isArray(suiteAny.suites)
         ? suiteAny.suites
         : [];
     for (const sub of suites) {
-        collectSuiteFailures(sub, file, nextPath, printed);
+        collectSuiteFailures(sub, file, nextPath, printed, modeName);
     }
 }
+function buildSuiteReproCommand(file, suitePath, modeName) {
+    const modeArg = modeName && modeName != "default" ? ` --mode ${modeName}` : "";
+    return `ast run ${file}${modeArg} --suite ${suitePath}`;
+}
 function normalizeFailureMessage(message) {
     return message.replace(/\r\n/g, "\n").trim();
 }

package/bin/util.js

@@ -1111,7 +1111,7 @@ export function getPkgRunner() {
     return "npx";
 }
 export function getExec(exec) {
-    const PATH = process.env.PATH.split(delimiter);
+    const PATH = (process.env.PATH ?? "").split(delimiter);
     for (const pathDir of PATH) {
         const fullPath = join(pathDir, exec + (process.platform === "win32" ? ".exe" : ""));
         if (existsSync(fullPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -10,22 +10,22 @@
     "as-rainbow": "^0.1.0",
     "as-console": "^7.0.0",
     "chalk": "^5.6.2",
-    "glob": "^13.0.3",
+    "glob": "^13.0.6",
     "typer-diff": "^1.1.1",
     "wipc-js": "^0.1.1"
   },
   "devDependencies": {
     "@assemblyscript/wasi-shim": "^0.1.0",
     "@eslint/js": "^10.0.1",
-    "@types/node": "^25.2.3",
+    "@types/node": "^25.6.0",
     "as-sleep": "^0.0.2",
     "as-test": "./",
-    "assemblyscript": "^0.28.9",
+    "assemblyscript": "^0.28.17",
     "assemblyscript-prettier": "^3.0.4",
-    "prettier": "3.8.1",
-    "try-as": "^0.2.5",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.55.0",
+    "prettier": "3.8.3",
+    "try-as": "^1.0.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.1",
     "vitepress": "^1.6.4"
   },
   "bin": {

package/transform/lib/builder.js

@@ -488,11 +488,11 @@ export class ASTBuilder extends Visitor {
     }
     visitUnaryExpression(node) {
         switch (node.kind) {
-            case 27: {
+            case 28: {
                 this.visitUnaryPostfixExpression(node);
                 break;
             }
-            case 28: {
+            case 29: {
                 this.visitUnaryPrefixExpression(node);
                 break;
             }
@@ -512,8 +512,8 @@ export class ASTBuilder extends Visitor {
         this.visitNode(node);
         const sb = this.sb;
         if (!sb.length ||
-            node.kind == 47 ||
-            node.kind == 38) {
+            node.kind == 48 ||
+            node.kind == 39) {
             sb.push(";\n");
         }
         else {
@@ -629,7 +629,7 @@ export class ASTBuilder extends Visitor {
             }
             for (let i = 0, k = members.length; i < k; ++i) {
                 const member = members[i];
-                if (member.kind != 54 ||
+                if (member.kind != 55 ||
                     member.parameterIndex < 0) {
                     util.indent(sb, indentLevel);
                     this.visitNodeAndTerminate(member);
@@ -646,7 +646,7 @@ export class ASTBuilder extends Visitor {
         const sb = this.sb;
         sb.push("do ");
         this.visitNode(node.body);
-        if (node.body.kind == 30) {
+        if (node.body.kind == 31) {
             sb.push(" while (");
         }
         else {
@@ -748,23 +748,23 @@ export class ASTBuilder extends Visitor {
     visitExportDefaultStatement(node) {
         const declaration = node.declaration;
         switch (declaration.kind) {
-            case 52: {
+            case 53: {
                 this.visitEnumDeclaration(declaration, true);
                 break;
             }
-            case 55: {
+            case 56: {
                 this.visitFunctionDeclaration(declaration, true);
                 break;
             }
-            case 51: {
+            case 52: {
                 this.visitClassDeclaration(declaration, true);
                 break;
             }
-            case 57: {
+            case 58: {
                 this.visitInterfaceDeclaration(declaration, true);
                 break;
             }
-            case 59: {
+            case 60: {
                 this.visitNamespaceDeclaration(declaration, true);
                 break;
             }
@@ -946,12 +946,12 @@ export class ASTBuilder extends Visitor {
         sb.push(") ");
         const ifTrue = node.ifTrue;
         this.visitNode(ifTrue);
-        if (ifTrue.kind != 30) {
+        if (ifTrue.kind != 31) {
             sb.push(";\n");
         }
         const ifFalse = node.ifFalse;
         if (ifFalse) {
-            if (ifTrue.kind == 30) {
+            if (ifTrue.kind == 31) {
                 sb.push(" else ");
             }
             else {
@@ -1263,7 +1263,7 @@ export class ASTBuilder extends Visitor {
         sb.push("while (");
         this.visitNode(node.condition);
         const statement = node.body;
-        if (statement.kind == 34) {
+        if (statement.kind == 35) {
             sb.push(")");
         }
         else {
@@ -1358,4 +1358,3 @@ export class ASTBuilder extends Visitor {
         return ret;
     }
 }
-//# sourceMappingURL=builder.js.map