as-test 1.1.6 → 1.1.8

package/bin/commands/fuzz-core.js

@@ -9,465 +9,518 @@ const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 const MAGIC = Buffer.from("WIPC");
 const HEADER_SIZE = 9;
 const MAX_DEFAULT_SEED = 0x7fffffff;
-export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, overrides = {}, fuzzerSelectors = []) {
-    const loadedConfig = loadConfig(configPath, false);
-    const mode = applyMode(loadedConfig, modeName);
-    const activeConfig = mode.config;
-    const config = resolveFuzzConfig(activeConfig.fuzz, overrides);
-    const inputPatterns = resolveFuzzInputPatterns(config.input, selectors);
-    const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
-    if (!inputFiles.length) {
-        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" }, loadedConfig);
-        const buildFinishedAt = Date.now();
-        const buildTime = buildFinishedAt - buildStartedAt;
-        results.push(await runFuzzTarget(file, activeConfig.outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName));
-    }
-    return results;
+export async function fuzz(
+  configPath = DEFAULT_CONFIG_PATH,
+  selectors = [],
+  modeName,
+  overrides = {},
+  fuzzerSelectors = [],
+) {
+  const loadedConfig = loadConfig(configPath, false);
+  const mode = applyMode(loadedConfig, modeName);
+  const activeConfig = mode.config;
+  const config = resolveFuzzConfig(activeConfig.fuzz, overrides);
+  const inputPatterns = resolveFuzzInputPatterns(config.input, selectors);
+  const inputFiles = (await glob(inputPatterns)).sort((a, b) =>
+    a.localeCompare(b),
+  );
+  if (!inputFiles.length) {
+    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" },
+      loadedConfig,
+    );
+    const buildFinishedAt = Date.now();
+    const buildTime = buildFinishedAt - buildStartedAt;
+    results.push(
+      await runFuzzTarget(
+        file,
+        activeConfig.outDir,
+        duplicateBasenames,
+        config,
+        fuzzerSelectors,
+        buildStartedAt,
+        buildFinishedAt,
+        buildTime,
+        modeName,
+      ),
+    );
+  }
+  return results;
 }
 function resolveFuzzConfig(raw, overrides) {
-    const config = Object.assign({}, raw);
-    if (typeof overrides.seed == "number") {
-        config.seed = overrides.seed;
-    }
-    else if (config.seed < 0) {
-        config.seed = generateRandomSeed();
+  const config = Object.assign({}, raw);
+  if (typeof overrides.seed == "number") {
+    config.seed = overrides.seed;
+  } else if (config.seed < 0) {
+    config.seed = generateRandomSeed();
+  }
+  if (typeof overrides.runs == "number") {
+    config.runs = overrides.runs;
+  }
+  config.runsOverrideKind = 0;
+  config.runsOverrideValue = 0;
+  if (overrides.runsOverride) {
+    config.runsOverrideKind = encodeRunsOverrideKind(
+      overrides.runsOverride.kind,
+    );
+    config.runsOverrideValue = overrides.runsOverride.value;
+    if (overrides.runsOverride.kind == "set") {
+      config.runs = Math.max(1, Math.round(overrides.runsOverride.value));
     }
-    if (typeof overrides.runs == "number") {
-        config.runs = overrides.runs;
-    }
-    config.runsOverrideKind = 0;
-    config.runsOverrideValue = 0;
-    if (overrides.runsOverride) {
-        config.runsOverrideKind = encodeRunsOverrideKind(overrides.runsOverride.kind);
-        config.runsOverrideValue = overrides.runsOverride.value;
-        if (overrides.runsOverride.kind == "set") {
-            config.runs = Math.max(1, Math.round(overrides.runsOverride.value));
-        }
-    }
-    if (config.target != "bindings") {
-        throw new Error(`fuzz target must be "bindings"; received "${config.target}"`);
-    }
-    return config;
+  }
+  if (config.target != "bindings") {
+    throw new Error(
+      `fuzz target must be "bindings"; received "${config.target}"`,
+    );
+  }
+  return config;
 }
 function generateRandomSeed() {
-    return Math.floor(Math.random() * (MAX_DEFAULT_SEED + 1));
+  return Math.floor(Math.random() * (MAX_DEFAULT_SEED + 1));
 }
 function encodeRunsOverrideKind(kind) {
-    switch (kind) {
-        case "set":
-            return 1;
-        case "scale":
-            return 2;
-        case "add":
-            return 3;
-        case "percent-add":
-            return 4;
-    }
+  switch (kind) {
+    case "set":
+      return 1;
+    case "scale":
+      return 2;
+    case "add":
+      return 3;
+    case "percent-add":
+      return 4;
+  }
 }
-async function runFuzzTarget(file, outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName) {
-    const startedAt = Date.now();
-    const artifact = resolveArtifactFileName(file, duplicateBasenames, modeName);
-    const wasmPath = path.resolve(process.cwd(), outDir, artifact);
-    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;
-    let reportParseError = null;
-    const reportStream = {
-        sawChunkStart: false,
-        sawChunkEnd: false,
-        chunkCountExpected: 0,
-        chunkTotalBytesExpected: 0,
-        chunkFramesReceived: 0,
-        chunkBytesReceived: 0,
-        chunks: [],
-    };
-    const captured = captureFrames((type, payload, respond) => {
-        if (type == 0x02) {
-            const event = JSON.parse(payload.toString("utf8"));
-            const kind = String(event.kind ?? "");
-            if (kind == "fuzz:config") {
-                const resolved = config;
-                respond(`${config.runs}\n${config.seed}\n${resolved.runsOverrideKind ?? 0}\n${resolved.runsOverrideValue ?? 0}`);
-            }
-            else if (kind == "report:start") {
-                reportStream.sawChunkStart = true;
-                reportStream.sawChunkEnd = false;
-                reportStream.chunkCountExpected = Number(event.chunkCount ?? 0);
-                reportStream.chunkTotalBytesExpected = Number(event.totalBytes ?? 0);
-                reportStream.chunkFramesReceived = 0;
-                reportStream.chunkBytesReceived = 0;
-                reportStream.chunks = [];
-            }
-            else if (kind == "report:end") {
-                reportStream.sawChunkEnd = true;
-            }
-            else {
-                respond("");
-            }
-            return;
-        }
-        if (type == 0x03) {
-            if (reportStream.sawChunkStart && !reportStream.sawChunkEnd) {
-                reportStream.chunkFramesReceived++;
-                reportStream.chunkBytesReceived += payload.length;
-                reportStream.chunks.push(payload.toString("utf8"));
-            }
-            else {
-                try {
-                    report = JSON.parse(payload.toString("utf8"));
-                    reportParseError = null;
-                }
-                catch (error) {
-                    reportParseError = String(error);
-                }
-            }
-        }
-    });
-    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,
-            entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
-            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: [],
-        };
+async function runFuzzTarget(
+  file,
+  outDir,
+  duplicateBasenames,
+  config,
+  fuzzerSelectors,
+  buildStartedAt,
+  buildFinishedAt,
+  buildTime,
+  modeName,
+) {
+  const startedAt = Date.now();
+  const artifact = resolveArtifactFileName(file, duplicateBasenames, modeName);
+  const wasmPath = path.resolve(process.cwd(), outDir, artifact);
+  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;
+  let reportParseError = null;
+  const reportStream = {
+    sawChunkStart: false,
+    sawChunkEnd: false,
+    chunkCountExpected: 0,
+    chunkTotalBytesExpected: 0,
+    chunkFramesReceived: 0,
+    chunkBytesReceived: 0,
+    chunks: [],
+  };
+  const captured = captureFrames((type, payload, respond) => {
+    if (type == 0x02) {
+      const event = JSON.parse(payload.toString("utf8"));
+      const kind = String(event.kind ?? "");
+      if (kind == "fuzz:config") {
+        const resolved = config;
+        respond(
+          `${config.runs}\n${config.seed}\n${resolved.runsOverrideKind ?? 0}\n${resolved.runsOverrideValue ?? 0}`,
+        );
+      } else if (kind == "report:start") {
+        reportStream.sawChunkStart = true;
+        reportStream.sawChunkEnd = false;
+        reportStream.chunkCountExpected = Number(event.chunkCount ?? 0);
+        reportStream.chunkTotalBytesExpected = Number(event.totalBytes ?? 0);
+        reportStream.chunkFramesReceived = 0;
+        reportStream.chunkBytesReceived = 0;
+        reportStream.chunks = [];
+      } else if (kind == "report:end") {
+        reportStream.sawChunkEnd = true;
+      } else {
+        respond("");
+      }
+      return;
     }
-    const passthrough = captured.restore();
-    if (reportStream.sawChunkStart) {
-        if (reportStream.sawChunkEnd) {
-            const chunkedPayload = reportStream.chunks.join("");
-            try {
-                report = JSON.parse(chunkedPayload);
-                reportParseError = null;
-            }
-            catch (error) {
-                reportParseError = String(error);
-            }
+    if (type == 0x03) {
+      if (reportStream.sawChunkStart && !reportStream.sawChunkEnd) {
+        reportStream.chunkFramesReceived++;
+        reportStream.chunkBytesReceived += payload.length;
+        reportStream.chunks.push(payload.toString("utf8"));
+      } else {
+        try {
+          report = JSON.parse(payload.toString("utf8"));
+          reportParseError = null;
+        } catch (error) {
+          reportParseError = String(error);
         }
+      }
     }
-    if (!report?.fuzzers) {
-        const diagnostics = [
-            `chunked=${reportStream.sawChunkStart ? "yes" : "no"}`,
-            `chunkStart=${reportStream.sawChunkStart ? "yes" : "no"}`,
-            `chunkEnd=${reportStream.sawChunkEnd ? "yes" : "no"}`,
-            `chunkFrames=${reportStream.chunkFramesReceived}`,
-            `expectedChunkFrames=${reportStream.chunkCountExpected}`,
-            `chunkBytes=${reportStream.chunkBytesReceived}`,
-            `expectedChunkBytes=${reportStream.chunkTotalBytesExpected}`,
-        ].join(", ");
-        const crash = persistCrashRecord(config.crashDir, {
-            kind: "fuzz",
-            file,
-            entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
-            mode: modeName ?? "default",
-            seed: config.seed,
-            error: `${reportParseError ? `invalid fuzz report payload: ${reportParseError}` : `missing fuzz report payload from ${path.basename(file)}`} (${diagnostics})`,
-            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 crashFiles = [];
-    const selectedFuzzers = fuzzerSelectors.length
-        ? filterSelectedFuzzers(report.fuzzers, fuzzerSelectors, file)
-        : report.fuzzers;
-    for (const fuzzer of selectedFuzzers) {
-        if (fuzzer.failed <= 0 && fuzzer.crashed <= 0)
-            continue;
-        const firstFailureSeed = typeof fuzzer.failures?.[0]?.seed == "number"
-            ? fuzzer.failures[0].seed
-            : config.seed;
-        const crash = persistCrashRecord(config.crashDir, {
-            kind: "fuzz",
-            file,
-            entryKey: buildFuzzFailureEntryKey(file, fuzzer.name, modeName ?? "default"),
-            mode: modeName ?? "default",
-            seed: firstFailureSeed,
-            reproCommand: buildFuzzReproCommand(file, firstFailureSeed, modeName ?? "default", fuzzer.selector, 1),
-            error: fuzzer.failure?.message ||
-                `fuzz failure in ${fuzzer.name} after ${fuzzer.runs} runs`,
-            stdout: passthrough.stdout,
-            stderr: "",
-            failure: fuzzer.failure,
-            failures: fuzzer.failures,
-        });
-        crashFiles.push(crash.jsonPath);
-        fuzzer.crashFile = crash.jsonPath;
+  });
+  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,
+      entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
+      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 (reportStream.sawChunkStart) {
+    if (reportStream.sawChunkEnd) {
+      const chunkedPayload = reportStream.chunks.join("");
+      try {
+        report = JSON.parse(chunkedPayload);
+        reportParseError = null;
+      } catch (error) {
+        reportParseError = String(error);
+      }
     }
+  }
+  if (!report?.fuzzers) {
+    const diagnostics = [
+      `chunked=${reportStream.sawChunkStart ? "yes" : "no"}`,
+      `chunkStart=${reportStream.sawChunkStart ? "yes" : "no"}`,
+      `chunkEnd=${reportStream.sawChunkEnd ? "yes" : "no"}`,
+      `chunkFrames=${reportStream.chunkFramesReceived}`,
+      `expectedChunkFrames=${reportStream.chunkCountExpected}`,
+      `chunkBytes=${reportStream.chunkBytesReceived}`,
+      `expectedChunkBytes=${reportStream.chunkTotalBytesExpected}`,
+    ].join(", ");
+    const crash = persistCrashRecord(config.crashDir, {
+      kind: "fuzz",
+      file,
+      entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
+      mode: modeName ?? "default",
+      seed: config.seed,
+      error: `${reportParseError ? `invalid fuzz report payload: ${reportParseError}` : `missing fuzz report payload from ${path.basename(file)}`} (${diagnostics})`,
+      stdout: passthrough.stdout,
+      stderr: "",
+    });
     return {
-        file,
-        target: path.basename(file),
-        modeName: modeName ?? "default",
-        runs: selectedFuzzers.reduce((sum, item) => sum + item.runs, 0),
-        crashes: selectedFuzzers.reduce((sum, item) => sum + item.crashed, 0),
-        crashFiles,
-        seed: config.seed,
-        time: Date.now() - startedAt,
-        buildTime,
-        buildStartedAt,
-        buildFinishedAt,
-        fuzzers: selectedFuzzers,
+      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 crashFiles = [];
+  const selectedFuzzers = fuzzerSelectors.length
+    ? filterSelectedFuzzers(report.fuzzers, fuzzerSelectors, file)
+    : report.fuzzers;
+  for (const fuzzer of selectedFuzzers) {
+    if (fuzzer.failed <= 0 && fuzzer.crashed <= 0) continue;
+    const firstFailureSeed =
+      typeof fuzzer.failures?.[0]?.seed == "number"
+        ? fuzzer.failures[0].seed
+        : config.seed;
+    const crash = persistCrashRecord(config.crashDir, {
+      kind: "fuzz",
+      file,
+      entryKey: buildFuzzFailureEntryKey(
+        file,
+        fuzzer.name,
+        modeName ?? "default",
+      ),
+      mode: modeName ?? "default",
+      seed: firstFailureSeed,
+      reproCommand: buildFuzzReproCommand(
+        file,
+        firstFailureSeed,
+        modeName ?? "default",
+        fuzzer.selector,
+        1,
+      ),
+      error:
+        fuzzer.failure?.message ||
+        `fuzz failure in ${fuzzer.name} after ${fuzzer.runs} runs`,
+      stdout: passthrough.stdout,
+      stderr: "",
+      failure: fuzzer.failure,
+      failures: fuzzer.failures,
+    });
+    crashFiles.push(crash.jsonPath);
+    fuzzer.crashFile = crash.jsonPath;
+  }
+  return {
+    file,
+    target: path.basename(file),
+    modeName: modeName ?? "default",
+    runs: selectedFuzzers.reduce((sum, item) => sum + item.runs, 0),
+    crashes: selectedFuzzers.reduce((sum, item) => sum + item.crashed, 0),
+    crashFiles,
+    seed: config.seed,
+    time: Date.now() - startedAt,
+    buildTime,
+    buildStartedAt,
+    buildFinishedAt,
+    fuzzers: selectedFuzzers,
+  };
 }
 function filterSelectedFuzzers(fuzzers, selectors, file) {
-    const annotated = fuzzers.map((fuzzer) => ({
-        ...fuzzer,
-        selector: slugifyFuzzerSelector(fuzzer.name),
-    }));
-    const selected = new Set();
-    for (const selector of selectors) {
-        const slug = slugifyFuzzerSelector(selector);
-        if (!slug.length)
-            continue;
-        const matches = annotated.filter((fuzzer) => fuzzer.selector == slug);
-        if (!matches.length) {
-            throw new Error(`No fuzz targets matched "${selector}" in ${path.basename(file)}.`);
-        }
-        for (const match of matches) {
-            selected.add(match.selector);
-        }
+  const annotated = fuzzers.map((fuzzer) => ({
+    ...fuzzer,
+    selector: slugifyFuzzerSelector(fuzzer.name),
+  }));
+  const selected = new Set();
+  for (const selector of selectors) {
+    const slug = slugifyFuzzerSelector(selector);
+    if (!slug.length) continue;
+    const matches = annotated.filter((fuzzer) => fuzzer.selector == slug);
+    if (!matches.length) {
+      throw new Error(
+        `No fuzz targets matched "${selector}" in ${path.basename(file)}.`,
+      );
     }
-    return annotated.filter((fuzzer) => selected.has(fuzzer.selector ?? ""));
+    for (const match of matches) {
+      selected.add(match.selector);
+    }
+  }
+  return annotated.filter((fuzzer) => selected.has(fuzzer.selector ?? ""));
 }
 function slugifyFuzzerSelector(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
 }
 function buildFuzzReproCommand(file, seed, modeName, fuzzer, runs) {
-    const modeArg = modeName != "default" ? ` --mode ${modeName}` : "";
-    const fuzzerArg = fuzzer?.length ? ` --fuzzer ${fuzzer}` : "";
-    const runsArg = typeof runs == "number" ? ` --runs ${runs}` : "";
-    return `ast fuzz ${file}${modeArg}${fuzzerArg} --seed ${seed}${runsArg}`;
+  const modeArg = modeName != "default" ? ` --mode ${modeName}` : "";
+  const fuzzerArg = fuzzer?.length ? ` --fuzzer ${fuzzer}` : "";
+  const runsArg = typeof runs == "number" ? ` --runs ${runs}` : "";
+  return `ast fuzz ${file}${modeArg}${fuzzerArg} --seed ${seed}${runsArg}`;
 }
 function buildFuzzFailureEntryKey(file, name, modeName) {
-    return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}.${sanitizeEntryName(name)}`;
+  return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}.${sanitizeEntryName(name)}`;
 }
 function buildFuzzCrashEntryKey(file, modeName) {
-    return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}`;
+  return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}`;
 }
 function sanitizeEntryName(name) {
-    return (name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "") || "fuzzer");
+  return (
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "fuzzer"
+  );
 }
 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);
+  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);
     }
-    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 = size == null ? 0 : Number(size);
-        if (max > 0 && replies.length) {
-            return dequeueReply(max);
-        }
-        if (originalRead) {
-            return originalRead(size === null ? undefined : size);
+    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 null;
-    });
-    return {
-        restore() {
-            process.stdout.write = originalWrite;
-            if (originalRead) {
-                process.stdin.read = originalRead;
-            }
-            return {
-                stdout: passthrough.toString("utf8"),
-            };
-        },
-    };
+        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 = size == null ? 0 : Number(size);
+    if (max > 0 && replies.length) {
+      return dequeueReply(max);
+    }
+    if (originalRead) {
+      return originalRead(size === null ? undefined : 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);
+  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;
     }
-    return [...patterns];
+    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}`;
+  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;
+  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, "");
+  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;
+  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);
+  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;
     }
-    return expanded;
+    expanded.push(selector);
+  }
+  return expanded;
 }
 function isBareSelector(selector) {
-    return (!selector.includes("/") &&
-        !selector.includes("\\") &&
-        !/[*?[\]{}]/.test(selector));
+  return (
+    !selector.includes("/") &&
+    !selector.includes("\\") &&
+    !/[*?[\]{}]/.test(selector)
+  );
 }