as-test 1.1.10 → 1.3.0

package/bin/commands/build-core.js

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { INTERNAL_FEATURE_NAMES, normalizeFeatureName } from "../types.js";
 import { glob } from "glob";
 import chalk from "chalk";
 import { spawn } from "child_process";
@@ -11,6 +12,8 @@ import {
   applyMode,
   getPkgRunner,
   loadConfig,
+  resolveArtifactPath,
+  resolveSpecRelativePath,
   tokenizeCommand,
   resolveProjectModule,
 } from "../util.js";
@@ -64,11 +67,8 @@ export async function build(
   const inputFiles = (await glob(inputPatterns)).sort((a, b) =>
     a.localeCompare(b),
   );
-  // Disambiguation must consider the entire configured input set, not just the
-  // selector-filtered subset, otherwise running `ast test <one-spec>` writes
-  // an artifact name the runner won't look up (it always globs full input).
-  const duplicateSpecBasenames =
-    await resolveAllConfiguredDuplicateBasenames(sourceInputPatterns);
+  await assertNoArtifactCollisions(sourceInputPatterns);
+  warnOnUnknownModeReferences(inputFiles, loadedConfig.modes ?? {});
   const coverageEnabled = resolveCoverageEnabled(
     config.coverage,
     featureToggles.coverage,
@@ -77,6 +77,7 @@ export async function build(
     ...mode.env,
     ...config.buildOptions.env,
     AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
+    AS_TEST_MODE_NAME: modeName ?? "default",
   };
   if (
     !resolvedConfig &&
@@ -85,7 +86,10 @@ export async function build(
   ) {
     const pool = getSerialBuildWorkerPool();
     for (const file of inputFiles) {
-      const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+      const outFile = path.join(
+        config.outDir,
+        resolveArtifactPath(file, sourceInputPatterns),
+      );
       const invocation = getBuildCommand(
         config,
         pkgRunner,
@@ -106,7 +110,11 @@ export async function build(
     return;
   }
   for (const file of inputFiles) {
-    const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+    const outFile = path.join(
+      config.outDir,
+      resolveArtifactPath(file, sourceInputPatterns),
+    );
+    mkdirSync(path.dirname(outFile), { recursive: true });
     const invocation = getBuildCommand(
       config,
       pkgRunner,
@@ -127,6 +135,10 @@ export async function build(
         kind,
         stage: "build",
         file,
+        entryKey: resolveSpecRelativePath(file, sourceInputPatterns).replace(
+          /\.ts$/i,
+          "",
+        ),
         mode: modeLabel,
         cwd: process.cwd(),
         buildCommand,
@@ -189,9 +201,10 @@ export async function getBuildInvocationPreview(
   }
   const sourceInputPatterns =
     overrides.kind === "fuzz" ? config.fuzz.input : config.input;
-  const duplicateSpecBasenames =
-    await resolveAllConfiguredDuplicateBasenames(sourceInputPatterns);
-  const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+  const outFile = path.join(
+    config.outDir,
+    resolveArtifactPath(file, sourceInputPatterns),
+  );
   return getBuildCommand(
     config,
     getPkgRunner(),
@@ -229,9 +242,10 @@ export async function getBuildReuseInfo(
   }
   const sourceInputPatterns =
     overrides.kind === "fuzz" ? config.fuzz.input : config.input;
-  const duplicateSpecBasenames =
-    await resolveAllConfiguredDuplicateBasenames(sourceInputPatterns);
-  const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+  const outFile = path.join(
+    config.outDir,
+    resolveArtifactPath(file, sourceInputPatterns),
+  );
   const invocation = getBuildCommand(
     config,
     getPkgRunner(),
@@ -248,6 +262,7 @@ export async function getBuildReuseInfo(
     ...mode.env,
     ...config.buildOptions.env,
     AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
+    AS_TEST_MODE_NAME: modeName ?? "default",
   };
   return {
     signature: JSON.stringify({
@@ -262,6 +277,129 @@ export async function getBuildReuseInfo(
 function hasCustomBuildCommand(config) {
   return !!config.buildOptions.cmd.trim().length;
 }
+// Scans input spec files for `mode([...], fn)` calls whose entries reference
+// mode names not present in the configured set. Collects all (file, name)
+// hits and prints a single formatted block to stdout. The implicit "default"
+// name is only valid when no configured mode has `default: true` — otherwise
+// a named mode always runs and `AS_TEST_MODE_NAME` is never literal "default".
+const MODE_CALL_RE = /\bmode\s*\(\s*\[([^\]]*)\]/g;
+const MODE_STRING_RE = /["']([^"']*)["']/g;
+const STRIP_COMMENTS_RE = /\/\*[\s\S]*?\*\/|\/\/.*$/gm;
+const reportedModeWarnings = new Set();
+const pendingModeWarningsByFile = new Map();
+// Scans input spec files for `mode([...], fn)` calls whose entries reference
+// mode names not present in the configured set, and buffers them for later
+// printing via flushModeWarnings(). Called as early as possible (before the
+// reporter starts streaming progress). De-duplicates across invocations.
+export function warnOnUnknownModeReferences(files, configuredModes) {
+  const modeEntries = Object.entries(configuredModes ?? {});
+  const fallsBackToImplicitDefault =
+    modeEntries.length === 0 ||
+    modeEntries.every(([, mode]) => mode?.default === false);
+  const knownModes = new Set(modeEntries.map(([name]) => name));
+  if (fallsBackToImplicitDefault) knownModes.add("default");
+  const knownList = [...knownModes].sort();
+  for (const file of files) {
+    let text;
+    try {
+      text = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    text = text.replace(STRIP_COMMENTS_RE, "");
+    for (const callMatch of text.matchAll(MODE_CALL_RE)) {
+      const arrayContents = callMatch[1] ?? "";
+      for (const strMatch of arrayContents.matchAll(MODE_STRING_RE)) {
+        let value = strMatch[1] ?? "";
+        if (value.length === 0) continue;
+        if (value.charCodeAt(0) === 33 /* '!' */) value = value.slice(1);
+        if (value.length === 0) continue;
+        if (knownModes.has(value)) continue;
+        const key = `${file}\x1f${value}`;
+        if (reportedModeWarnings.has(key)) continue;
+        reportedModeWarnings.add(key);
+        const warning = {
+          name: value,
+          suggestion: closestKnownMode(value, knownList),
+        };
+        const list = pendingModeWarningsByFile.get(file);
+        if (list) list.push(warning);
+        else pendingModeWarningsByFile.set(file, [warning]);
+      }
+    }
+  }
+}
+// Drains buffered mode warnings. When `showAll` is true, prints the full
+// per-warning block; otherwise prints a one-line summary that tells the user
+// to re-run with `--show-warnings`. No-op when there are no warnings.
+export function flushModeWarnings(showAll) {
+  if (pendingModeWarningsByFile.size === 0) return;
+  const hits = [];
+  for (const [file, list] of pendingModeWarningsByFile) {
+    for (const w of list) {
+      hits.push({ file, name: w.name, suggestion: w.suggestion });
+    }
+  }
+  pendingModeWarningsByFile.clear();
+  if (hits.length === 0) return;
+  if (!showAll) {
+    const count = hits.length;
+    const noun = count === 1 ? "warning" : "warnings";
+    process.stdout.write(
+      `\nFound ${chalk.yellow.bold(count)} ${noun}. Run with ${chalk.dim("--show-warnings")} to view.\n`,
+    );
+    return;
+  }
+  const lines = [chalk.yellow.bold("WARNINGS:")];
+  for (const hit of hits) {
+    let line = ` - unknown mode reference ${chalk.bold(`"${hit.name}"`)} in ${chalk.dim(hit.file)}`;
+    if (hit.suggestion) {
+      line += ` - did you mean ${chalk.cyan(`"${hit.suggestion}"`)}?`;
+    }
+    lines.push(line);
+  }
+  process.stdout.write("\n" + lines.join("\n") + "\n");
+}
+// Returns the configured mode whose Levenshtein distance to `name` is below
+// a small threshold (proportional to the longer string's length). Returns
+// null when nothing's close enough — avoids suggesting wildly different names.
+function closestKnownMode(name, candidates) {
+  let best = null;
+  let bestDist = Infinity;
+  for (const candidate of candidates) {
+    const d = levenshtein(name, candidate);
+    const threshold = Math.max(
+      2,
+      Math.floor(Math.max(name.length, candidate.length) * 0.4),
+    );
+    if (d < bestDist && d <= threshold) {
+      bestDist = d;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+      const del = prev[j] + 1;
+      const ins = curr[j - 1] + 1;
+      const sub = prev[j - 1] + cost;
+      curr[j] = Math.min(del, ins, sub);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
 function getBuildCommand(
   config,
   pkgRunner,
@@ -356,54 +494,23 @@ function expandBuildCommand(template, file, outFile, target, modeName) {
     .replace(/<target>/g, target)
     .replace(/<mode>/g, modeName ?? "");
 }
-function resolveArtifactFileName(
-  file,
-  target,
-  modeName,
-  duplicateSpecBasenames = new Set(),
-) {
-  const base = path
-    .basename(file)
-    .replace(/\.spec\.ts$/, "")
-    .replace(/\.ts$/, "");
-  const legacy = !modeName
-    ? `${path.basename(file).replace(".ts", ".wasm")}`
-    : `${base}.${modeName}.${target}.wasm`;
-  if (!duplicateSpecBasenames.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}`;
-}
-async function resolveAllConfiguredDuplicateBasenames(configured) {
+async function assertNoArtifactCollisions(configured) {
   const patterns = Array.isArray(configured) ? configured : [configured];
   const files = await glob(patterns);
-  return resolveDuplicateBasenames(files);
-}
-function resolveDuplicateBasenames(files) {
-  const counts = new Map();
+  const seen = 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);
+    const artifact = resolveArtifactPath(file, patterns);
+    const prev = seen.get(artifact);
+    if (prev != null && prev !== file) {
+      throw new Error(
+        `Two input files resolve to the same artifact path "${artifact}":\n` +
+          `  - ${prev}\n` +
+          `  - ${file}\n` +
+          `Rename one of them or narrow the input patterns to disambiguate.`,
+      );
+    }
+    seen.set(artifact, file);
   }
-  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 resolveInputPatterns(configured, selectors) {
   const configuredInputs = Array.isArray(configured)
@@ -590,7 +697,8 @@ function getBuildStdout(error) {
 }
 function getDefaultBuildArgs(config, featureToggles) {
   const buildArgs = [];
-  const tryAsEnabled = resolveTryAsEnabled(featureToggles.tryAs);
+  const effectiveFeatures = resolveEffectiveFeatures(config, featureToggles);
+  const tryAsEnabled = resolveTryAsEnabled(effectiveFeatures.has("try-as"));
   buildArgs.push("--transform", "as-test/transform");
   if (
     resolveProjectModule("json-as/transform") &&
@@ -607,6 +715,10 @@ function getDefaultBuildArgs(config, featureToggles) {
   if (tryAsEnabled) {
     buildArgs.push("--use", "AS_TEST_TRY_AS=1");
   }
+  for (const feature of effectiveFeatures) {
+    if (INTERNAL_FEATURE_NAMES.has(feature)) continue;
+    buildArgs.push("--enable", feature);
+  }
   // Should also strip any bindings-enabling from asconfig
   if (
     config.buildOptions.target == "bindings" ||
@@ -705,16 +817,29 @@ function transformsContainJsonAs(value) {
   }
   return false;
 }
-function resolveTryAsEnabled(override) {
-  const installed = hasTryAsRuntime();
-  if (override === false) return false;
-  if (override === true && !installed) {
+function resolveEffectiveFeatures(config, featureToggles) {
+  const effective = new Set();
+  for (const name of config.features) {
+    effective.add(normalizeFeatureName(name));
+  }
+  const overrides = featureToggles.featureOverrides ?? {};
+  for (const [name, enabled] of Object.entries(overrides)) {
+    const key = normalizeFeatureName(name);
+    if (!key.length) continue;
+    if (enabled) effective.add(key);
+    else effective.delete(key);
+  }
+  effective.delete("");
+  return effective;
+}
+function resolveTryAsEnabled(enabled) {
+  if (!enabled) return false;
+  if (!hasTryAsRuntime()) {
     throw new Error(
       'try-as feature was enabled, but package "try-as" is not installed',
     );
   }
-  if (override === true) return true;
-  return false;
+  return true;
 }
 function resolveCoverageEnabled(rawCoverage, override) {
   if (override != undefined) return override;

package/bin/commands/build.js

@@ -5,6 +5,8 @@ export {
   formatInvocation,
   getBuildInvocationPreview,
   getBuildReuseInfo,
+  warnOnUnknownModeReferences,
+  flushModeWarnings,
 } from "./build-core.js";
 export async function executeBuildCommand(
   rawArgs,
@@ -17,8 +19,8 @@ export async function executeBuildCommand(
   const featureToggles = deps.resolveFeatureToggles(rawArgs, "build");
   const parallel = deps.resolveBuildParallelJobs(rawArgs);
   const buildFeatureToggles = {
-    tryAs: featureToggles.tryAs,
     coverage: featureToggles.coverage,
+    featureOverrides: featureToggles.featureOverrides,
   };
   const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
   if (listFlags.list || listFlags.listModes) {

package/bin/commands/fuzz-core.js

@@ -3,7 +3,12 @@ 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 {
+  applyMode,
+  loadConfig,
+  resolveArtifactPath,
+  resolveSpecRelativePath,
+} 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");
@@ -29,13 +34,6 @@ export async function fuzz(
       `No fuzz files matched: ${selectors.length ? selectors.join(", ") : "configured input patterns"}`,
     );
   }
-  // Disambiguation must consider the full configured fuzz input set, not the
-  // selector-filtered subset, so artifact names stay consistent across runs.
-  const fullPatterns = Array.isArray(config.input)
-    ? config.input
-    : [config.input];
-  const allFuzzFiles = await glob(fullPatterns);
-  const duplicateBasenames = resolveDuplicateBasenames(allFuzzFiles);
   const results = [];
   for (const file of inputFiles) {
     const buildStartedAt = Date.now();
@@ -53,7 +51,6 @@ export async function fuzz(
       await runFuzzTarget(
         file,
         activeConfig.outDir,
-        duplicateBasenames,
         config,
         fuzzerSelectors,
         buildStartedAt,
@@ -111,7 +108,6 @@ function encodeRunsOverrideKind(kind) {
 async function runFuzzTarget(
   file,
   outDir,
-  duplicateBasenames,
   config,
   fuzzerSelectors,
   buildStartedAt,
@@ -120,7 +116,7 @@ async function runFuzzTarget(
   modeName,
 ) {
   const startedAt = Date.now();
-  const artifact = resolveArtifactFileName(file, duplicateBasenames, modeName);
+  const artifact = resolveArtifactPath(file, config.input);
   const wasmPath = path.resolve(process.cwd(), outDir, artifact);
   const jsPath = resolveBindingsHelperPath(wasmPath);
   const helper = await import(pathToFileURL(jsPath).href + `?t=${Date.now()}`);
@@ -185,7 +181,11 @@ async function runFuzzTarget(
     const crash = persistCrashRecord(config.crashDir, {
       kind: "fuzz",
       file,
-      entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
+      entryKey: buildFuzzCrashEntryKey(
+        file,
+        config.input,
+        modeName ?? "default",
+      ),
       mode: modeName ?? "default",
       seed: config.seed,
       error: crashMessage,
@@ -232,7 +232,11 @@ async function runFuzzTarget(
     const crash = persistCrashRecord(config.crashDir, {
       kind: "fuzz",
       file,
-      entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
+      entryKey: buildFuzzCrashEntryKey(
+        file,
+        config.input,
+        modeName ?? "default",
+      ),
       mode: modeName ?? "default",
       seed: config.seed,
       error: `${reportParseError ? `invalid fuzz report payload: ${reportParseError}` : `missing fuzz report payload from ${path.basename(file)}`} (${diagnostics})`,
@@ -269,6 +273,7 @@ async function runFuzzTarget(
       file,
       entryKey: buildFuzzFailureEntryKey(
         file,
+        config.input,
         fuzzer.name,
         modeName ?? "default",
       ),
@@ -341,11 +346,19 @@ function buildFuzzReproCommand(file, seed, modeName, fuzzer, runs) {
   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)}`;
+function buildFuzzFailureEntryKey(file, inputPatterns, name, modeName) {
+  const stem = resolveSpecRelativePath(file, inputPatterns).replace(
+    /\.ts$/i,
+    "",
+  );
+  return `${stem}.${sanitizeEntryName(modeName)}.${sanitizeEntryName(name)}`;
 }
-function buildFuzzCrashEntryKey(file, modeName) {
-  return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}`;
+function buildFuzzCrashEntryKey(file, inputPatterns, modeName) {
+  const stem = resolveSpecRelativePath(file, inputPatterns).replace(
+    /\.ts$/i,
+    "",
+  );
+  return `${stem}.${sanitizeEntryName(modeName)}`;
 }
 function sanitizeEntryName(name) {
   return (
@@ -458,45 +471,6 @@ function resolveFuzzInputPatterns(configured, selectors) {
   }
   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;