as-test 1.0.1 → 1.0.4

package/bin/index.js

@@ -1,19 +1,26 @@
 #!/usr/bin/env node
 import chalk from "chalk";
-import { build } from "./commands/build.js";
+import { build, formatInvocation as formatBuildInvocation, getBuildInvocationPreview, } from "./commands/build.js";
 import { createRunReporter, run } from "./commands/run.js";
 import { executeBuildCommand } from "./commands/build.js";
 import { executeRunCommand } from "./commands/run.js";
 import { executeTestCommand } from "./commands/test.js";
+import { executeFuzzCommand } from "./commands/fuzz.js";
 import { executeInitCommand } from "./commands/init.js";
 import { executeDoctorCommand } from "./commands/doctor.js";
-import { applyMode, getCliVersion, loadConfig, resolveModeNames, } from "./util.js";
+import { fuzz } from "./commands/fuzz-core.js";
+import { applyMode, formatTime, getCliVersion, loadConfig, resolveModeNames, } from "./util.js";
 import * as path from "path";
+import { spawnSync } from "child_process";
 import { glob } from "glob";
+import { createInterface } from "readline";
+import { existsSync } from "fs";
+import { availableParallelism, cpus } from "os";
+import { BuildWorkerPool } from "./build-worker-pool.js";
 const _args = process.argv.slice(2);
 const flags = [];
 const args = [];
-const COMMANDS = ["run", "build", "test", "init", "doctor"];
+const COMMANDS = ["run", "build", "test", "fuzz", "init", "doctor"];
 const version = getCliVersion();
 const configPath = resolveConfigPath(_args);
 const selectedModes = resolveModeNames(_args);
@@ -25,7 +32,7 @@ for (const arg of _args) {
 }
 if (!args.length) {
     if (flags.includes("--version") || flags.includes("-v")) {
-        console.log("as-test v" + version.toString());
+        console.log(version.toString());
     }
     else {
         info();
@@ -43,6 +50,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveCommandArgs,
                 resolveListFlags,
                 resolveFeatureToggles,
+                resolveBuildParallelJobs,
                 resolveExecutionModes,
                 listExecutionPlan,
                 runBuildModes,
@@ -56,6 +64,8 @@ else if (COMMANDS.includes(args[0])) {
                 resolveCommandArgs,
                 resolveListFlags,
                 resolveFeatureToggles,
+                resolveParallelJobs,
+                resolveBrowserOverride,
                 resolveExecutionModes,
                 listExecutionPlan,
                 runRuntimeModes,
@@ -69,6 +79,9 @@ else if (COMMANDS.includes(args[0])) {
                 resolveCommandArgs,
                 resolveListFlags,
                 resolveFeatureToggles,
+                resolveParallelJobs,
+                resolveBrowserOverride,
+                resolveFuzzOverrides,
                 resolveExecutionModes,
                 listExecutionPlan,
                 runTestModes,
@@ -77,6 +90,19 @@ else if (COMMANDS.includes(args[0])) {
                 process.exit(1);
             });
         }
+        else if (command === "fuzz") {
+            executeFuzzCommand(_args, configPath, selectedModes, {
+                resolveCommandArgs,
+                resolveListFlags,
+                resolveJobs,
+                resolveExecutionModes,
+                listExecutionPlan,
+                runFuzzModes,
+            }).catch((error) => {
+                printCliError(error);
+                process.exit(1);
+            });
+        }
         else if (command === "init") {
             executeInitCommand(_args, {
                 resolveCommandTokens,
@@ -139,6 +165,13 @@ function info() {
         "  " +
         "Build and run unit tests with selected runtime" +
         "\n");
+    console.log("  " +
+        chalk.bold.blueBright("fuzz") +
+        "    " +
+        chalk.dim("<name>|<path-or-glob>") +
+        "  " +
+        "Build and run fuzz targets" +
+        "\n");
     console.log("  " +
         chalk.bold.magentaBright("init") +
         "    " +
@@ -153,63 +186,19 @@ function info() {
         "Validate environment/config/runtime setup");
     console.log("");
     console.log(chalk.bold("Flags:"));
-    console.log("   " +
-        chalk.bold.blue("--mode <name[,name...]>") +
-        "       " +
-        "Run one or multiple named config modes");
-    console.log("   " +
-        chalk.bold.blue("--config <path>") +
-        "               " +
-        "Use a specific config file");
-    console.log("   " +
-        chalk.bold.blue("--snapshot") +
-        "                    " +
-        "Snapshot assertions (enabled by default)");
-    console.log("   " +
-        chalk.bold.blue("--update-snapshots") +
-        "            " +
-        "Create/update snapshot files on mismatch");
-    console.log("   " +
-        chalk.bold.blue("--no-snapshot") +
-        "                 " +
-        "Disable snapshot assertions for this run");
-    console.log("   " +
-        chalk.bold.blue("--show-coverage") +
-        "               " +
-        "Print all coverage points with line:column refs");
-    console.log("   " +
-        chalk.bold.blue("--enable <feature>") +
-        "            " +
-        "Enable as-test feature (coverage|try-as)");
-    console.log("   " +
-        chalk.bold.blue("--disable <feature>") +
-        "           " +
-        "Disable as-test feature (coverage|try-as)");
-    console.log("   " +
-        chalk.bold.blue("--verbose") +
-        "                     " +
-        "Print each suite start/end line");
-    console.log("   " +
-        chalk.bold.blue("--reporter <name|path>") +
-        "        " +
-        "Use built-in reporter (default|tap) or custom module path");
-    console.log("   " +
-        chalk.bold.blue("--list") +
-        "                        " +
-        "Preview resolved files/modes/artifacts without running");
-    console.log("   " +
-        chalk.bold.blue("--list-modes") +
+    console.log("  " +
+        chalk.bold.blue("--version, -v") +
         "                  " +
-        "Preview configured and selected mode names");
-    console.log("   " + chalk.bold.blue("--help, -h") + "                    Show help");
+        "Print current cli version");
+    console.log("  " +
+        chalk.bold.blue("--help, -h") +
+        "                     Show help menu");
     console.log("");
-    console.log(chalk.dim("If your using this, consider dropping a star, it would help a lot!") + "\n");
+    console.log(chalk.dim("If this tool provides value, please consider sponsoring my open-source work! https://jairus.dev/sponsor") + "\n");
+    console.log("View the docs:                   " +
+        chalk.blue("https://docs.jairus.dev/as-test"));
     console.log("View the repo:                   " +
-        chalk.magenta("https://github.com/JairusSW/as-test"));
-    // console.log(
-    //   "View the docs:                   " +
-    //     chalk.blue("https://docs.jairus.dev/as-test"),
-    // );
+        chalk.blue("https://github.com/JairusSW/as-test"));
 }
 function isHelpFlag(value) {
     return value == "--help" || value == "-h";
@@ -238,6 +227,9 @@ function printCommandHelp(command) {
         process.stdout.write("  --mode <name[,name...]>  Run one or multiple named config modes\n");
         process.stdout.write("  --enable <feature>       Enable build feature (coverage|try-as)\n");
         process.stdout.write("  --disable <feature>      Disable build feature (coverage|try-as)\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");
+        process.stdout.write("  --build-jobs <n>         Limit concurrent build tasks (defaults to --jobs)\n");
         process.stdout.write("  --list                   Preview resolved files/artifacts without building\n");
         process.stdout.write("  --list-modes             Preview configured and selected mode names\n");
         process.stdout.write("  --help, -h               Show this help\n");
@@ -249,7 +241,13 @@ 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("  --update-snapshots       Create/update snapshot files on mismatch\n");
+        process.stdout.write("  --browser <name|path>    Use chrome, chromium, firefox, webkit, or an executable path for web modes\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");
+        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");
+        process.stdout.write("  --create-snapshots       Create missing snapshot entries\n");
+        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("  --enable <feature>       Enable feature (coverage|try-as)\n");
@@ -269,11 +267,24 @@ 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("  --update-snapshots       Create/update snapshot files on mismatch\n");
+        process.stdout.write("  --browser <name|path>    Use chrome, chromium, firefox, webkit, or an executable path for web modes\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");
+        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");
+        process.stdout.write("  --create-snapshots       Create missing snapshot entries\n");
+        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("  --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-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");
+        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");
         process.stdout.write("  --reporter <name|path>   Use built-in reporter (default|tap) or custom module path\n");
         process.stdout.write("  --tap                    Shortcut for --reporter tap\n");
         process.stdout.write("  --verbose                Keep expanded suite/test lines and live updates\n");
@@ -283,11 +294,27 @@ function printCommandHelp(command) {
         process.stdout.write("  --help, -h               Show this help\n");
         return;
     }
+    if (command == "fuzz") {
+        process.stdout.write(chalk.bold("Usage: ast fuzz [selectors...] [flags]\n\n"));
+        process.stdout.write("Build selected fuzz targets with bindings and execute them with generated inputs.\n\n");
+        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("  --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");
+        process.stdout.write("  --run-jobs <n>           Limit concurrent run tasks (defaults to --jobs)\n");
+        process.stdout.write("  --list                   Preview resolved fuzz files without running\n");
+        process.stdout.write("  --list-modes             Preview configured and selected mode names\n");
+        process.stdout.write("  --help, -h               Show this help\n");
+        return;
+    }
     if (command == "init") {
         process.stdout.write(chalk.bold("Usage: ast init [dir] [flags]\n\n"));
         process.stdout.write("Initialize as-test config, default runners, and example specs.\n\n");
         process.stdout.write(chalk.bold("Flags:\n"));
-        process.stdout.write("  --target <wasi|bindings>                Set build target\n");
+        process.stdout.write("  --target <wasi|bindings|web>            Set build target\n");
         process.stdout.write("  --example <minimal|full|none>           Set example template\n");
         process.stdout.write("  --install                               Install dependencies after scaffolding\n");
         process.stdout.write("  --yes, -y                               Non-interactive setup with defaults\n");
@@ -361,6 +388,9 @@ function resolveCommandArgs(rawArgs, command) {
         if (arg == "--tap") {
             continue;
         }
+        if (arg == "--fuzz") {
+            continue;
+        }
         if (arg == "--enable" || arg == "--disable") {
             i++;
             continue;
@@ -368,6 +398,28 @@ function resolveCommandArgs(rawArgs, command) {
         if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) {
             continue;
         }
+        if (arg == "--runs" ||
+            arg == "--seed" ||
+            arg == "--parallel" ||
+            arg == "--jobs" ||
+            arg == "--build-jobs" ||
+            arg == "--run-jobs" ||
+            arg == "--browser" ||
+            arg == "--fuzz-runs" ||
+            arg == "--fuzz-seed") {
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--runs=") ||
+            arg.startsWith("--seed=") ||
+            arg.startsWith("--jobs=") ||
+            arg.startsWith("--build-jobs=") ||
+            arg.startsWith("--run-jobs=") ||
+            arg.startsWith("--browser=") ||
+            arg.startsWith("--fuzz-runs=") ||
+            arg.startsWith("--fuzz-seed=")) {
+            continue;
+        }
         if (arg.startsWith("-")) {
             continue;
         }
@@ -407,12 +459,51 @@ function resolveFeatureToggles(rawArgs, command) {
     }
     return out;
 }
+function resolveFuzzOverrides(rawArgs, command) {
+    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;
+        }
+        const direct = command == "fuzz"
+            ? {
+                runs: "--runs",
+                seed: "--seed",
+            }
+            : {
+                runs: "--fuzz-runs",
+                seed: "--fuzz-seed",
+            };
+        const runs = parseNumberFlag(rawArgs, i, direct.runs);
+        if (runs) {
+            out.runs = runs.number;
+            if (runs.consumeNext)
+                i++;
+            continue;
+        }
+        const seed = parseNumberFlag(rawArgs, i, direct.seed);
+        if (seed) {
+            out.seed = seed.number;
+            if (seed.consumeNext)
+                i++;
+            continue;
+        }
+    }
+    return out;
+}
 function resolveListFlags(rawArgs, command) {
     const out = {
         list: false,
         listModes: false,
     };
-    if (command !== "build" && command !== "run" && command !== "test") {
+    if (command !== "build" &&
+        command !== "run" &&
+        command !== "test" &&
+        command !== "fuzz") {
         return out;
     }
     let seenCommand = false;
@@ -430,6 +521,341 @@ function resolveListFlags(rawArgs, command) {
     }
     return out;
 }
+function parseNumberFlag(rawArgs, index, flag) {
+    const arg = rawArgs[index];
+    if (arg == flag) {
+        const next = rawArgs[index + 1];
+        if (!next || next.startsWith("-")) {
+            throw new Error(`${flag} requires a numeric value`);
+        }
+        return {
+            key: flag,
+            number: parseIntegerFlag(flag, next),
+            consumeNext: true,
+        };
+    }
+    if (arg.startsWith(`${flag}=`)) {
+        return {
+            key: flag,
+            number: parseIntegerFlag(flag, arg.slice(flag.length + 1)),
+            consumeNext: false,
+        };
+    }
+    return null;
+}
+function parseStringFlag(rawArgs, index, flag) {
+    const arg = rawArgs[index];
+    if (arg == flag) {
+        const next = rawArgs[index + 1];
+        if (!next || next.startsWith("-")) {
+            throw new Error(`${flag} requires a value`);
+        }
+        return { key: flag, value: next, consumeNext: true };
+    }
+    if (arg.startsWith(`${flag}=`)) {
+        const value = arg.slice(flag.length + 1);
+        if (!value.length) {
+            throw new Error(`${flag} requires a value`);
+        }
+        return { key: flag, value, consumeNext: false };
+    }
+    return null;
+}
+function resolveBrowserOverride(rawArgs, command) {
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == command)
+                seenCommand = true;
+            continue;
+        }
+        const parsed = parseStringFlag(rawArgs, i, "--browser");
+        if (!parsed)
+            continue;
+        return parsed.value.trim() || undefined;
+    }
+    return undefined;
+}
+function resolveJobs(rawArgs, command) {
+    let seenCommand = false;
+    let parallel = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == command)
+                seenCommand = true;
+            continue;
+        }
+        if (arg == "--parallel") {
+            parallel = true;
+            continue;
+        }
+        const parsed = parseNumberFlag(rawArgs, i, "--jobs");
+        if (!parsed)
+            continue;
+        if (parsed.number < 1) {
+            throw new Error("--jobs requires a positive integer");
+        }
+        return parsed.number;
+    }
+    return parallel ? 0 : 1;
+}
+function resolveBuildParallelJobs(rawArgs) {
+    const baseJobs = resolveJobs(rawArgs, "build");
+    let buildJobs = baseJobs;
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == "build")
+                seenCommand = true;
+            continue;
+        }
+        const buildParsed = parseNumberFlag(rawArgs, i, "--build-jobs");
+        if (buildParsed) {
+            if (buildParsed.number < 1) {
+                throw new Error("--build-jobs requires a positive integer");
+            }
+            buildJobs = buildParsed.number;
+            continue;
+        }
+    }
+    const jobs = Math.max(baseJobs, buildJobs);
+    return { jobs, buildJobs };
+}
+function resolveParallelJobs(rawArgs, command) {
+    const baseJobs = resolveJobs(rawArgs, command);
+    let buildJobs = baseJobs;
+    let runJobs = baseJobs;
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == command)
+                seenCommand = true;
+            continue;
+        }
+        const buildParsed = parseNumberFlag(rawArgs, i, "--build-jobs");
+        if (buildParsed) {
+            if (buildParsed.number < 1) {
+                throw new Error("--build-jobs requires a positive integer");
+            }
+            buildJobs = buildParsed.number;
+            continue;
+        }
+        const runParsed = parseNumberFlag(rawArgs, i, "--run-jobs");
+        if (runParsed) {
+            if (runParsed.number < 1) {
+                throw new Error("--run-jobs requires a positive integer");
+            }
+            runJobs = runParsed.number;
+            continue;
+        }
+    }
+    const jobs = Math.max(baseJobs, buildJobs, runJobs);
+    return { jobs, buildJobs, runJobs };
+}
+function resolveFuzzParallelJobs(rawArgs) {
+    const baseJobs = resolveJobs(rawArgs, "fuzz");
+    let buildJobs = baseJobs;
+    let runJobs = baseJobs;
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == "fuzz")
+                seenCommand = true;
+            continue;
+        }
+        const buildParsed = parseNumberFlag(rawArgs, i, "--build-jobs");
+        if (buildParsed) {
+            if (buildParsed.number < 1) {
+                throw new Error("--build-jobs requires a positive integer");
+            }
+            buildJobs = buildParsed.number;
+            continue;
+        }
+        const runParsed = parseNumberFlag(rawArgs, i, "--run-jobs");
+        if (runParsed) {
+            if (runParsed.number < 1) {
+                throw new Error("--run-jobs requires a positive integer");
+            }
+            runJobs = runParsed.number;
+            continue;
+        }
+    }
+    const jobs = Math.max(baseJobs, buildJobs, runJobs);
+    return { jobs, buildJobs, runJobs };
+}
+function resolveEffectiveParallelJobs(settings, totalFiles) {
+    if (settings.jobs > 0) {
+        return {
+            jobs: Math.max(settings.jobs, settings.buildJobs, settings.runJobs),
+            buildJobs: settings.buildJobs > 0 ? settings.buildJobs : settings.jobs,
+            runJobs: settings.runJobs > 0 ? settings.runJobs : settings.jobs,
+        };
+    }
+    const autoJobs = resolveAutoJobs(totalFiles);
+    return {
+        jobs: Math.max(autoJobs, settings.buildJobs, settings.runJobs),
+        buildJobs: settings.buildJobs > 0 ? settings.buildJobs : autoJobs,
+        runJobs: settings.runJobs > 0 ? settings.runJobs : autoJobs,
+    };
+}
+function resolveAutoJobs(totalFiles) {
+    const cpuCount = typeof availableParallelism == "function"
+        ? availableParallelism()
+        : cpus().length;
+    const cpuBudget = Math.max(1, cpuCount - 1);
+    if (totalFiles <= 1)
+        return 1;
+    if (totalFiles <= 4)
+        return Math.min(2, cpuBudget, totalFiles);
+    if (totalFiles <= 12)
+        return Math.min(3, cpuBudget);
+    if (totalFiles <= 32)
+        return Math.min(4, cpuBudget);
+    return Math.min(Math.max(4, Math.ceil(totalFiles / 12)), cpuBudget);
+}
+function createBufferedStream() {
+    const chunks = [];
+    return {
+        isTTY: false,
+        write(chunk) {
+            chunks.push(typeof chunk == "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return true;
+        },
+        read() {
+            return chunks.join("");
+        },
+    };
+}
+async function createBufferedReporter(configPath, modeName) {
+    const stream = createBufferedStream();
+    const session = await createRunReporter(configPath, undefined, modeName, {
+        stdout: stream,
+        stderr: stream,
+    });
+    return {
+        reporter: session.reporter,
+        reporterKind: session.reporterKind,
+        runtimeName: session.runtimeName,
+        output: () => stream.read(),
+    };
+}
+async function runOrderedPool(items, jobs, worker) {
+    const width = Math.max(1, jobs);
+    let nextIndex = 0;
+    let firstError = null;
+    async function runWorker() {
+        while (true) {
+            if (firstError != null)
+                return;
+            const index = nextIndex++;
+            if (index >= items.length)
+                return;
+            try {
+                await worker(items[index], index);
+            }
+            catch (error) {
+                if (firstError == null)
+                    firstError = error;
+                return;
+            }
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(width, items.length) }, () => runWorker()));
+    if (firstError != null)
+        throw firstError;
+}
+function createAsyncLimiter(limit) {
+    const width = Math.max(1, limit);
+    let active = 0;
+    const queue = [];
+    return async function withLimit(task) {
+        if (active >= width) {
+            await new Promise((resolve) => queue.push(resolve));
+        }
+        active++;
+        try {
+            return await task();
+        }
+        finally {
+            active--;
+            const next = queue.shift();
+            if (next)
+                next();
+        }
+    };
+}
+function canRewriteParallelQueue() {
+    return Boolean(process.stdout.isTTY);
+}
+class ParallelQueueDisplay {
+    constructor(showStartLines) {
+        this.showStartLines = showStartLines;
+        this.active = new Map();
+        this.renderedLines = 0;
+        this.enabled = showStartLines && canRewriteParallelQueue();
+    }
+    start(file) {
+        const token = Symbol(file);
+        if (!this.showStartLines)
+            return token;
+        const line = `${chalk.bgBlackBright.white(" .... ")} ${file}`;
+        if (!this.enabled)
+            return token;
+        this.clear();
+        this.active.set(token, line);
+        this.render();
+        return token;
+    }
+    complete(token, output) {
+        if (!this.showStartLines || !this.enabled) {
+            process.stdout.write(output);
+            return;
+        }
+        this.clear();
+        process.stdout.write(output);
+        this.active.delete(token);
+        this.render();
+    }
+    flush() {
+        if (!this.enabled)
+            return;
+        this.clear();
+    }
+    clear() {
+        if (!this.renderedLines)
+            return;
+        for (let i = 0; i < this.renderedLines; i++) {
+            process.stdout.write("\r\x1b[2K");
+            if (i < this.renderedLines - 1)
+                process.stdout.write("\x1b[1A");
+        }
+        this.renderedLines = 0;
+    }
+    render() {
+        if (!this.enabled)
+            return;
+        const lines = Array.from(this.active.values());
+        if (!lines.length)
+            return;
+        process.stdout.write(lines.join("\n"));
+        this.renderedLines = lines.length;
+    }
+}
+function renderQueuedFileStart(display, file) {
+    return display.start(file);
+}
+function parseIntegerFlag(flag, value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new Error(`${flag} requires a non-negative integer`);
+    }
+    return Math.floor(parsed);
+}
 function applyFeatureToggle(out, rawFeature, enabled) {
     const key = rawFeature.trim().toLowerCase();
     if (key == "coverage") {
@@ -456,26 +882,32 @@ function resolveCommandTokens(rawArgs, command) {
     }
     return values;
 }
-async function runTestSequential(runFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, modeName) {
+async function runTestSequential(runFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, allowNoSpecFiles = false, modeName, reporterOverride, emitRunComplete = true) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
-        throw await buildNoTestFilesMatchedError(configPath, selectors);
+        if (!allowNoSpecFiles) {
+            throw await buildNoTestFilesMatchedError(configPath, selectors);
+        }
     }
     const reporterSession = await createRunReporter(configPath, undefined, modeName);
-    const reporter = reporterSession.reporter;
+    const reporter = reporterOverride ?? reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
         runtimeName: reporterSession.runtimeName,
         clean: runFlags.clean,
         verbose: runFlags.verbose,
         snapshotEnabled,
-        updateSnapshots: runFlags.updateSnapshots,
+        createSnapshots: runFlags.createSnapshots,
     });
     const results = [];
     let failed = false;
+    const buildIntervals = [];
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     for (const file of files) {
+        const buildStartedAt = Date.now();
         await build(configPath, [file], modeName, buildFeatureToggles);
+        buildIntervals.push({ start: buildStartedAt, end: Date.now() });
+        const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
         const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
         const result = await run(runFlags, configPath, [file], false, {
             reporter,
@@ -483,6 +915,7 @@ async function runTestSequential(runFlags, configPath, selectors, buildFeatureTo
             emitRunComplete: false,
             logFileName: `test.${artifactKey}.log.json`,
             coverageFileName: `coverage.${artifactKey}.log.json`,
+            buildCommand: formatBuildInvocation(buildInvocation),
             modeName,
         });
         results.push(result);
@@ -491,38 +924,109 @@ async function runTestSequential(runFlags, configPath, selectors, buildFeatureTo
     }
     const summary = aggregateRunResults(results);
     summary.stats = applyConfiguredFileTotalToStats(summary.stats, fileSummaryTotal);
-    reporter.onRunComplete?.({
-        clean: runFlags.clean,
-        snapshotEnabled,
-        showCoverage: runFlags.showCoverage,
-        snapshotSummary: summary.snapshotSummary,
-        coverageSummary: summary.coverageSummary,
-        stats: summary.stats,
-        reports: summary.reports,
-        modeSummary: buildSingleModeSummary(summary.stats, summary.snapshotSummary, modeSummaryTotal),
-    });
-    return failed;
+    if (emitRunComplete) {
+        reporter.onRunComplete?.({
+            clean: runFlags.clean,
+            snapshotEnabled,
+            showCoverage: runFlags.showCoverage,
+            buildTime: getMergedIntervalDuration(buildIntervals),
+            snapshotSummary: summary.snapshotSummary,
+            coverageSummary: summary.coverageSummary,
+            stats: summary.stats,
+            reports: summary.reports,
+            modeSummary: buildSingleModeSummary(summary.stats, summary.snapshotSummary, modeSummaryTotal),
+        });
+        reporter.flush?.();
+    }
+    return {
+        failed,
+        summary: {
+            buildTime: getMergedIntervalDuration(buildIntervals),
+            snapshotSummary: summary.snapshotSummary,
+            coverageSummary: summary.coverageSummary,
+            stats: summary.stats,
+            reports: summary.reports,
+        },
+    };
 }
-async function runBuildModes(configPath, selectors, modes, buildFeatureToggles) {
+async function runBuildModes(configPath, selectors, modes, buildFeatureToggles, parallel) {
+    const files = await resolveSelectedFiles(configPath, selectors);
+    if (!files.length) {
+        throw await buildNoTestFilesMatchedError(configPath, selectors);
+    }
+    const effective = resolveEffectiveParallelJobs({
+        jobs: parallel.jobs,
+        buildJobs: parallel.buildJobs,
+        runJobs: parallel.buildJobs,
+    }, files.length);
+    const resolvedConfigPath = configPath ?? path.join(process.cwd(), "./as-test.config.json");
+    const loadedConfig = loadConfig(resolvedConfigPath, true);
+    const allStartedAt = Date.now();
+    let builtCount = 0;
     for (const modeName of modes) {
-        await build(configPath, selectors, modeName, buildFeatureToggles);
+        const startedAt = Date.now();
+        if (effective.buildJobs > 1) {
+            const pool = new BuildWorkerPool(effective.buildJobs);
+            try {
+                await runOrderedPool(files, effective.buildJobs, async (file) => {
+                    await pool.buildFileMode({
+                        configPath,
+                        file,
+                        modeName,
+                        featureToggles: buildFeatureToggles,
+                    });
+                });
+            }
+            finally {
+                await pool.close();
+            }
+        }
+        else {
+            await build(configPath, selectors, modeName, buildFeatureToggles);
+        }
+        builtCount += files.length;
+        const active = applyMode(loadedConfig, modeName).config;
+        process.stdout.write(`${chalk.bgGreenBright.black(" BUILT ")} ${modeName ?? "default"} ${chalk.dim(`(${active.buildOptions.target})`)} ${files.length} file(s) -> ${active.outDir} ${chalk.dim(formatTime(Date.now() - startedAt))}\n`);
     }
+    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) {
-    const modeSummaryTotal = resolveConfiguredModeTotal(configPath);
+    await ensureWebBrowsersReady(configPath, modes, runFlags.browser);
+    const modeSummaryTotal = Math.max(modes.length, 1);
     const fileSummaryTotal = await resolveConfiguredFileTotal(configPath);
+    const effectiveRunFlags = {
+        ...runFlags,
+        ...resolveEffectiveParallelJobs(runFlags, fileSummaryTotal),
+    };
+    if (effectiveRunFlags.jobs > 1) {
+        if (modes.length > 1) {
+            const failed = await runRuntimeMatrixParallel(effectiveRunFlags, configPath, selectors, 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);
+            if (result)
+                failed = true;
+        }
+        process.exit(failed ? 1 : 0);
+        return;
+    }
     if (modes.length > 1) {
-        const failed = await runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSummaryTotal, fileSummaryTotal);
+        const failed = await runRuntimeMatrix(effectiveRunFlags, configPath, selectors, modes, modeSummaryTotal, fileSummaryTotal);
         process.exit(failed ? 1 : 0);
         return;
     }
     let failed = false;
+    const buildCommandsByFile = await previewBuildCommands(configPath, selectors, modes[0], {});
     for (const modeName of modes) {
-        const result = await run(runFlags, configPath, selectors, false, {
+        const result = await run(effectiveRunFlags, configPath, selectors, false, {
             modeName,
             modeSummaryTotal,
             modeSummaryExecuted: 1,
             fileSummaryTotal,
+            buildCommandsByFile,
         });
         if (result.failed)
             failed = true;
@@ -542,7 +1046,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
         clean: runFlags.clean,
         verbose: runFlags.verbose,
         snapshotEnabled,
-        updateSnapshots: runFlags.updateSnapshots,
+        createSnapshots: runFlags.createSnapshots,
     });
     const silentReporter = {};
     const allResults = [];
@@ -558,6 +1062,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
         passed: false,
     }));
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const buildIntervals = [];
     for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
         const file = files[fileIndex];
         const fileName = path.basename(file);
@@ -569,6 +1074,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
         for (let i = 0; i < modes.length; i++) {
             const modeName = modes[i];
             try {
+                const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, {});
                 const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
                 const result = await run(runFlags, configPath, [file], false, {
                     reporter: silentReporter,
@@ -577,6 +1083,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
                     emitRunComplete: false,
                     logFileName: `run.${artifactKey}.log.json`,
                     coverageFileName: `coverage.${artifactKey}.log.json`,
+                    buildCommand: formatBuildInvocation(buildInvocation),
                     modeName,
                 });
                 modeTimes[i] = formatMatrixModeTime(result.stats.time);
@@ -612,6 +1119,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        buildTime: 0,
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
         stats: summary.stats,
@@ -620,26 +1128,75 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
     });
     return allResults.some((result) => result.failed);
 }
-async function runTestModes(runFlags, configPath, selectors, modes, buildFeatureToggles) {
-    const modeSummaryTotal = resolveConfiguredModeTotal(configPath);
-    const fileSummaryTotal = await resolveConfiguredFileTotal(configPath);
+async function runTestModes(runFlags, configPath, selectors, modes, buildFeatureToggles, fuzzEnabled, fuzzOverrides) {
+    await ensureWebBrowsersReady(configPath, modes, runFlags.browser);
+    const modeSummaryTotal = Math.max(modes.length, 1);
+    const fileSummaryTotal = await resolveConfiguredFileTotal(configPath, selectors);
+    const effectiveRunFlags = {
+        ...runFlags,
+        ...resolveEffectiveParallelJobs(runFlags, fileSummaryTotal),
+    };
+    if (effectiveRunFlags.jobs > 1) {
+        if (modes.length > 1) {
+            const failed = await runTestMatrixParallel(effectiveRunFlags, configPath, selectors, 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);
+            if (modeFailed)
+                failed = true;
+        }
+        process.exit(failed ? 1 : 0);
+        return;
+    }
     if (modes.length > 1) {
-        const failed = await runTestMatrix(runFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal);
+        const failed = await runTestMatrix(effectiveRunFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides);
         process.exit(failed ? 1 : 0);
         return;
     }
     let failed = false;
     for (const modeName of modes) {
-        const modeFailed = await runTestSequential(runFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, modeName);
-        if (modeFailed)
+        const reporterSession = await createRunReporter(configPath, undefined, modeName);
+        const modeResult = await runTestSequential(effectiveRunFlags, configPath, selectors, 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);
+            if (fuzzResults.some(hasFuzzFailures))
+                failed = true;
+            reporterSession.reporter.onRunComplete?.({
+                clean: runFlags.clean,
+                snapshotEnabled: effectiveRunFlags.snapshot !== false,
+                showCoverage: effectiveRunFlags.showCoverage,
+                buildTime: modeResult.summary.buildTime +
+                    getMergedIntervalDuration(collectFuzzBuildIntervals(fuzzResults)),
+                snapshotSummary: modeResult.summary.snapshotSummary,
+                coverageSummary: modeResult.summary.coverageSummary,
+                stats: modeResult.summary.stats,
+                reports: modeResult.summary.reports,
+                fuzzSummary: summarizeFuzzExecutions(fuzzResults),
+                modeSummary: buildSingleModeSummary(modeResult.summary.stats, modeResult.summary.snapshotSummary, modeSummaryTotal),
+            });
+            reporterSession.reporter.flush?.();
+        }
     }
     process.exit(failed ? 1 : 0);
 }
-async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal) {
+async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
-        throw await buildNoTestFilesMatchedError(configPath, selectors);
+        if (!fuzzEnabled) {
+            throw await buildNoTestFilesMatchedError(configPath, selectors);
+        }
+        const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors);
+        if (!fuzzFiles.length) {
+            throw await buildNoTestFilesMatchedError(configPath, selectors, true);
+        }
     }
     const reporterSession = await createRunReporter(configPath);
     const reporter = reporterSession.reporter;
@@ -649,7 +1206,7 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
         clean: runFlags.clean,
         verbose: runFlags.verbose,
         snapshotEnabled,
-        updateSnapshots: runFlags.updateSnapshots,
+        createSnapshots: runFlags.createSnapshots,
     });
     const silentReporter = {};
     const allResults = [];
@@ -665,6 +1222,7 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
         passed: false,
     }));
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const buildIntervals = [];
     for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
         const file = files[fileIndex];
         const fileName = path.basename(file);
@@ -676,7 +1234,10 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
         for (let i = 0; i < modes.length; i++) {
             const modeName = modes[i];
             try {
+                const buildStartedAt = Date.now();
                 await build(configPath, [file], modeName, buildFeatureToggles);
+                buildIntervals.push({ start: buildStartedAt, end: Date.now() });
+                const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
                 const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
                 const result = await run(runFlags, configPath, [file], false, {
                     reporter: silentReporter,
@@ -685,6 +1246,7 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
                     emitRunComplete: false,
                     logFileName: `test.${artifactKey}.log.json`,
                     coverageFileName: `coverage.${artifactKey}.log.json`,
+                    buildCommand: formatBuildInvocation(buildInvocation),
                     modeName,
                 });
                 modeTimes[i] = formatMatrixModeTime(result.stats.time);
@@ -716,53 +1278,585 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
     }
     const summary = aggregateRunResults(allResults);
     summary.stats = applyMatrixFileSummaryToStats(summary.stats, fileState, fileSummaryTotal);
+    let failed = allResults.some((result) => result.failed);
+    let fuzzSummary;
+    if (fuzzEnabled) {
+        if (reporterSession.reporterKind == "default") {
+            process.stdout.write("\n");
+        }
+        const fuzzResults = await runFuzzMatrixResults(configPath, selectors, modes, fuzzOverrides, reporter);
+        if (fuzzResults.some(hasFuzzFailures))
+            failed = true;
+        fuzzSummary = summarizeFuzzExecutions(fuzzResults);
+        buildIntervals.push(...collectFuzzBuildIntervals(fuzzResults));
+    }
     reporter.onRunComplete?.({
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
         stats: summary.stats,
         reports: summary.reports,
+        fuzzSummary,
         modeSummary: buildModeSummary(modeState, modeSummaryTotal),
     });
-    return allResults.some((result) => result.failed);
-}
-function renderMatrixFileResult(file, modes, results, modeTimes, liveMatrix, showPerModeTimes) {
-    const verdict = resolveMatrixVerdict(results);
-    const badge = verdict == "fail"
-        ? chalk.bgRed.white(" FAIL ")
-        : verdict == "ok"
-            ? chalk.bgGreenBright.black(" PASS ")
-            : chalk.bgBlackBright.white(" SKIP ");
-    const avg = formatMatrixAverageTime(results);
-    const timingText = showPerModeTimes ? modeTimes.join(",") : avg;
-    const suffix = showPerModeTimes
-        ? ` ${chalk.dim(`(${modes.join(",")})`)}`
-        : "";
-    const line = `${badge} ${file} ${chalk.dim(timingText)}${suffix}`;
-    if (liveMatrix)
-        clearLiveLine();
-    process.stdout.write(line + "\n");
-}
-function resolveMatrixVerdict(results) {
-    if (results.some((result) => result.failed))
-        return "fail";
-    const hasPass = results.some((result) => result.stats.passedFiles > 0);
-    if (hasPass)
-        return "ok";
-    return "skip";
-}
-function canRewriteStdout() {
-    return Boolean(process.stdout.isTTY);
+    reporter.flush?.();
+    return failed;
 }
-function clearLiveLine() {
-    if (!canRewriteStdout())
+async function runFuzzModes(configPath, selectors, 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 reporterSession = await createRunReporter(configPath);
+        reporterSession.reporter.onFuzzComplete?.(buildFuzzCompleteEvent(results, modes));
+        reporterSession.reporter.flush?.();
+        process.exit(results.some(hasFuzzFailures) ? 1 : 0);
         return;
-    process.stdout.write("\r\x1b[2K");
+    }
+    const reporterSession = await createRunReporter(configPath);
+    const results = await runFuzzMatrixResults(configPath, selectors, modes, overrides, reporterSession.reporter);
+    reporterSession.reporter.onFuzzComplete?.(buildFuzzCompleteEvent(results, modes));
+    reporterSession.reporter.flush?.();
+    process.exit(results.some(hasFuzzFailures) ? 1 : 0);
 }
-function renderMatrixLiveLine(file, modes, modeTimes, showPerModeTimes) {
-    if (!canRewriteStdout())
+async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeName, modeSummaryTotal, fileSummaryTotal) {
+    const files = await resolveSelectedFiles(configPath, selectors);
+    if (!files.length) {
+        throw await buildNoTestFilesMatchedError(configPath, selectors);
+    }
+    const reporterSession = await createRunReporter(configPath, undefined, modeName);
+    const reporter = reporterSession.reporter;
+    const snapshotEnabled = runFlags.snapshot !== false;
+    reporter.onRunStart?.({
+        runtimeName: reporterSession.runtimeName,
+        clean: runFlags.clean,
+        verbose: runFlags.verbose,
+        snapshotEnabled,
+        createSnapshots: runFlags.createSnapshots,
+    });
+    const buildCommandsByFile = await previewBuildCommands(configPath, selectors, modeName, {});
+    const results = new Array(files.length);
+    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const runLimit = createAsyncLimiter(runFlags.runJobs);
+    const poolWidth = Math.max(runFlags.buildJobs, runFlags.runJobs);
+    await runOrderedPool(files, poolWidth, async (file, index) => {
+        const token = renderQueuedFileStart(queueDisplay, path.basename(file));
+        const buffered = await createBufferedReporter(configPath, modeName);
+        const result = await runLimit(() => run({ ...runFlags, clean: true }, configPath, [file], false, {
+            reporter: buffered.reporter,
+            reporterKind: buffered.reporterKind,
+            modeName,
+            emitRunComplete: false,
+            fileSummaryTotal: 1,
+            modeSummaryTotal,
+            modeSummaryExecuted: 1,
+            buildCommandsByFile: { [file]: buildCommandsByFile[file] ?? "" },
+        }));
+        buffered.reporter.flush?.();
+        results[index] = result;
+        queueDisplay.complete(token, buffered.output());
+    });
+    queueDisplay.flush();
+    const summary = aggregateRunResults(results);
+    summary.stats = applyConfiguredFileTotalToStats(summary.stats, fileSummaryTotal);
+    reporter.onRunComplete?.({
+        clean: runFlags.clean,
+        snapshotEnabled,
+        showCoverage: runFlags.showCoverage,
+        buildTime: 0,
+        snapshotSummary: summary.snapshotSummary,
+        coverageSummary: summary.coverageSummary,
+        stats: summary.stats,
+        reports: summary.reports,
+        modeSummary: buildSingleModeSummary(summary.stats, summary.snapshotSummary, modeSummaryTotal),
+    });
+    reporter.flush?.();
+    return results.some((result) => result.failed);
+}
+async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes, modeSummaryTotal, fileSummaryTotal) {
+    const files = await resolveSelectedFiles(configPath, selectors);
+    if (!files.length) {
+        throw await buildNoTestFilesMatchedError(configPath, selectors);
+    }
+    const reporterSession = await createRunReporter(configPath);
+    const reporter = reporterSession.reporter;
+    const snapshotEnabled = runFlags.snapshot !== false;
+    reporter.onRunStart?.({
+        runtimeName: reporterSession.runtimeName,
+        clean: runFlags.clean,
+        verbose: runFlags.verbose,
+        snapshotEnabled,
+        createSnapshots: runFlags.createSnapshots,
+    });
+    const silentReporter = {};
+    const modeLabels = modes.map((modeName) => modeName ?? "default");
+    const showPerModeTimes = Boolean(runFlags.verbose);
+    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const ordered = new Array(files.length);
+    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
+    const buildPool = new BuildWorkerPool(runFlags.buildJobs);
+    const buildIntervals = [];
+    try {
+        await runOrderedPool(files, poolWidth, async (file, fileIndex) => {
+            const fileName = path.basename(file);
+            const token = renderQueuedFileStart(queueDisplay, fileName);
+            const fileResults = [];
+            const modeTimes = modes.map(() => "...");
+            for (let i = 0; i < modes.length; i++) {
+                const modeName = modes[i];
+                const buildStartedAt = Date.now();
+                await buildPool.buildFileMode({
+                    configPath,
+                    file,
+                    modeName,
+                });
+                buildIntervals.push({ start: buildStartedAt, end: Date.now() });
+                const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, {});
+                const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+                const result = await run(runFlags, configPath, [file], false, {
+                    reporter: silentReporter,
+                    reporterKind: "default",
+                    emitRunStart: false,
+                    emitRunComplete: false,
+                    logFileName: `run.${artifactKey}.log.json`,
+                    coverageFileName: `coverage.${artifactKey}.log.json`,
+                    buildCommand: formatBuildInvocation(buildInvocation),
+                    modeName,
+                });
+                modeTimes[i] = formatMatrixModeTime(result.stats.time);
+                fileResults.push(result);
+            }
+            ordered[fileIndex] = { fileName, fileResults, modeTimes };
+            queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+        });
+    }
+    finally {
+        await buildPool.close();
+    }
+    queueDisplay.flush();
+    const allResults = [];
+    const modeState = modes.map(() => ({ failed: false, passed: false }));
+    const fileState = files.map(() => ({ failed: false, passed: false }));
+    for (let fileIndex = 0; fileIndex < ordered.length; fileIndex++) {
+        const fileResults = ordered[fileIndex].fileResults;
+        for (let i = 0; i < fileResults.length; i++) {
+            const result = fileResults[i];
+            allResults.push(result);
+            if (result.failed)
+                modeState[i].failed = true;
+            else if (result.stats.passedFiles > 0)
+                modeState[i].passed = true;
+        }
+        const verdict = resolveMatrixVerdict(fileResults);
+        if (verdict == "fail")
+            fileState[fileIndex].failed = true;
+        else if (verdict == "ok")
+            fileState[fileIndex].passed = true;
+    }
+    const summary = aggregateRunResults(allResults);
+    summary.stats = applyMatrixFileSummaryToStats(summary.stats, fileState, fileSummaryTotal);
+    reporter.onRunComplete?.({
+        clean: runFlags.clean,
+        snapshotEnabled,
+        showCoverage: runFlags.showCoverage,
+        buildTime: getMergedIntervalDuration(buildIntervals),
+        snapshotSummary: summary.snapshotSummary,
+        coverageSummary: summary.coverageSummary,
+        stats: summary.stats,
+        reports: summary.reports,
+        modeSummary: buildModeSummary(modeState, modeSummaryTotal),
+    });
+    reporter.flush?.();
+    return allResults.some((result) => result.failed);
+}
+async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides, modeName) {
+    const files = await resolveSelectedFiles(configPath, selectors);
+    if (!files.length && !fuzzEnabled) {
+        throw await buildNoTestFilesMatchedError(configPath, selectors);
+    }
+    const reporterSession = await createRunReporter(configPath, undefined, modeName);
+    const reporter = reporterSession.reporter;
+    const snapshotEnabled = runFlags.snapshot !== false;
+    reporter.onRunStart?.({
+        runtimeName: reporterSession.runtimeName,
+        clean: runFlags.clean,
+        verbose: runFlags.verbose,
+        snapshotEnabled,
+        createSnapshots: runFlags.createSnapshots,
+    });
+    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const results = new Array(files.length);
+    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
+    const buildIntervals = [];
+    if (files.length) {
+        const buildPool = new BuildWorkerPool(runFlags.buildJobs);
+        try {
+            await runOrderedPool(files, poolWidth, async (file, index) => {
+                const token = renderQueuedFileStart(queueDisplay, path.basename(file));
+                const buildStartedAt = Date.now();
+                await buildPool.buildFileMode({
+                    configPath,
+                    file,
+                    modeName,
+                    featureToggles: buildFeatureToggles,
+                });
+                buildIntervals.push({ start: buildStartedAt, end: Date.now() });
+                const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
+                const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+                const buffered = await createBufferedReporter(configPath, modeName);
+                const result = await run({ ...runFlags, clean: true }, configPath, [file], false, {
+                    reporter: buffered.reporter,
+                    reporterKind: buffered.reporterKind,
+                    emitRunComplete: false,
+                    logFileName: `test.${artifactKey}.log.json`,
+                    coverageFileName: `coverage.${artifactKey}.log.json`,
+                    buildCommand: formatBuildInvocation(buildInvocation),
+                    modeName,
+                });
+                buffered.reporter.flush?.();
+                results[index] = result;
+                queueDisplay.complete(token, buffered.output());
+            });
+        }
+        finally {
+            await buildPool.close();
+        }
+    }
+    queueDisplay.flush();
+    const runResults = results.filter(Boolean);
+    const summary = aggregateRunResults(runResults);
+    summary.stats = applyConfiguredFileTotalToStats(summary.stats, fileSummaryTotal);
+    let failed = runResults.some((result) => result.failed);
+    let fuzzSummary;
+    if (fuzzEnabled) {
+        if (reporterSession.reporterKind == "default") {
+            process.stdout.write("\n");
+        }
+        const fuzzResults = await runFuzzMatrixResultsParallel(configPath, selectors, [modeName], fuzzOverrides, runFlags.jobs, runFlags.buildJobs, runFlags.runJobs, runFlags.clean);
+        if (fuzzResults.some(hasFuzzFailures))
+            failed = true;
+        fuzzSummary = summarizeFuzzExecutions(fuzzResults);
+        buildIntervals.push(...collectFuzzBuildIntervals(fuzzResults));
+    }
+    reporter.onRunComplete?.({
+        clean: runFlags.clean,
+        snapshotEnabled,
+        showCoverage: runFlags.showCoverage,
+        buildTime: getMergedIntervalDuration(buildIntervals),
+        snapshotSummary: summary.snapshotSummary,
+        coverageSummary: summary.coverageSummary,
+        stats: summary.stats,
+        reports: summary.reports,
+        fuzzSummary,
+        modeSummary: buildSingleModeSummary(summary.stats, summary.snapshotSummary, modeSummaryTotal),
+    });
+    reporter.flush?.();
+    return failed;
+}
+async function runTestMatrixParallel(runFlags, configPath, selectors, modes, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, fuzzOverrides) {
+    const files = await resolveSelectedFiles(configPath, selectors);
+    if (!files.length) {
+        if (!fuzzEnabled) {
+            throw await buildNoTestFilesMatchedError(configPath, selectors);
+        }
+        const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors);
+        if (!fuzzFiles.length) {
+            throw await buildNoTestFilesMatchedError(configPath, selectors, true);
+        }
+    }
+    const reporterSession = await createRunReporter(configPath);
+    const reporter = reporterSession.reporter;
+    const snapshotEnabled = runFlags.snapshot !== false;
+    reporter.onRunStart?.({
+        runtimeName: reporterSession.runtimeName,
+        clean: runFlags.clean,
+        verbose: runFlags.verbose,
+        snapshotEnabled,
+        createSnapshots: runFlags.createSnapshots,
+    });
+    const silentReporter = {};
+    const modeLabels = modes.map((modeName) => modeName ?? "default");
+    const showPerModeTimes = Boolean(runFlags.verbose);
+    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const ordered = new Array(files.length);
+    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
+    const buildPool = new BuildWorkerPool(runFlags.buildJobs);
+    const buildIntervals = [];
+    try {
+        await runOrderedPool(files, poolWidth, async (file, fileIndex) => {
+            const fileName = path.basename(file);
+            const token = renderQueuedFileStart(queueDisplay, fileName);
+            const fileResults = [];
+            const modeTimes = modes.map(() => "...");
+            for (let i = 0; i < modes.length; i++) {
+                const modeName = modes[i];
+                const buildStartedAt = Date.now();
+                await buildPool.buildFileMode({
+                    configPath,
+                    file,
+                    modeName,
+                    featureToggles: buildFeatureToggles,
+                });
+                buildIntervals.push({ start: buildStartedAt, end: Date.now() });
+                const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
+                const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+                const result = await run(runFlags, configPath, [file], false, {
+                    reporter: silentReporter,
+                    reporterKind: "default",
+                    emitRunStart: false,
+                    emitRunComplete: false,
+                    logFileName: `test.${artifactKey}.log.json`,
+                    coverageFileName: `coverage.${artifactKey}.log.json`,
+                    buildCommand: formatBuildInvocation(buildInvocation),
+                    modeName,
+                });
+                modeTimes[i] = formatMatrixModeTime(result.stats.time);
+                fileResults.push(result);
+            }
+            ordered[fileIndex] = { fileName, fileResults, modeTimes };
+            queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+        });
+    }
+    finally {
+        await buildPool.close();
+    }
+    queueDisplay.flush();
+    const allResults = [];
+    const modeState = modes.map(() => ({ failed: false, passed: false }));
+    const fileState = files.map(() => ({ failed: false, passed: false }));
+    for (let fileIndex = 0; fileIndex < ordered.length; fileIndex++) {
+        const entry = ordered[fileIndex];
+        for (let i = 0; i < entry.fileResults.length; i++) {
+            const result = entry.fileResults[i];
+            allResults.push(result);
+            if (result.failed)
+                modeState[i].failed = true;
+            else if (result.stats.passedFiles > 0)
+                modeState[i].passed = true;
+        }
+        const verdict = resolveMatrixVerdict(entry.fileResults);
+        if (verdict == "fail")
+            fileState[fileIndex].failed = true;
+        else if (verdict == "ok")
+            fileState[fileIndex].passed = true;
+    }
+    const summary = aggregateRunResults(allResults);
+    summary.stats = applyMatrixFileSummaryToStats(summary.stats, fileState, fileSummaryTotal);
+    let failed = allResults.some((result) => result.failed);
+    let fuzzSummary;
+    if (fuzzEnabled) {
+        if (reporterSession.reporterKind == "default") {
+            process.stdout.write("\n");
+        }
+        const fuzzResults = await runFuzzMatrixResultsParallel(configPath, selectors, modes, fuzzOverrides, runFlags.jobs, runFlags.buildJobs, runFlags.runJobs, runFlags.clean);
+        if (fuzzResults.some(hasFuzzFailures))
+            failed = true;
+        fuzzSummary = summarizeFuzzExecutions(fuzzResults);
+        buildIntervals.push(...collectFuzzBuildIntervals(fuzzResults));
+    }
+    reporter.onRunComplete?.({
+        clean: runFlags.clean,
+        snapshotEnabled,
+        showCoverage: runFlags.showCoverage,
+        buildTime: getMergedIntervalDuration(buildIntervals),
+        snapshotSummary: summary.snapshotSummary,
+        coverageSummary: summary.coverageSummary,
+        stats: summary.stats,
+        reports: summary.reports,
+        fuzzSummary,
+        modeSummary: buildModeSummary(modeState, modeSummaryTotal),
+    });
+    reporter.flush?.();
+    return failed;
+}
+async function runFuzzMatrixResultsParallel(configPath, selectors, 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"}`);
+    }
+    const ordered = new Array(files.length);
+    const queueDisplay = new ParallelQueueDisplay(!clean);
+    const poolWidth = Math.max(jobs, buildJobs, runJobs);
+    await runOrderedPool(files, poolWidth, async (file, index) => {
+        const token = renderQueuedFileStart(queueDisplay, path.basename(file));
+        const fileResults = [];
+        for (const modeName of modes) {
+            const modeResults = await fuzz(configPath, [file], modeName, overrides);
+            fileResults.push(...modeResults);
+        }
+        ordered[index] = fileResults;
+        const buffered = await createBufferedReporter(configPath);
+        buffered.reporter.onFuzzFileComplete?.({ file, results: fileResults });
+        buffered.reporter.flush?.();
+        queueDisplay.complete(token, buffered.output());
+    });
+    queueDisplay.flush();
+    return ordered.flat();
+}
+async function runFuzzMatrixResults(configPath, selectors, 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"}`);
+    }
+    const results = [];
+    for (const file of files) {
+        const fileResults = [];
+        for (const modeName of modes) {
+            const modeResults = await fuzz(configPath, [file], modeName, overrides);
+            fileResults.push(...modeResults);
+            results.push(...modeResults);
+        }
+        reporter?.onFuzzFileComplete?.({ file, results: fileResults });
+    }
+    return results;
+}
+function hasFuzzFailures(result) {
+    if (result.crashes > 0)
+        return true;
+    return result.fuzzers.some((fuzzer) => fuzzer.failed > 0);
+}
+function buildFuzzCompleteEvent(results, modes) {
+    return {
+        results,
+        time: results.reduce((sum, item) => sum + item.time, 0),
+        buildTime: getMergedIntervalDuration(collectFuzzBuildIntervals(results)),
+        fuzzingSummary: summarizeFuzzExecutions(results),
+        suiteSummary: summarizeFuzzSuites(results),
+        modeSummary: summarizeFuzzModes(results, modes),
+    };
+}
+function collectFuzzBuildIntervals(results) {
+    return results.map((result) => ({
+        start: result.buildStartedAt,
+        end: result.buildFinishedAt,
+    }));
+}
+function getMergedIntervalDuration(intervals) {
+    if (!intervals.length)
+        return 0;
+    const sorted = intervals
+        .map((interval) => ({
+        start: Math.min(interval.start, interval.end),
+        end: Math.max(interval.start, interval.end),
+    }))
+        .sort((a, b) => a.start - b.start);
+    let total = 0;
+    let currentStart = sorted[0].start;
+    let currentEnd = sorted[0].end;
+    for (let i = 1; i < sorted.length; i++) {
+        const interval = sorted[i];
+        if (interval.start <= currentEnd) {
+            currentEnd = Math.max(currentEnd, interval.end);
+            continue;
+        }
+        total += currentEnd - currentStart;
+        currentStart = interval.start;
+        currentEnd = interval.end;
+    }
+    total += currentEnd - currentStart;
+    return total;
+}
+function summarizeFuzzExecutions(results) {
+    return {
+        failed: results.reduce((sum, item) => sum +
+            item.fuzzers.reduce((inner, fuzzer) => inner + fuzzer.failed + fuzzer.crashed, 0), 0),
+        skipped: results.reduce((sum, item) => sum + item.fuzzers.reduce((inner, fuzzer) => inner + fuzzer.skipped, 0), 0),
+        total: results.reduce((sum, item) => sum + item.fuzzers.reduce((inner, fuzzer) => inner + fuzzer.runs, 0), 0),
+    };
+}
+function summarizeFuzzSuites(results) {
+    return {
+        failed: results.reduce((sum, item) => sum +
+            item.fuzzers.filter((fuzzer) => fuzzer.failed > 0 || fuzzer.crashed > 0)
+                .length, 0),
+        skipped: results.reduce((sum, item) => sum + item.fuzzers.filter((fuzzer) => fuzzer.skipped > 0).length, 0),
+        total: results.reduce((sum, item) => sum + item.fuzzers.length, 0),
+    };
+}
+function summarizeFuzzModes(results, modes) {
+    const total = Math.max(modes.length, 1);
+    const state = new Map();
+    for (const modeName of modes) {
+        state.set(modeName ?? "default", { failed: false, passed: false });
+    }
+    for (const result of results) {
+        const current = state.get(result.modeName) ?? {
+            failed: false,
+            passed: false,
+        };
+        if (hasFuzzFailures(result))
+            current.failed = true;
+        else if (!isSkippedFuzzResult(result))
+            current.passed = true;
+        state.set(result.modeName, current);
+    }
+    let failed = 0;
+    let skipped = 0;
+    for (const mode of state.values()) {
+        if (mode.failed)
+            failed++;
+        else if (!mode.passed)
+            skipped++;
+    }
+    return { failed, skipped, total };
+}
+function isSkippedFuzzResult(result) {
+    return (result.crashes == 0 &&
+        result.fuzzers.length > 0 &&
+        result.fuzzers.every((fuzzer) => fuzzer.skipped > 0));
+}
+function renderMatrixFileResult(file, modes, results, modeTimes, liveMatrix, showPerModeTimes) {
+    const line = formatMatrixFileResultLine(file, modes, results, modeTimes, showPerModeTimes);
+    if (liveMatrix)
+        clearLiveLine();
+    process.stdout.write(line + "\n");
+}
+function formatMatrixFileResultLine(file, modes, results, modeTimes, showPerModeTimes) {
+    const verdict = resolveMatrixVerdict(results);
+    const badge = verdict == "fail"
+        ? chalk.bgRed.white(" FAIL ")
+        : verdict == "ok"
+            ? chalk.bgGreenBright.black(" PASS ")
+            : chalk.bgBlackBright.white(" SKIP ");
+    const avg = formatMatrixAverageTime(results);
+    const timingText = showPerModeTimes ? modeTimes.join(",") : avg;
+    const failedModes = results
+        .map((result, index) => (result.failed ? modes[index] : null))
+        .filter((mode) => Boolean(mode));
+    const suffix = showPerModeTimes
+        ? ` ${chalk.dim(`(${modes.join(",")})`)}`
+        : failedModes.length
+            ? ` ${chalk.dim(`(failed: ${failedModes.join(", ")})`)}`
+            : "";
+    return `${badge} ${file} ${chalk.dim(timingText)}${suffix}`;
+}
+function resolveMatrixVerdict(results) {
+    if (results.some((result) => result.failed))
+        return "fail";
+    const hasPass = results.some((result) => result.stats.passedFiles > 0);
+    if (hasPass)
+        return "ok";
+    return "skip";
+}
+function canRewriteStdout() {
+    return Boolean(process.stdout.isTTY);
+}
+function clearLiveLine() {
+    if (!canRewriteStdout())
+        return;
+    process.stdout.write("\r\x1b[2K");
+}
+function renderMatrixLiveLine(file, modes, modeTimes, showPerModeTimes) {
+    if (!canRewriteStdout())
         return;
     const timingText = showPerModeTimes ? modeTimes.join(",") : "...";
     const suffix = showPerModeTimes
@@ -850,10 +1944,19 @@ function resolveConfiguredModeTotal(configPath) {
     const configuredModes = Object.keys(config.modes).length;
     return configuredModes || 1;
 }
-async function resolveConfiguredFileTotal(configPath) {
-    const files = await resolveSelectedFiles(configPath, []);
+async function resolveConfiguredFileTotal(configPath, selectors = []) {
+    const files = await resolveSelectedFiles(configPath, selectors);
     return files.length;
 }
+async function previewBuildCommands(configPath, selectors, modeName, featureToggles) {
+    const files = await resolveSelectedFiles(configPath, selectors);
+    const out = {};
+    for (const file of files) {
+        const invocation = await getBuildInvocationPreview(configPath, file, modeName, featureToggles);
+        out[file] = formatBuildInvocation(invocation);
+    }
+    return out;
+}
 function resolveExecutionModes(configPath, selectedModes) {
     if (selectedModes.length)
         return selectedModes;
@@ -872,15 +1975,35 @@ async function resolveSelectedFiles(configPath, selectors, warn = true) {
     const specs = matches.filter((file) => file.endsWith(".spec.ts"));
     return [...new Set(specs)].sort((a, b) => a.localeCompare(b));
 }
-async function buildNoTestFilesMatchedError(configPath, selectors) {
+async function resolveSelectedFuzzFiles(configPath, selectors) {
+    const resolvedConfigPath = configPath ?? path.join(process.cwd(), "./as-test.config.json");
+    const config = loadConfig(resolvedConfigPath, false);
+    const patterns = resolveFuzzPatterns(config.fuzz.input, selectors);
+    const matches = await glob(patterns);
+    const fuzzFiles = matches.filter((file) => file.endsWith(".fuzz.ts"));
+    return [...new Set(fuzzFiles)].sort((a, b) => a.localeCompare(b));
+}
+async function resolveSelectedTestInputs(configPath, selectors) {
+    const [specs, fuzz] = await Promise.all([
+        resolveSelectedFiles(configPath, selectors),
+        resolveSelectedFuzzFiles(configPath, selectors),
+    ]);
+    return { specs, fuzz };
+}
+async function buildNoTestFilesMatchedError(configPath, selectors, includeFuzz = false) {
     const scope = selectors.length > 0 ? selectors.join(", ") : "configured input patterns";
     const lines = [`No test files matched: ${scope}`];
     const configuredFiles = await resolveSelectedFiles(configPath, [], false);
+    const configuredFuzzFiles = includeFuzz
+        ? await resolveSelectedFuzzFiles(configPath, [])
+        : [];
     if (!selectors.length) {
         lines.push('No specs were discovered from configured input patterns. Check "input" in config or run "ast doctor".');
         return new Error(lines.join("\n"));
     }
-    const suggestions = suggestClosestSuites(selectors, configuredFiles);
+    const suggestions = suggestClosestSuites(selectors, includeFuzz
+        ? [...configuredFiles, ...configuredFuzzFiles]
+        : configuredFiles);
     if (suggestions.length) {
         lines.push(`Closest suite names: ${suggestions.join(", ")}`);
     }
@@ -894,6 +2017,13 @@ async function buildNoTestFilesMatchedError(configPath, selectors) {
     else {
         lines.push('No specs were discovered from configured input patterns. Check "input" in config.');
     }
+    if (includeFuzz && configuredFuzzFiles.length) {
+        const sample = configuredFuzzFiles
+            .slice(0, 5)
+            .map((file) => path.basename(file))
+            .join(", ");
+        lines.push(`Configured fuzzers (${configuredFuzzFiles.length}): ${sample}${configuredFuzzFiles.length > 5 ? ", ..." : ""}`);
+    }
     lines.push('Run "ast test --list" to inspect resolved files.');
     return new Error(lines.join("\n"));
 }
@@ -980,6 +2110,27 @@ function resolveInputPatterns(configured, selectors) {
     }
     return [...patterns];
 }
+function resolveFuzzPatterns(configured, selectors) {
+    const configuredInputs = Array.isArray(configured)
+        ? configured
+        : [configured];
+    if (!selectors.length)
+        return configuredInputs;
+    const patterns = new Set();
+    for (const selector of expandSelectors(selectors)) {
+        if (!selector)
+            continue;
+        if (isBareSuiteSelector(selector)) {
+            const base = selector.replace(/\.fuzz\.ts$/, "").replace(/\.ts$/, "");
+            for (const configuredInput of configuredInputs) {
+                patterns.add(path.join(path.dirname(configuredInput), `${base}.fuzz.ts`));
+            }
+            continue;
+        }
+        patterns.add(selector);
+    }
+    return [...patterns];
+}
 function expandSelectors(selectors) {
     const expanded = [];
     for (const selector of selectors) {
@@ -1064,7 +2215,184 @@ function resolveArtifactFileNameForPreview(file, target, modeName, duplicateSpec
     const stem = ext.length ? legacy.slice(0, -ext.length) : legacy;
     return `${stem}.${disambiguator}${ext}`;
 }
-async function listExecutionPlan(command, configPath, selectors, modes, listFlags) {
+async function ensureWebBrowsersReady(configPath, modes, browserOverride) {
+    const resolvedConfigPath = configPath ?? path.join(process.cwd(), "./as-test.config.json");
+    const config = loadConfig(resolvedConfigPath, true);
+    const missing = [];
+    for (const modeName of modes) {
+        const applied = applyMode(config, modeName);
+        const active = applied.config;
+        if (!usesWebBrowser(active))
+            continue;
+        const requestedBrowser = browserOverride?.trim() || active.runOptions.runtime.browser.trim();
+        const resolved = resolveBrowserSelection(requestedBrowser);
+        if (!resolved) {
+            missing.push({ modeName, browser: requestedBrowser });
+            continue;
+        }
+        active.runOptions.runtime.browser = resolved.browser;
+        process.env.BROWSER = resolved.browser;
+    }
+    if (!missing.length)
+        return;
+    await handleMissingWebBrowsers(missing);
+}
+function resolveBrowserSelection(requested = "") {
+    if (requested.trim().length) {
+        return resolveNamedBrowser(requested);
+    }
+    const envBrowser = process.env.BROWSER?.trim() ?? "";
+    if (envBrowser.length) {
+        return resolveNamedBrowser(envBrowser);
+    }
+    const candidates = [
+        "chromium",
+        "chromium-browser",
+        "google-chrome",
+        "google-chrome-stable",
+        "chrome",
+        "msedge",
+        "firefox",
+    ];
+    for (const candidate of candidates) {
+        if (hasExecutable(candidate)) {
+            return { browser: candidate };
+        }
+    }
+    const playwrightFallback = resolvePlaywrightBrowserExecutable("chromium") ??
+        resolvePlaywrightBrowserExecutable("firefox");
+    if (playwrightFallback) {
+        return { browser: playwrightFallback };
+    }
+    return null;
+}
+function resolveNamedBrowser(browser) {
+    const normalized = browser.trim().toLowerCase();
+    if (!normalized.length)
+        return null;
+    if (browser.includes("/") ||
+        browser.includes("\\") ||
+        path.isAbsolute(browser)) {
+        return hasExecutable(browser) ? { browser } : null;
+    }
+    const aliases = {
+        chromium: ["chromium", "chromium-browser"],
+        chrome: [
+            "google-chrome",
+            "google-chrome-stable",
+            "chrome",
+            "chromium",
+            "chromium-browser",
+        ],
+        firefox: ["firefox"],
+        webkit: [],
+    };
+    const candidates = aliases[normalized] ?? [browser];
+    for (const candidate of candidates) {
+        if (hasExecutable(candidate)) {
+            return { browser: candidate };
+        }
+    }
+    const playwrightFallback = resolvePlaywrightBrowserExecutable(normalized);
+    if (playwrightFallback) {
+        return { browser: playwrightFallback };
+    }
+    return null;
+}
+function usesWebBrowser(config) {
+    return (config.buildOptions.target == "web" ||
+        config.runOptions.runtime.browser.length > 0 ||
+        config.runOptions.runtime.cmd.includes("default.web.js"));
+}
+async function handleMissingWebBrowsers(missing) {
+    const scope = missing
+        .map((entry) => entry.browser?.length
+        ? `${entry.modeName ?? "default"} (${entry.browser})`
+        : (entry.modeName ?? "default"))
+        .join(", ");
+    const details = "no web-capable browser was found in PATH, BROWSER, or Playwright cache";
+    if (!canPromptForWebInstall()) {
+        throw new Error(`web target requires a browser for mode(s) ${scope}; ${details}. Export BROWSER or install one with "npx -y playwright install chromium" or "npx -y playwright install webkit".`);
+    }
+    process.stdout.write(chalk.bold.blue("◇  Browser Setup Needed") +
+        "\n" +
+        `│  ${details}\n` +
+        "│\n");
+    const choice = await promptLine("Install Chromium with Playwright now? [Y/n] ");
+    const normalized = choice.trim().toLowerCase();
+    if (normalized == "n" || normalized == "no") {
+        throw new Error('browser install skipped. Export BROWSER or install one with "npx -y playwright install chromium" or "npx -y playwright install webkit", then rerun.');
+    }
+    if (normalized != "" && normalized != "y" && normalized != "yes") {
+        throw new Error(`invalid answer "${choice}". Expected yes or no.`);
+    }
+    const selected = "chromium";
+    process.stdout.write(chalk.dim(`installing ${selected} via Playwright...\n`));
+    const install = spawnSync("npx", ["-y", "playwright", "install", selected], {
+        stdio: "inherit",
+        shell: false,
+    });
+    if (install.status !== 0) {
+        throw new Error(`Playwright browser install failed for ${selected}`);
+    }
+    const browserPath = resolvePlaywrightBrowserExecutable(selected);
+    if (!browserPath) {
+        throw new Error(`Playwright installed ${selected}, but as-test could not locate the browser executable`);
+    }
+    process.env.BROWSER = browserPath;
+}
+function canPromptForWebInstall() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function promptLine(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+function resolvePlaywrightBrowserExecutable(browser) {
+    const cacheRoot = path.join(process.env.HOME ?? "", ".cache", "ms-playwright");
+    if (!cacheRoot.length || !existsSync(cacheRoot))
+        return null;
+    const map = {
+        chromium: ["chromium-*/chrome-linux64/chrome"],
+        chrome: ["chromium-*/chrome-linux64/chrome"],
+        firefox: ["firefox-*/firefox/firefox"],
+        webkit: ["webkit-*/pw_run.sh"],
+    };
+    const patterns = map[browser] ?? [];
+    for (const pattern of patterns) {
+        const matches = glob.sync(path.join(cacheRoot, pattern)).sort();
+        if (matches.length)
+            return matches[matches.length - 1];
+    }
+    return null;
+}
+function hasExecutable(command) {
+    if (!command.length)
+        return false;
+    if (command.includes("/") || command.includes("\\")) {
+        return existsSync(command);
+    }
+    const pathValue = process.env.PATH ?? "";
+    const suffixes = process.platform == "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+    for (const base of pathValue.split(path.delimiter)) {
+        if (!base.length)
+            continue;
+        for (const suffix of suffixes) {
+            if (existsSync(path.join(base, command + suffix)))
+                return true;
+        }
+    }
+    return false;
+}
+async function listExecutionPlan(command, configPath, selectors, modes, listFlags, fuzzEnabled = false) {
     const resolvedConfigPath = configPath ?? path.join(process.cwd(), "./as-test.config.json");
     const config = loadConfig(resolvedConfigPath, true);
     const configuredModes = Object.keys(config.modes);
@@ -1093,36 +2421,86 @@ async function listExecutionPlan(command, configPath, selectors, modes, listFlag
     }
     if (!listFlags.list)
         return;
-    const files = await resolveSelectedFiles(configPath, selectors);
-    if (!files.length) {
+    const specFiles = command == "fuzz" ? [] : await resolveSelectedFiles(configPath, selectors);
+    const fuzzFiles = command == "fuzz"
+        ? await resolveSelectedFuzzFiles(configPath, selectors)
+        : command == "test" && fuzzEnabled
+            ? await resolveSelectedFuzzFiles(configPath, selectors)
+            : [];
+    const files = command == "fuzz" ? fuzzFiles : specFiles;
+    if (!specFiles.length && !fuzzFiles.length) {
         const scope = selectors.length > 0 ? selectors.join(", ") : "configured input patterns";
-        throw new Error(`No test files matched: ${scope}`);
+        throw new Error(command == "fuzz"
+            ? `No fuzz files matched: ${scope}`
+            : `No test files matched: ${scope}`);
     }
-    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
-    process.stdout.write(chalk.bold("Resolved files:\n"));
-    for (const file of files) {
-        process.stdout.write(`  - ${file}\n`);
+    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(specFiles);
+    const duplicateFuzzBasenames = resolveDuplicateSpecBasenames(fuzzFiles);
+    if (specFiles.length) {
+        process.stdout.write(chalk.bold("Resolved files:\n"));
+        for (const file of specFiles) {
+            process.stdout.write(`  - ${file}\n`);
+        }
+        process.stdout.write("\n");
+    }
+    if (fuzzFiles.length && command == "test") {
+        process.stdout.write(chalk.bold("Resolved fuzz files:\n"));
+        for (const file of fuzzFiles) {
+            process.stdout.write(`  - ${file}\n`);
+        }
+        process.stdout.write("\n");
+    }
+    if (command == "fuzz" && fuzzFiles.length) {
+        process.stdout.write(chalk.bold("Resolved files:\n"));
+        for (const file of fuzzFiles) {
+            process.stdout.write(`  - ${file}\n`);
+        }
+        process.stdout.write("\n");
     }
-    process.stdout.write("\n");
     for (const modeName of modes) {
         const applied = applyMode(config, modeName);
         const active = applied.config;
         const modeLabel = modeName ?? "default";
         process.stdout.write(chalk.bold(`Mode: ${modeLabel}\n`));
-        process.stdout.write(`  target: ${active.buildOptions.target}\n`);
+        process.stdout.write(`  target: ${command == "fuzz" ? "bindings" : active.buildOptions.target}\n`);
         process.stdout.write(`  outDir: ${active.outDir}\n`);
-        if (command != "build") {
+        if (command == "run" || command == "test") {
             process.stdout.write(`  runtime: ${active.runOptions.runtime.cmd}\n`);
+            if (usesWebBrowser(active)) {
+                process.stdout.write(`  browser: ${active.runOptions.runtime.browser || "(auto)"}\n`);
+            }
         }
-        const envOverrides = modeName
-            ? (config.modes[modeName]?.env ?? {})
-            : config.env;
+        const envOverrides = {
+            ...config.env,
+            ...(modeName ? (config.modes[modeName]?.env ?? {}) : {}),
+            ...(command == "build"
+                ? active.buildOptions.env
+                : command == "run" || command == "test"
+                    ? active.runOptions.env
+                    : {}),
+        };
         const envKeys = Object.keys(envOverrides);
         process.stdout.write(`  env overrides: ${envKeys.length}${envKeys.length ? ` (${envKeys.join(", ")})` : ""}\n`);
-        process.stdout.write("  artifacts:\n");
-        for (const file of files) {
-            const artifactName = resolveArtifactFileNameForPreview(file, active.buildOptions.target, modeName, duplicateSpecBasenames);
-            process.stdout.write(`    - ${path.join(active.outDir, artifactName)}\n`);
+        if (specFiles.length) {
+            process.stdout.write("  artifacts:\n");
+            for (const file of specFiles) {
+                const artifactName = resolveArtifactFileNameForPreview(file, active.buildOptions.target, modeName, duplicateSpecBasenames);
+                process.stdout.write(`    - ${path.join(active.outDir, artifactName)}\n`);
+            }
+        }
+        if (fuzzFiles.length && command == "test") {
+            process.stdout.write("  fuzz artifacts:\n");
+            for (const file of fuzzFiles) {
+                const artifactName = resolveArtifactFileNameForPreview(file, "bindings", modeName, duplicateFuzzBasenames);
+                process.stdout.write(`    - ${path.join(active.outDir, artifactName)}\n`);
+            }
+        }
+        else if (command == "fuzz") {
+            process.stdout.write("  artifacts:\n");
+            for (const file of fuzzFiles) {
+                const artifactName = resolveArtifactFileNameForPreview(file, "bindings", modeName, duplicateFuzzBasenames);
+                process.stdout.write(`    - ${path.join(active.outDir, artifactName)}\n`);
+            }
         }
         process.stdout.write("\n");
     }