as-test 1.0.1 → 1.0.4

package/bin/commands/build-core.js

@@ -1,38 +1,129 @@
 import { existsSync } from "fs";
 import { glob } from "glob";
 import chalk from "chalk";
-import { spawnSync } from "child_process";
+import { spawn } from "child_process";
 import * as path from "path";
+import { createMemoryStream, main as ascMain, } from "assemblyscript/dist/asc.js";
 import { applyMode, getPkgRunner, loadConfig, tokenizeCommand, resolveProjectModule, } from "../util.js";
+import { persistCrashRecord } from "../crash-store.js";
+import { BuildWorkerPool } from "../build-worker-pool.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
-export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, featureToggles = {}) {
+class BuildFailureError extends Error {
+    constructor(args) {
+        super(args.message);
+        this.name = "BuildFailureError";
+        this.file = args.file;
+        this.mode = args.mode;
+        this.invocation = args.invocation;
+        this.stdout = args.stdout;
+        this.stderr = args.stderr;
+        this.kind = args.kind;
+    }
+}
+export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, featureToggles = {}, overrides = {}) {
     const loadedConfig = loadConfig(configPath, false);
     const mode = applyMode(loadedConfig, modeName);
-    const config = mode.config;
+    const config = Object.assign(Object.create(Object.getPrototypeOf(mode.config)), mode.config);
+    config.buildOptions = Object.assign(Object.create(Object.getPrototypeOf(mode.config.buildOptions)), mode.config.buildOptions);
+    if (overrides.target) {
+        config.buildOptions.target = overrides.target;
+    }
+    if (overrides.args?.length) {
+        config.buildOptions.args = [...config.buildOptions.args, ...overrides.args];
+    }
     if (!hasCustomBuildCommand(config)) {
         ensureDeps(config);
     }
     const pkgRunner = getPkgRunner();
     const inputPatterns = resolveInputPatterns(config.input, selectors);
     const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
-    const duplicateSpecBasenames = await resolveDuplicateSpecBasenames(config.input);
+    const duplicateSpecBasenames = resolveDuplicateBasenames(inputFiles);
     const coverageEnabled = resolveCoverageEnabled(config.coverage, featureToggles.coverage);
     const buildEnv = {
         ...mode.env,
+        ...config.buildOptions.env,
         AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
     };
+    if (!process.env.AS_TEST_BUILD_API && !hasCustomBuildCommand(config)) {
+        const pool = getSerialBuildWorkerPool();
+        for (const file of inputFiles) {
+            await pool.buildFileMode({
+                configPath,
+                file,
+                modeName,
+                featureToggles,
+                overrides,
+            });
+        }
+        return;
+    }
     for (const file of inputFiles) {
         const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
         const invocation = getBuildCommand(config, pkgRunner, file, outFile, modeName, featureToggles);
         try {
-            buildFile(invocation, buildEnv);
+            await buildFile(invocation, buildEnv);
         }
         catch (error) {
             const modeLabel = modeName ?? "default";
-            throw new Error(`Failed to build ${path.basename(file)} in mode ${modeLabel} with ${getBuildStderr(error)}\nBuild command: ${formatInvocation(invocation)}`);
+            const stdout = getBuildStdout(error);
+            const stderr = getBuildStderr(error);
+            const buildCommand = formatInvocation(invocation);
+            const kind = overrides.kind ?? "test";
+            const crash = persistCrashRecord(config.fuzz.crashDir, {
+                kind,
+                stage: "build",
+                file,
+                mode: modeLabel,
+                cwd: process.cwd(),
+                buildCommand,
+                reproCommand: buildCommand,
+                error: stderr || stdout || "unknown build error",
+                stdout,
+                stderr,
+            });
+            throw new BuildFailureError({
+                file,
+                mode: modeLabel,
+                invocation,
+                stdout,
+                stderr,
+                kind,
+                message: `Failed to build ${path.basename(file)} in mode ${modeLabel} with ${stderr || stdout || "unknown build error"}\n` +
+                    `Build command: ${buildCommand}\n` +
+                    `Crash log: ${crash.logPath}`,
+            });
         }
     }
 }
+let serialBuildWorkerPool = null;
+function getSerialBuildWorkerPool() {
+    if (!serialBuildWorkerPool) {
+        serialBuildWorkerPool = new BuildWorkerPool(1);
+    }
+    return serialBuildWorkerPool;
+}
+export async function closeSerialBuildWorkerPool() {
+    if (!serialBuildWorkerPool)
+        return;
+    const pool = serialBuildWorkerPool;
+    serialBuildWorkerPool = null;
+    await pool.close();
+}
+export async function getBuildInvocationPreview(configPath = DEFAULT_CONFIG_PATH, file, modeName, featureToggles = {}, overrides = {}) {
+    const loadedConfig = loadConfig(configPath, false);
+    const mode = applyMode(loadedConfig, modeName);
+    const config = Object.assign(Object.create(Object.getPrototypeOf(mode.config)), mode.config);
+    config.buildOptions = Object.assign(Object.create(Object.getPrototypeOf(mode.config.buildOptions)), mode.config.buildOptions);
+    if (overrides.target) {
+        config.buildOptions.target = overrides.target;
+    }
+    if (overrides.args?.length) {
+        config.buildOptions.args = [...config.buildOptions.args, ...overrides.args];
+    }
+    const duplicateSpecBasenames = resolveDuplicateBasenames([file]);
+    const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+    return getBuildCommand(config, getPkgRunner(), file, outFile, modeName, featureToggles);
+}
 function hasCustomBuildCommand(config) {
     return !!config.buildOptions.cmd.trim().length;
 }
@@ -49,13 +140,31 @@ function getBuildCommand(config, pkgRunner, file, outFile, modeName, featureTogg
         };
     }
     const defaultArgs = getDefaultBuildArgs(config, featureToggles);
-    const args = ["asc", file, ...userArgs, ...defaultArgs];
+    const ascInvocation = resolveAscInvocation(pkgRunner);
+    const args = [...ascInvocation.args, file, ...userArgs, ...defaultArgs];
     if (config.outDir.length) {
         args.push("-o", outFile);
     }
     return {
-        command: pkgRunner,
+        command: ascInvocation.command,
         args,
+        apiArgs: args.slice(1),
+    };
+}
+function resolveAscInvocation(pkgRunner) {
+    const assemblyscriptPkg = resolveProjectModule("assemblyscript/package.json");
+    if (assemblyscriptPkg) {
+        const ascPath = path.join(path.dirname(assemblyscriptPkg), "bin", "asc.js");
+        if (existsSync(ascPath)) {
+            return {
+                command: process.execPath,
+                args: [ascPath],
+            };
+        }
+    }
+    return {
+        command: pkgRunner,
+        args: ["asc"],
     };
 }
 function getUserBuildArgs(config) {
@@ -98,9 +207,7 @@ function resolveArtifactFileName(file, target, modeName, duplicateSpecBasenames
     const stem = ext.length ? legacy.slice(0, -ext.length) : legacy;
     return `${stem}.${disambiguator}${ext}`;
 }
-async function resolveDuplicateSpecBasenames(configured) {
-    const patterns = Array.isArray(configured) ? configured : [configured];
-    const files = await glob(patterns);
+function resolveDuplicateBasenames(files) {
     const counts = new Map();
     for (const file of files) {
         const base = path.basename(file);
@@ -183,21 +290,96 @@ function ensureDeps(config) {
         }
     }
 }
-function buildFile(invocation, env) {
-    const result = spawnSync(invocation.command, invocation.args, {
-        stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf8",
-        env,
-        shell: false,
+async function buildFile(invocation, env) {
+    if (process.env.AS_TEST_BUILD_API == "1" && invocation.apiArgs?.length) {
+        await buildFileViaApi(invocation.apiArgs, env);
+        return;
+    }
+    await buildFileViaSpawn(invocation, env);
+}
+async function buildFileViaApi(args, env) {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const stdout = createMemoryStream((chunk) => {
+        stdoutChunks.push(typeof chunk == "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+    });
+    const stderr = createMemoryStream((chunk) => {
+        stderrChunks.push(typeof chunk == "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+    });
+    const previousEnv = snapshotEnv();
+    applyEnv(env);
+    try {
+        const result = await ascMain(args, { stdout, stderr });
+        if (result.error) {
+            const error = result.error;
+            error.stderr = stderrChunks.join("").trim();
+            error.stdout = stdoutChunks.join("").trim();
+            throw error;
+        }
+    }
+    finally {
+        restoreEnv(previousEnv);
+    }
+}
+async function buildFileViaSpawn(invocation, env) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(invocation.command, invocation.args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env,
+            shell: false,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const error = new Error(stderr.trim() || stdout.trim() || `command exited with code ${code}`);
+            error.stderr = stderr.trim();
+            error.stdout = stdout.trim();
+            reject(error);
+        });
     });
-    if (result.error)
-        throw result.error;
-    if (result.status !== 0) {
-        const error = new Error(result.stderr?.trim() ||
-            result.stdout?.trim() ||
-            `command exited with code ${result.status}`);
-        error.stderr = result.stderr ?? "";
-        throw error;
+}
+function snapshotEnv() {
+    return { ...process.env };
+}
+function applyEnv(nextEnv) {
+    const keys = new Set([
+        ...Object.keys(process.env),
+        ...Object.keys(nextEnv),
+    ]);
+    for (const key of keys) {
+        const value = nextEnv[key];
+        if (value == undefined) {
+            delete process.env[key];
+        }
+        else {
+            process.env[key] = value;
+        }
+    }
+}
+function restoreEnv(previousEnv) {
+    const keys = new Set([
+        ...Object.keys(process.env),
+        ...Object.keys(previousEnv),
+    ]);
+    for (const key of keys) {
+        const value = previousEnv[key];
+        if (value == undefined) {
+            delete process.env[key];
+        }
+        else {
+            process.env[key] = value;
+        }
     }
 }
 function formatInvocation(invocation) {
@@ -205,6 +387,7 @@ function formatInvocation(invocation) {
         .map((token) => (/\s/.test(token) ? JSON.stringify(token) : token))
         .join(" ");
 }
+export { getBuildCommand, formatInvocation };
 function getBuildStderr(error) {
     const err = error;
     const stderr = err?.stderr;
@@ -221,6 +404,15 @@ function getBuildStderr(error) {
     const message = typeof err?.message == "string" ? err.message.trim() : "";
     return message || "unknown error";
 }
+function getBuildStdout(error) {
+    const err = error;
+    const stdout = err?.stdout;
+    if (typeof stdout == "string")
+        return stdout.trim();
+    if (stdout instanceof Buffer)
+        return stdout.toString("utf8").trim();
+    return "";
+}
 function getDefaultBuildArgs(config, featureToggles) {
     const buildArgs = [];
     const tryAsEnabled = resolveTryAsEnabled(featureToggles.tryAs);
@@ -235,7 +427,8 @@ function getDefaultBuildArgs(config, featureToggles) {
         buildArgs.push("--use", "AS_TEST_TRY_AS=1");
     }
     // Should also strip any bindings-enabling from asconfig
-    if (config.buildOptions.target == "bindings") {
+    if (config.buildOptions.target == "bindings" ||
+        config.buildOptions.target == "web") {
         buildArgs.push("--use", "AS_TEST_BINDINGS=1", "--bindings", "raw", "--exportRuntime", "--exportStart", "_start");
     }
     else if (config.buildOptions.target == "wasi") {
@@ -246,7 +439,7 @@ function getDefaultBuildArgs(config, featureToggles) {
         buildArgs.push("--use", "AS_TEST_WASI=1", "--config", wasiShim.configPath);
     }
     else {
-        console.log(`${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not determine target in config! Set target to 'bindings' or 'wasi'`);
+        console.log(`${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not determine target in config! Set target to 'bindings', 'web', or 'wasi'`);
         process.exit(1);
     }
     return buildArgs;
@@ -258,7 +451,7 @@ function resolveTryAsEnabled(override) {
     if (override === true && !installed) {
         throw new Error('try-as feature was enabled, but package "try-as" is not installed');
     }
-    return installed;
+    return false;
 }
 function resolveCoverageEnabled(rawCoverage, override) {
     if (override != undefined)

package/bin/commands/build.js

@@ -1,8 +1,11 @@
+import { closeSerialBuildWorkerPool, } from "./build-core.js";
 export { build } from "./build-core.js";
+export { formatInvocation, getBuildInvocationPreview } from "./build-core.js";
 export async function executeBuildCommand(rawArgs, configPath, selectedModes, deps) {
     const commandArgs = deps.resolveCommandArgs(rawArgs, "build");
     const listFlags = deps.resolveListFlags(rawArgs, "build");
     const featureToggles = deps.resolveFeatureToggles(rawArgs, "build");
+    const parallel = deps.resolveBuildParallelJobs(rawArgs);
     const buildFeatureToggles = {
         tryAs: featureToggles.tryAs,
         coverage: featureToggles.coverage,
@@ -12,5 +15,18 @@ export async function executeBuildCommand(rawArgs, configPath, selectedModes, de
         await deps.listExecutionPlan("build", configPath, commandArgs, modeTargets, listFlags);
         return;
     }
-    await deps.runBuildModes(configPath, commandArgs, modeTargets, buildFeatureToggles);
+    const previousBuildApi = process.env.AS_TEST_BUILD_API;
+    process.env.AS_TEST_BUILD_API = "1";
+    try {
+        await deps.runBuildModes(configPath, commandArgs, modeTargets, buildFeatureToggles, parallel);
+    }
+    finally {
+        if (previousBuildApi == undefined) {
+            delete process.env.AS_TEST_BUILD_API;
+        }
+        else {
+            process.env.AS_TEST_BUILD_API = previousBuildApi;
+        }
+        await closeSerialBuildWorkerPool();
+    }
 }

package/bin/commands/fuzz-core.js

@@ -0,0 +1,306 @@
+import { existsSync, readFileSync } from "fs";
+import * as path from "path";
+import { pathToFileURL } from "url";
+import { glob } from "glob";
+import { build } from "./build-core.js";
+import { applyMode, loadConfig } from "../util.js";
+import { persistCrashRecord } from "../crash-store.js";
+const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
+const MAGIC = Buffer.from("WIPC");
+const HEADER_SIZE = 9;
+export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, overrides = {}) {
+    const loadedConfig = loadConfig(configPath, false);
+    const mode = applyMode(loadedConfig, modeName);
+    const config = resolveFuzzConfig(loadedConfig.fuzz, overrides);
+    const inputPatterns = resolveFuzzInputPatterns(config.input, selectors);
+    const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
+    if (!inputFiles.length) {
+        throw new Error(`No fuzz files matched: ${selectors.length ? selectors.join(", ") : "configured input patterns"}`);
+    }
+    const duplicateBasenames = resolveDuplicateBasenames(inputFiles);
+    const results = [];
+    for (const file of inputFiles) {
+        const buildStartedAt = Date.now();
+        await build(configPath, [file], modeName, { coverage: false }, { target: "bindings", args: ["--use", "AS_TEST_FUZZ=1"], kind: "fuzz" });
+        const buildFinishedAt = Date.now();
+        const buildTime = buildFinishedAt - buildStartedAt;
+        results.push(await runFuzzTarget(file, mode.config.outDir, duplicateBasenames, config, buildStartedAt, buildFinishedAt, buildTime, modeName));
+    }
+    return results;
+}
+function resolveFuzzConfig(raw, overrides) {
+    const config = Object.assign({}, raw, overrides);
+    if (config.target != "bindings") {
+        throw new Error(`fuzz target must be "bindings"; received "${config.target}"`);
+    }
+    return config;
+}
+async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStartedAt, buildFinishedAt, buildTime, modeName) {
+    const startedAt = Date.now();
+    const artifact = resolveArtifactFileName(file, duplicateBasenames, modeName);
+    const wasmPath = path.resolve(process.cwd(), outDir, artifact);
+    const jsPath = resolveBindingsHelperPath(wasmPath);
+    const helper = await import(pathToFileURL(jsPath).href + `?t=${Date.now()}`);
+    const binary = readFileSync(wasmPath);
+    const module = new WebAssembly.Module(binary);
+    let report = null;
+    const captured = captureFrames((type, payload, respond) => {
+        if (type == 0x02) {
+            const event = JSON.parse(payload.toString("utf8"));
+            if (String(event.kind ?? "") == "fuzz:config") {
+                respond(`${config.runs}\n${config.seed}`);
+            }
+            else {
+                respond("");
+            }
+            return;
+        }
+        if (type == 0x03) {
+            report = JSON.parse(payload.toString("utf8"));
+        }
+    });
+    try {
+        await helper.instantiate(module, {});
+    }
+    catch (error) {
+        const passthrough = captured.restore();
+        const crashMessage = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        const crash = persistCrashRecord(config.crashDir, {
+            kind: "fuzz",
+            file,
+            mode: modeName ?? "default",
+            seed: config.seed,
+            error: crashMessage,
+            stdout: passthrough.stdout,
+            stderr: "",
+        });
+        return {
+            file,
+            target: path.basename(file),
+            modeName: modeName ?? "default",
+            runs: config.runs,
+            crashes: 1,
+            crashFiles: [crash.jsonPath],
+            seed: config.seed,
+            time: Date.now() - startedAt,
+            buildTime,
+            buildStartedAt,
+            buildFinishedAt,
+            fuzzers: [],
+        };
+    }
+    const passthrough = captured.restore();
+    if (!report?.fuzzers) {
+        const crash = persistCrashRecord(config.crashDir, {
+            kind: "fuzz",
+            file,
+            mode: modeName ?? "default",
+            seed: config.seed,
+            error: `missing fuzz report payload from ${path.basename(file)}`,
+            stdout: passthrough.stdout,
+            stderr: "",
+        });
+        return {
+            file,
+            target: path.basename(file),
+            modeName: modeName ?? "default",
+            runs: config.runs,
+            crashes: 1,
+            crashFiles: [crash.jsonPath],
+            seed: config.seed,
+            time: Date.now() - startedAt,
+            buildTime,
+            buildStartedAt,
+            buildFinishedAt,
+            fuzzers: [],
+        };
+    }
+    return {
+        file,
+        target: path.basename(file),
+        modeName: modeName ?? "default",
+        runs: report.fuzzers.reduce((sum, item) => sum + item.runs, 0),
+        crashes: report.fuzzers.reduce((sum, item) => sum + item.crashed, 0),
+        crashFiles: [],
+        seed: config.seed,
+        time: Date.now() - startedAt,
+        buildTime,
+        buildStartedAt,
+        buildFinishedAt,
+        fuzzers: report.fuzzers,
+    };
+}
+function captureFrames(onFrame) {
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    const originalRead = typeof process.stdin.read == "function"
+        ? process.stdin.read.bind(process.stdin)
+        : null;
+    let buffer = Buffer.alloc(0);
+    let passthrough = Buffer.alloc(0);
+    let replies = Buffer.alloc(0);
+    function encodeReply(body) {
+        const payload = Buffer.from(body, "utf8");
+        const header = Buffer.alloc(HEADER_SIZE);
+        MAGIC.copy(header, 0);
+        header.writeUInt8(0x02, 4);
+        header.writeUInt32LE(payload.length, 5);
+        return Buffer.concat([header, payload]);
+    }
+    function dequeueReply(length) {
+        const available = Math.min(length, replies.length);
+        const view = replies.subarray(0, available);
+        replies = replies.subarray(available);
+        return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+    }
+    process.stdout.write = ((chunk, ...args) => {
+        if (!(chunk instanceof ArrayBuffer) && !Buffer.isBuffer(chunk)) {
+            return originalWrite(chunk, ...args);
+        }
+        const incoming = Buffer.from(chunk);
+        buffer = Buffer.concat([buffer, incoming]);
+        while (true) {
+            const index = buffer.indexOf(MAGIC);
+            if (index == -1) {
+                if (buffer.length) {
+                    passthrough = Buffer.concat([passthrough, buffer]);
+                    originalWrite(buffer);
+                    buffer = Buffer.alloc(0);
+                }
+                return true;
+            }
+            if (index > 0) {
+                const raw = buffer.subarray(0, index);
+                passthrough = Buffer.concat([passthrough, raw]);
+                originalWrite(raw);
+                buffer = buffer.subarray(index);
+            }
+            if (buffer.length < HEADER_SIZE)
+                return true;
+            const type = buffer.readUInt8(4);
+            const length = buffer.readUInt32LE(5);
+            const frameSize = HEADER_SIZE + length;
+            if (buffer.length < frameSize)
+                return true;
+            const payload = buffer.subarray(HEADER_SIZE, frameSize);
+            buffer = buffer.subarray(frameSize);
+            onFrame(type, payload, (body) => {
+                replies = Buffer.concat([replies, encodeReply(body)]);
+            });
+        }
+    });
+    process.stdin.read = ((size) => {
+        const max = Number(size ?? 0);
+        if (max > 0 && replies.length) {
+            return dequeueReply(max);
+        }
+        if (originalRead) {
+            return originalRead(size);
+        }
+        return null;
+    });
+    return {
+        restore() {
+            process.stdout.write = originalWrite;
+            if (originalRead) {
+                process.stdin.read = originalRead;
+            }
+            return {
+                stdout: passthrough.toString("utf8"),
+            };
+        },
+    };
+}
+function resolveFuzzInputPatterns(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 (isBareSelector(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 resolveArtifactFileName(file, duplicateBasenames, modeName) {
+    const base = path
+        .basename(file)
+        .replace(/\.spec\.ts$/, "")
+        .replace(/\.ts$/, "");
+    const legacy = !modeName
+        ? `${path.basename(file).replace(".ts", ".wasm")}`
+        : `${base}.${modeName}.bindings.wasm`;
+    if (!duplicateBasenames.has(path.basename(file))) {
+        return legacy;
+    }
+    const disambiguator = resolveDisambiguator(file);
+    if (!disambiguator.length) {
+        return legacy;
+    }
+    const ext = path.extname(legacy);
+    const stem = ext.length ? legacy.slice(0, -ext.length) : legacy;
+    return `${stem}.${disambiguator}${ext}`;
+}
+function resolveDuplicateBasenames(files) {
+    const counts = new Map();
+    for (const file of files) {
+        const base = path.basename(file);
+        counts.set(base, (counts.get(base) ?? 0) + 1);
+    }
+    const duplicates = new Set();
+    for (const [base, count] of counts) {
+        if (count > 1)
+            duplicates.add(base);
+    }
+    return duplicates;
+}
+function resolveDisambiguator(file) {
+    const relDir = path.dirname(path.relative(process.cwd(), file));
+    if (!relDir.length || relDir == ".")
+        return "";
+    return relDir
+        .replace(/[\\/]+/g, "__")
+        .replace(/[^A-Za-z0-9._-]/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+function resolveBindingsHelperPath(wasmPath) {
+    const bindingsPath = wasmPath.replace(/\.wasm$/, ".bindings.js");
+    if (existsSync(bindingsPath))
+        return bindingsPath;
+    const directPath = wasmPath.replace(/\.wasm$/, ".js");
+    if (existsSync(directPath))
+        return directPath;
+    return bindingsPath;
+}
+function expandSelectors(selectors) {
+    const expanded = [];
+    for (const selector of selectors) {
+        if (selector.includes(",") &&
+            !selector.includes("/") &&
+            !selector.includes("\\") &&
+            !/[*?[\]{}]/.test(selector)) {
+            for (const token of selector.split(",")) {
+                const trimmed = token.trim();
+                if (trimmed.length)
+                    expanded.push(trimmed);
+            }
+            continue;
+        }
+        expanded.push(selector);
+    }
+    return expanded;
+}
+function isBareSelector(selector) {
+    return (!selector.includes("/") &&
+        !selector.includes("\\") &&
+        !/[*?[\]{}]/.test(selector));
+}

package/bin/commands/fuzz.js

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