as-test 1.5.0 → 1.5.2

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Change Log
 
+## 2026-06-01 - v1.5.2
+
+### Selectors resolve folders, files, and globs consistently
+
+- feat: positional selectors for `ast test`/`ast run`/`ast build` now resolve through a single shared resolver (`cli/selectors.ts:resolveSpecFiles`), replacing three drifting private copies of `resolveInputPatterns` (in `build-core`, `run-core`, and `index`). Three input shapes are supported:
+  - **Bare folders/files/globs** (no leading `./`) resolve against the configured input root(s) — the static prefix of each `input` glob, e.g. `assembly/__tests__` — searched recursively, and fall back to the cwd only if nothing matched there: `ast test rfc/` → `<root>/**/rfc/**/*.spec.ts`; `ast test foo` → `<root>/**/foo.spec.ts`; `ast test 'rfc/*.spec.ts'` → `<root>/**/rfc/*.spec.ts` (the user's glob appended verbatim). A bare path shorthand like `nested/array` is tried as a cwd path first, then anchored to the test folder.
+  - **`./`-prefixed** selectors (and absolute / `~` paths) are cwd-relative only; on a miss we emit a `did you mean "rfc/*.spec.ts"` hint pointing at the test-folder form when that would have matched.
+- feat: a bare selector that matches under more than one configured input root is flagged with a `WARN` (it still runs everything that matched), and a selector that matches nothing emits a `WARN` naming where it looked. Warnings are deduped by text across the orchestrator + per-file build/run passes (`emitSelectorWarnings`), so each prints once per invocation. Folder selectors (`rfc/`) and `,`-joined bare names (`a,b`) are recognized; selectors with an internal path separator (e.g. the orchestrator's own `assembly/__tests__/foo.spec.ts`) are still treated as direct cwd paths, preserving existing per-file dispatch.
+
+## 2026-05-30 - v1.5.1
+
+### An early-exiting runtime now fails instead of warning
+
+- fix: when the runtime never delivers its final report payload, the CLI reconstructs a result from the streamed lifecycle events (`synthesizeReportFromRuntimeEvents`). Previously this always emitted a `WARN` and returned the reconstruction, only escalating to a `FAIL` if the child exited non-zero or wrote to stderr — so a spec that trapped/exited early with exit code `0` and no stderr came back as a passing reconstruction (the `runtime report payload missing; reconstructed result from streamed lifecycle events` warning storm). Both `runProcess` (WASI/bindings) and `runWebSessionProcess` (web) now treat `!runtimeEvents.sawFileEnd` — the runtime never emitted `event:file-end`, i.e. it exited before the file finished — as a failure: `appendRuntimeFailureReport` with a persisted crash record and a `test runtime exited before completing the test file` message, no misleading `WARN`. A run that _did_ reach `file-end` but simply failed to flush the final report frame is still the recoverable case (`WARN` + reconstructed result). This also closes a gap in the web path, which previously never escalated to a failure in the synthesized branch — it only warned, even on a non-zero exit.
+
+### esm bindings now run
+
+- fix: `instantiateEsmInstance` (`lib/src/index.ts`) now calls `patchNodeIo()` before importing the bindings helper. An esm helper auto-instantiates at import time and writes the WIPC report by calling the global `process.stdout.write(ArrayBuffer)` directly. `patchNodeIo()` — which teaches `process.stdout.write`/`process.stdin.read` to accept a raw `ArrayBuffer` and route it through `fs.writeSync` — was only wired into the raw path (via `withNodeIo`), never the esm path. So under esm bindings Node threw `ERR_INVALID_ARG_TYPE` ("chunk must be of type string or Buffer…, received an instance of ArrayBuffer") before any report was emitted, and the run crashed with `missing report payload from test runtime`. The patch is now in place by the time the helper instantiates.
+
+### `--bindings` is respected instead of overridden
+
+- feat: as-test no longer forces `--bindings raw` when you've already declared bindings yourself. `getDefaultBuildArgs` (`cli/commands/build-core.ts`) now takes a `bindingsAlreadyConfigured` flag and only appends `--bindings raw` when neither `buildOptions.args` nor a referenced asconfig declares `--bindings`. The other bindings flags (`AS_TEST_BINDINGS=1`, `--exportRuntime`, `--exportStart _start`) are still always injected. Two new detectors back this: `argsDeclareBindings(args)` (scans for `--bindings`/`--bindings=`) and `asconfigDeclaresBindings(configPath)` (reads `options.bindings`, follows `extends`), mirroring the existing try-as detection. Previously `--bindings esm` in `buildOptions.args` was combined with the forced `--bindings raw`, so `asc` emitted glue for **both** styles into one file; the runtime then mis-detected the kind and crashed. With this, `--bindings esm` produces esm-only glue and runs.
+
+### Mocking works on every runtime
+
+- change: `mock.spec.ts` is split into `mock.spec.ts` (mocking + `unmockFn` only) and `unmock.spec.ts` (the `unmockImport` cases). The split tracks the real esm/standalone-WASI boundary: the transform removes a `@external` import from the wasm when it is **only ever mocked**, but keeps it (for fall-back) when it is `unmockImport`'d anywhere. A pure-mock spec therefore imports nothing virtual and runs on **every** runtime — verified via `WebAssembly.Module.imports()`: the pure-mock wasi build imports only `wasi_snapshot_preview1`, while the unmock build imports `mock.foo`. `unmockFn` (function mocks) does not retain an import; only `unmockImport` does.
+- feat: pure `mockImport` specs now run under **esm bindings** and the standalone WASI runtimes (`wasmtime`, `wasmer`, `wazero`) — `mock.spec.ts` is no longer excluded from those modes (it was in v1.5.0). Only `unmock.spec.ts`, which retains a real host binding the host can't supply under those runtimes, is excluded (`!**/unmock.spec.ts`).
+- feat: two new modes in `as-test.config.json` — `node:bindings:raw` and `node:bindings:esm` (both `default: false`) — exercise each bindings style explicitly, and both are added to the `test:modes` matrix so `test:all` covers them.
+
+### Watch mode exits with the last verdict
+
+- feat: quitting `--watch` (ctrl+c, both the raw-mode `0x03` path and the `SIGINT` handler in `runWatchLoop`) now exits `1` when the most recent run left any spec failing **or a run is still in flight**, instead of always exiting `0`. The watch loop already tracks currently-failing `(spec, mode)` pairs in its sticky `failingSpecs` map and an `isRunning` flag, so the exit code is `isRunning || failingSpecs.size ? 1 : 0` — an interrupted run counts as a failure. This lets a red watch session fail CI and shell pipelines (`ast test --watch && deploy`) instead of masking the failure on quit.
+
+### CI uses the main config
+
+- chore: removed `as-test.ci.config.json`. `test:ci` now runs against the main `as-test.config.json` (`npm run test -- --mode node:bindings,node:wasi,wasmtime`), so CI uses the same modes, `features` (`try-as`), and per-mode spec exclusions as everything else — `try-as` no longer needs an explicit `--enable`, and the stale CI-only `wasmtime` exclusion that still ran `unmock.spec.ts` (and failed on the missing `mock::foo` host import) is gone.
+
 ## 2026-05-28 - v1.5.0
 
 ### `mockFn` and `mockImport` now work anywhere

package/bin/commands/build-core.js

@@ -22,6 +22,7 @@ import {
 } from "../util.js";
 import { persistCrashRecord } from "../crash-store.js";
 import { BuildWorkerPool } from "../build-worker-pool.js";
+import { resolveSpecFiles, emitSelectorWarnings } from "../selectors.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 export const buildRecorderStorage = new AsyncLocalStorage();
 export class BuildFailureError extends Error {
@@ -67,14 +68,9 @@ export async function build(
   const pkgRunner = getPkgRunner();
   const sourceInputPatterns =
     overrides.kind === "fuzz" ? config.fuzz.input : config.input;
-  const inputPatterns = resolveInputPatterns(sourceInputPatterns, selectors);
-  const includePatterns = inputPatterns.filter((p) => !p.startsWith("!"));
-  const ignorePatterns = inputPatterns
-    .filter((p) => p.startsWith("!"))
-    .map((p) => p.slice(1));
-  const inputFiles = (
-    await glob(includePatterns, { ignore: ignorePatterns })
-  ).sort((a, b) => a.localeCompare(b));
+  const { files: inputFiles, warnings: selectorWarnings } =
+    await resolveSpecFiles(sourceInputPatterns, selectors);
+  emitSelectorWarnings(selectorWarnings);
   await assertNoArtifactCollisions(sourceInputPatterns);
   warnOnUnknownModeReferences(inputFiles, loadedConfig.modes ?? {});
   const coverageEnabled = resolveCoverageEnabled(
@@ -438,10 +434,13 @@ function getBuildCommand(
   }
   const tryAsAlreadyConfigured =
     argsDeclareTryAs(userArgs) || asconfigDeclaresTryAs(config.config);
+  const bindingsAlreadyConfigured =
+    argsDeclareBindings(userArgs) || asconfigDeclaresBindings(config.config);
   const defaultArgs = getDefaultBuildArgs(
     config,
     featureToggles,
     tryAsAlreadyConfigured,
+    bindingsAlreadyConfigured,
   );
   const ascInvocation = resolveAscInvocation(pkgRunner);
   // as-test's own transform goes first so CoverageTransform sees the
@@ -537,61 +536,6 @@ async function assertNoArtifactCollisions(configured) {
     seen.set(artifact, file);
   }
 }
-function resolveInputPatterns(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 = stripSuiteSuffix(selector);
-      for (const configuredInput of configuredInputs) {
-        patterns.add(
-          path.join(path.dirname(configuredInput), `${base}.spec.ts`),
-        );
-      }
-      continue;
-    }
-    patterns.add(selector);
-  }
-  return [...patterns];
-}
-function expandSelectors(selectors) {
-  const expanded = [];
-  for (const selector of selectors) {
-    if (!selector) continue;
-    if (!shouldSplitSelector(selector)) {
-      expanded.push(selector);
-      continue;
-    }
-    for (const token of selector.split(",")) {
-      const trimmed = token.trim();
-      if (!trimmed.length) continue;
-      expanded.push(trimmed);
-    }
-  }
-  return expanded;
-}
-function shouldSplitSelector(selector) {
-  return (
-    selector.includes(",") &&
-    !selector.includes("/") &&
-    !selector.includes("\\") &&
-    !/[*?[\]{}]/.test(selector)
-  );
-}
-function isBareSuiteSelector(selector) {
-  return (
-    !selector.includes("/") &&
-    !selector.includes("\\") &&
-    !/[*?[\]{}]/.test(selector)
-  );
-}
-function stripSuiteSuffix(selector) {
-  return selector.replace(/\.spec\.ts$/, "").replace(/\.ts$/, "");
-}
 function ensureDeps(config) {
   if (config.buildOptions.target == "wasi") {
     if (!resolveWasiShim()) {
@@ -769,6 +713,7 @@ function getDefaultBuildArgs(
   config,
   featureToggles,
   tryAsAlreadyConfigured = false,
+  bindingsAlreadyConfigured = false,
 ) {
   const buildArgs = [];
   const effectiveFeatures = resolveEffectiveFeatures(config, featureToggles);
@@ -795,7 +740,6 @@ function getDefaultBuildArgs(
     if (INTERNAL_FEATURE_NAMES.has(feature)) continue;
     buildArgs.push("--enable", feature);
   }
-  // Should also strip any bindings-enabling from asconfig
   if (
     config.buildOptions.target == "bindings" ||
     config.buildOptions.target == "web"
@@ -803,12 +747,18 @@ function getDefaultBuildArgs(
     buildArgs.push(
       "--use",
       "AS_TEST_BINDINGS=1",
-      "--bindings",
-      "raw",
       "--exportRuntime",
       "--exportStart",
       "_start",
     );
+    // `raw` bindings are the default the runtime host knows how to drive.
+    // If the user already declared `--bindings` (via buildOptions.args or
+    // an asconfig), respect their choice — the runtime supports both `raw`
+    // and `esm` — and don't force `raw` on top of it (asc would otherwise
+    // emit glue for both styles, confusing kind detection).
+    if (!bindingsAlreadyConfigured) {
+      buildArgs.push("--bindings", "raw");
+    }
   } else if (config.buildOptions.target == "wasi") {
     const wasiShim = resolveWasiShim();
     if (!wasiShim) {
@@ -879,6 +829,49 @@ function argsDeclareTryAs(args) {
   }
   return false;
 }
+function argsDeclareBindings(args) {
+  for (const arg of args) {
+    if (arg === "--bindings" || arg.startsWith("--bindings=")) return true;
+  }
+  return false;
+}
+function asconfigDeclaresBindings(configPath, seen = new Set()) {
+  if (!configPath || configPath === "none") return false;
+  const resolved = path.isAbsolute(configPath)
+    ? configPath
+    : path.resolve(process.cwd(), configPath);
+  if (seen.has(resolved)) return false;
+  seen.add(resolved);
+  if (!existsSync(resolved)) return false;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(resolved, "utf8"));
+  } catch {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object") return false;
+  const obj = parsed;
+  const options = obj.options;
+  if (options && typeof options === "object") {
+    const bindings = options.bindings;
+    if (typeof bindings === "string" && bindings.length) return true;
+    if (Array.isArray(bindings) && bindings.length) return true;
+  }
+  const extendsField = obj.extends;
+  const extendsList = Array.isArray(extendsField)
+    ? extendsField
+    : typeof extendsField === "string"
+      ? [extendsField]
+      : [];
+  for (const ext of extendsList) {
+    if (typeof ext !== "string") continue;
+    const extPath = path.isAbsolute(ext)
+      ? ext
+      : path.resolve(path.dirname(resolved), ext);
+    if (asconfigDeclaresBindings(extPath, seen)) return true;
+  }
+  return false;
+}
 function asconfigDeclaresTryAs(configPath, seen = new Set()) {
   if (!configPath || configPath === "none") return false;
   const resolved = path.isAbsolute(configPath)

package/bin/commands/init-core.js

@@ -3,9 +3,169 @@ import { spawnSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import * as path from "path";
 import { createInterface } from "readline";
-import { getCliVersion } from "../util.js";
+import { getCliVersion, getExec } from "../util.js";
 import { buildWebRunnerSource } from "./web-runner-source.js";
 const TARGETS = ["wasi", "bindings", "web"];
+// Popular runtimes offered by the interactive picker. Availability is probed
+// against the machine/project (PATH for native binaries, node_modules for
+// Playwright) so unavailable entries can be dimmed rather than hidden.
+const RUNTIMES = [
+  {
+    value: "node:wasi",
+    label: "Node.js",
+    target: "wasi",
+    cmd: "node .as-test/runners/default.wasi.js",
+    browser: "",
+  },
+  {
+    value: "node:bindings",
+    label: "Node.js",
+    target: "bindings",
+    cmd: "node .as-test/runners/default.bindings.js",
+    browser: "",
+  },
+  {
+    value: "wasmtime",
+    label: "Wasmtime",
+    target: "wasi",
+    cmd: "wasmtime run <file>",
+    browser: "",
+    bin: "wasmtime",
+  },
+  {
+    value: "wasmer",
+    label: "Wasmer",
+    target: "wasi",
+    cmd: "wasmer run <file>",
+    browser: "",
+    bin: "wasmer",
+  },
+  {
+    value: "wazero",
+    label: "wazero",
+    target: "wasi",
+    cmd: "wazero run <file>",
+    browser: "",
+    bin: "wazero",
+  },
+  {
+    value: "chromium",
+    label: "Chromium",
+    target: "web",
+    cmd: "node .as-test/runners/default.web.js",
+    browser: "chromium",
+    needsPlaywright: true,
+  },
+  {
+    value: "firefox",
+    label: "Firefox",
+    target: "web",
+    cmd: "node .as-test/runners/default.web.js",
+    browser: "firefox",
+    needsPlaywright: true,
+  },
+  {
+    value: "webkit",
+    label: "WebKit",
+    target: "web",
+    cmd: "node .as-test/runners/default.web.js",
+    browser: "webkit",
+    needsPlaywright: true,
+  },
+];
+// Probe whether a runtime is usable on this machine/project. Node-based
+// runtimes are always available (we are running under Node); native binaries
+// must resolve on PATH; browser runtimes require Playwright to be installed.
+function probeRuntime(runtime, root) {
+  if (runtime.bin) {
+    if (getExec(runtime.bin)) return { available: true };
+    return { available: false, hint: `${runtime.bin} not on PATH` };
+  }
+  if (runtime.needsPlaywright) {
+    const pkg = path.join(root, "node_modules", "playwright", "package.json");
+    if (existsSync(pkg)) return { available: true };
+    return { available: false, hint: "playwright not installed" };
+  }
+  return { available: true };
+}
+// The default runtime command for a build target, matching the long-standing
+// `--target`/`--yes` behaviour (plain Node runner, no browser).
+function runtimeForTarget(target) {
+  const cmd =
+    target == "wasi"
+      ? "node .as-test/runners/default.wasi.js"
+      : target == "bindings"
+        ? "node .as-test/runners/default.bindings.js"
+        : "node .as-test/runners/default.web.js";
+  return { cmd, browser: "" };
+}
+function defaultRuntimeLabel(target) {
+  if (target == "wasi") return "node:wasi";
+  if (target == "bindings") return "node:bindings";
+  return "web";
+}
+// Ensure a mode key is unique against names already in use, suffixing -2, -3…
+function uniqueModeName(name, taken) {
+  if (!taken.includes(name)) return name;
+  for (let i = 2; ; i++) {
+    const candidate = `${name}-${i}`;
+    if (!taken.includes(candidate)) return candidate;
+  }
+}
+// Prompt for a user-defined runtime: a command (with optional <file>
+// placeholder), a mode name, and — for the web target — an optional browser.
+// Returns null if no command is entered or interactive input is unavailable.
+async function askCustomRuntime(target, face, taken) {
+  if (!face) return null;
+  const cmd = (
+    await ask(
+      `${chalk.bold.blue("◇  Custom runtime command")}\n` +
+        `${chalk.dim("│  <file> is replaced with the generated .wasm — e.g. wasmtime <file>")}\n│  `,
+      face,
+      "",
+    )
+  ).trim();
+  if (!cmd.length) return null;
+  const rawName = (
+    await ask(
+      `${chalk.bold.blue("◇  Name for this runtime (used as the mode key, default: custom)")}\n│  `,
+      face,
+      "",
+    )
+  ).trim();
+  const name = uniqueModeName(rawName.length ? rawName : "custom", taken);
+  let browser = "";
+  if (target == "web") {
+    browser = (
+      await ask(
+        `${chalk.bold.blue("◇  Browser (optional: chromium / firefox / webkit)")}\n│  `,
+        face,
+        "",
+      )
+    ).trim();
+  }
+  printSelectionLine(`${name}: ${cmd}${browser ? ` (${browser})` : ""}`);
+  return { value: name, target, cmd, browser };
+}
+// Turn the selected runtimes into config `modes` — one named mode per runtime,
+// each carrying its build target and runtime command. Every mode runs by
+// default (the absent `default` flag defaults to true), so `ast test` executes
+// them all.
+function buildRuntimeModes(selected) {
+  const modes = {};
+  for (const rt of selected) {
+    modes[rt.value] = {
+      buildOptions: { target: rt.target },
+      runOptions: {
+        runtime: {
+          cmd: rt.cmd,
+          ...(rt.browser ? { browser: rt.browser } : {}),
+        },
+      },
+    };
+  }
+  return modes;
+}
 const EXAMPLE_MODES = ["minimal", "full", "none"];
 const FEATURE_KEYS = ["coverage", "tryAs"];
 const FEATURE_LABELS = {
@@ -27,6 +187,9 @@ export async function init(rawArgs) {
       ? {
           root: path.resolve(process.cwd(), options.dir),
           target: options.target ?? "wasi",
+          runtime: runtimeForTarget(options.target ?? "wasi"),
+          modes: {},
+          runtimeLabel: defaultRuntimeLabel(options.target ?? "wasi"),
           example: options.example ?? "minimal",
           fuzzExample: options.fuzzExample ?? false,
           features: resolveFeatures(options.features, {
@@ -43,6 +206,8 @@ export async function init(rawArgs) {
     printPlan(
       answers.root,
       answers.target,
+      answers.runtimeLabel,
+      Object.keys(answers.modes),
       answers.example,
       answers.fuzzExample,
       answers.features,
@@ -58,6 +223,8 @@ export async function init(rawArgs) {
     const summary = applyInit(
       answers.root,
       answers.target,
+      answers.runtime,
+      answers.modes,
       answers.example,
       answers.fuzzExample,
       answers.features,
@@ -265,6 +432,8 @@ async function runInteractiveOnboarding(options, face) {
   } else {
     printSelectionLine(resolvedRoot);
   }
+  // Step 1: pick the build target (mode). The runtime list is then filtered to
+  // the runtimes that support this target.
   const target =
     options.target ??
     (onboardingMode == "quick"
@@ -272,21 +441,9 @@ async function runInteractiveOnboarding(options, face) {
       : await askMenuChoice(
           "Build target",
           [
-            {
-              value: "wasi",
-              label:
-                "wasi (default runner: node .as-test/runners/default.wasi.js)",
-            },
-            {
-              value: "bindings",
-              label:
-                "bindings (default runner: node .as-test/runners/default.bindings.js)",
-            },
-            {
-              value: "web",
-              label:
-                "web (default runner: node .as-test/runners/default.web.js)",
-            },
+            { value: "wasi", label: "wasi (WebAssembly System Interface)" },
+            { value: "bindings", label: "bindings (Node.js host bindings)" },
+            { value: "web", label: "web (browser via Playwright)" },
           ],
           face,
           "wasi",
@@ -294,6 +451,72 @@ async function runInteractiveOnboarding(options, face) {
   if (options.target || onboardingMode == "quick") {
     printPromptAndSelectionLine("Build target", target);
   }
+  // Step 2: pick one or more runtimes, scoped to the chosen target. Unavailable
+  // runtimes (native binary missing from PATH, or Playwright not installed) are
+  // dimmed; "Custom…" lets the user define their own. Each chosen runtime
+  // becomes a config mode so `ast test` runs the whole matrix.
+  let runtime;
+  let runtimeLabel;
+  let modes = {};
+  const targetRuntimes = RUNTIMES.filter((rt) => rt.target == target);
+  if (options.target || onboardingMode == "quick") {
+    // Flag/quick runs are non-interactive: keep the historical Node default.
+    runtime = runtimeForTarget(target);
+    runtimeLabel = defaultRuntimeLabel(target);
+    printPromptAndSelectionLine("Runtime", runtimeLabel);
+  } else {
+    const toggleChoices = targetRuntimes.map((rt) => {
+      const status = probeRuntime(rt, resolvedRoot);
+      return {
+        value: rt.value,
+        label: rt.label,
+        disabled: !status.available,
+        hint: status.hint,
+      };
+    });
+    toggleChoices.push({
+      value: "custom",
+      label: "Custom…",
+      alwaysSelectable: true,
+    });
+    // Pre-select the first available built-in runtime so confirming immediately
+    // yields a sensible single choice.
+    const firstAvailable =
+      targetRuntimes.find((rt) => probeRuntime(rt, resolvedRoot).available)
+        ?.value ?? targetRuntimes[0].value;
+    const initial = {};
+    for (const choice of toggleChoices) {
+      initial[choice.value] = choice.value == firstAvailable;
+    }
+    const result = await askMultiToggle(
+      "Runtimes (↑/↓ move, space toggle, enter confirm — dimmed = not detected)",
+      toggleChoices,
+      face,
+      initial,
+    );
+    const selected = targetRuntimes.filter((rt) => result[rt.value]);
+    if (result["custom"]) {
+      const custom = await askCustomRuntime(
+        target,
+        face,
+        selected.map((rt) => rt.value),
+      );
+      if (custom) selected.push(custom);
+    }
+    if (!selected.length) {
+      // Confirming with nothing selected falls back to the default runtime.
+      const fallback =
+        targetRuntimes.find((rt) => rt.value == firstAvailable) ??
+        targetRuntimes[0];
+      selected.push(fallback);
+    }
+    const primary = selected[0];
+    runtime = { cmd: primary.cmd, browser: primary.browser };
+    runtimeLabel = selected.map((rt) => rt.value).join(", ");
+    // The picker is authoritative: write a mode per chosen runtime so the
+    // exact selection (single, matrix, or custom) is what `ast test` runs.
+    modes = buildRuntimeModes(selected);
+  }
   const featureDefaults = { coverage: false, tryAs: false };
   const explicitFeatures =
     options.features.coverage !== undefined ||
@@ -355,6 +578,9 @@ async function runInteractiveOnboarding(options, face) {
   return {
     root: resolvedRoot,
     target,
+    runtime,
+    modes,
+    runtimeLabel,
     example,
     fuzzExample,
     features,
@@ -464,7 +690,16 @@ function isTarget(value) {
 function isExampleMode(value) {
   return EXAMPLE_MODES.includes(value);
 }
-function printPlan(root, target, example, fuzzExample, features, install) {
+function printPlan(
+  root,
+  target,
+  runtimeLabel,
+  modeNames,
+  example,
+  fuzzExample,
+  features,
+  install,
+) {
   const displayRoot = () => {
     const rel = path.relative(process.cwd(), root).split(path.sep).join("/");
     if (!rel || rel == ".") return "./";
@@ -568,6 +803,15 @@ function printPlan(root, target, example, fuzzExample, features, install) {
   const treeRoot = buildTree(fileEntries);
   console.log(chalk.bold.blue("◇  Planned Changes"));
   console.log("│" + chalk.dim(`  - Target: ${target}`));
+  console.log(
+    "│" +
+      chalk.dim(
+        `  - Runtime${runtimeLabel.includes(",") ? "s" : ""}: ${runtimeLabel}`,
+      ),
+  );
+  if (modeNames.length) {
+    console.log("│" + chalk.dim(`  - Modes: ${modeNames.join(", ")}`));
+  }
   console.log("│" + chalk.dim(`  - Example: ${example}`));
   console.log(
     "│" + chalk.dim(`  - Fuzzer example: ${fuzzExample ? "yes" : "no"}`),
@@ -586,7 +830,16 @@ function printPlan(root, target, example, fuzzExample, features, install) {
   }
   console.log("│");
 }
-function applyInit(root, target, example, fuzzExample, features, force) {
+function applyInit(
+  root,
+  target,
+  runtime,
+  modes,
+  example,
+  fuzzExample,
+  features,
+  force,
+) {
   const summary = {
     created: [],
     updated: [],
@@ -637,17 +890,17 @@ function applyInit(root, target, example, fuzzExample, features, force) {
     },
     runOptions: {
       runtime: {
-        cmd:
-          target == "wasi"
-            ? "node .as-test/runners/default.wasi.js"
-            : target == "bindings"
-              ? "node .as-test/runners/default.bindings.js"
-              : "node .as-test/runners/default.web.js",
+        cmd: runtime.cmd,
+        ...(runtime.browser ? { browser: runtime.browser } : {}),
       },
       reporter: "default",
     },
-    modes:
-      target == "web"
+    // The interactive picker supplies one mode per selected runtime. The
+    // non-interactive paths (--yes/--target/quick) leave `modes` empty, so the
+    // historical web convenience modes are scaffolded for the web target.
+    modes: Object.keys(modes).length
+      ? modes
+      : target == "web"
         ? {
             web: {
               default: false,
@@ -899,12 +1152,14 @@ async function askChoice(label, choices, face, fallback) {
   throw new Error(`Invalid choice "${answer}" for ${label}`);
 }
 async function askMenuChoice(label, choices, face, fallback) {
-  const fallbackValue = choices.some((choice) => choice.value == fallback)
+  const enabled = choices.filter((choice) => !choice.disabled);
+  const pool = enabled.length ? enabled : choices;
+  const fallbackValue = pool.some((choice) => choice.value == fallback)
     ? fallback
-    : choices[0].value;
+    : pool[0].value;
   if (!face) return fallbackValue;
   if (!canUseArrowMenu(face)) {
-    const values = choices.map((choice) => choice.value);
+    const values = pool.map((choice) => choice.value);
     return askChoice(label, values, face, fallbackValue);
   }
   return askMenuChoiceWithArrows(label, choices, face, fallbackValue);
@@ -915,7 +1170,16 @@ async function askMultiToggle(label, choices, face, initial) {
     return askMultiToggleWithArrows(label, choices, face, initial);
   }
   const result = { ...initial };
+  const anySelectable = choices.some(
+    (choice) => !choice.disabled && !choice.alwaysSelectable,
+  );
   for (const choice of choices) {
+    const selectable =
+      Boolean(choice.alwaysSelectable) || !anySelectable || !choice.disabled;
+    if (!selectable) {
+      result[choice.value] = false;
+      continue;
+    }
     result[choice.value] = await askYesNo(
       `${label} — enable ${choice.label}?`,
       face,
@@ -961,8 +1225,32 @@ function canUseArrowMenu(face) {
 async function askMenuChoiceWithArrows(label, choices, face, fallback) {
   const stdin = process.stdin;
   const stdout = process.stdout;
-  const fallbackIndex = choices.findIndex((choice) => choice.value == fallback);
-  let selectedIndex = fallbackIndex == -1 ? 0 : fallbackIndex;
+  // When nothing is selectable (e.g. every runtime for a target is dimmed
+  // because its tooling isn't installed yet), fall back to letting the user
+  // pick anyway — the dimming stays as an informational warning.
+  const anySelectable = choices.some((choice) => !choice.disabled);
+  const isSelectable = (index) => !anySelectable || !choices[index].disabled;
+  const firstSelectable = choices.findIndex((_, i) => isSelectable(i));
+  const fallbackIndex = choices.findIndex(
+    (choice) => choice.value == fallback && !choice.disabled,
+  );
+  let selectedIndex =
+    fallbackIndex != -1
+      ? fallbackIndex
+      : firstSelectable != -1
+        ? firstSelectable
+        : 0;
+  // Step from `selectedIndex` in `step` direction (wrapping) to the next
+  // selectable option, ignoring disabled entries. Returns the current index
+  // unchanged if nothing else is selectable.
+  const stepSelection = (step) => {
+    for (let i = 1; i <= choices.length; i++) {
+      const candidate =
+        (selectedIndex + step * i + choices.length * i) % choices.length;
+      if (isSelectable(candidate)) return candidate;
+    }
+    return selectedIndex;
+  };
   let renderedLineCount = 0;
   const previousRawMode = Boolean(stdin.isRaw);
   const lineWidth = Math.max(20, (stdout.columns ?? 80) - 2);
@@ -977,6 +1265,15 @@ async function askMenuChoiceWithArrows(label, choices, face, fallback) {
     const lines = [titleLine()];
     for (let i = 0; i < choices.length; i++) {
       const choice = choices[i];
+      if (choice.disabled) {
+        const text = choice.hint
+          ? `${choice.label} (${choice.hint})`
+          : choice.label;
+        lines.push(
+          `│  ${chalk.dim("✕")} ${chalk.dim(clamp(text, Math.max(8, lineWidth - 6)))}`,
+        );
+        continue;
+      }
       const marker = i == selectedIndex ? chalk.blue("●") : chalk.dim("○");
       lines.push(
         `│  ${marker} ${clamp(choice.label, Math.max(8, lineWidth - 6))}`,
@@ -1069,7 +1366,7 @@ async function askMenuChoiceWithArrows(label, choices, face, fallback) {
         input == "\x1b[D" ||
         input == "\x1bOD"
       ) {
-        selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
+        selectedIndex = stepSelection(-1);
         writeLines(menuLines());
         return;
       }
@@ -1079,11 +1376,12 @@ async function askMenuChoiceWithArrows(label, choices, face, fallback) {
         input == "\x1b[C" ||
         input == "\x1bOC"
       ) {
-        selectedIndex = (selectedIndex + 1) % choices.length;
+        selectedIndex = stepSelection(1);
         writeLines(menuLines());
         return;
       }
       if (input == "\r" || input == "\n") {
+        if (!isSelectable(selectedIndex)) return;
         finish(choices[selectedIndex].value);
         return;
       }
@@ -1101,7 +1399,29 @@ async function askMultiToggleWithArrows(label, choices, face, initial) {
   const stdin = process.stdin;
   const stdout = process.stdout;
   const selected = { ...initial };
-  let cursorIndex = 0;
+  // When no "real" option is selectable (e.g. every browser is dimmed because
+  // Playwright isn't installed yet — which init can fix), allow toggling the
+  // dimmed entries anyway; the dimming stays as an informational warning. The
+  // always-selectable Custom… entry is excluded from this decision.
+  const anySelectable = choices.some(
+    (choice) => !choice.disabled && !choice.alwaysSelectable,
+  );
+  const isSelectable = (index) => {
+    const choice = choices[index];
+    return (
+      Boolean(choice.alwaysSelectable) || !anySelectable || !choice.disabled
+    );
+  };
+  const stepCursor = (step) => {
+    for (let i = 1; i <= choices.length; i++) {
+      const candidate =
+        (cursorIndex + step * i + choices.length * i) % choices.length;
+      if (isSelectable(candidate)) return candidate;
+    }
+    return cursorIndex;
+  };
+  let cursorIndex = choices.findIndex((_, i) => isSelectable(i));
+  if (cursorIndex == -1) cursorIndex = 0;
   let renderedLineCount = 0;
   const previousRawMode = Boolean(stdin.isRaw);
   const lineWidth = Math.max(20, (stdout.columns ?? 80) - 2);
@@ -1118,6 +1438,20 @@ async function askMultiToggleWithArrows(label, choices, face, initial) {
       const choice = choices[i];
       const isOn = Boolean(selected[choice.value]);
       const cursor = i == cursorIndex ? chalk.blue("›") : " ";
+      if (choice.disabled) {
+        const text = choice.hint
+          ? `${choice.label} (${choice.hint})`
+          : choice.label;
+        const dimmed = chalk.dim(clamp(text, Math.max(8, lineWidth - 8)));
+        // Selectable-but-dimmed (installable) keeps its ●/○; hard-blocked uses ✕.
+        const marker = isSelectable(i)
+          ? isOn
+            ? chalk.blue("●")
+            : chalk.dim("○")
+          : chalk.dim("✕");
+        lines.push(`│  ${cursor} ${marker} ${dimmed}`);
+        continue;
+      }
       const marker = isOn ? chalk.blue("●") : chalk.dim("○");
       const text = clamp(choice.label, Math.max(8, lineWidth - 6));
       const painted = i == cursorIndex ? chalk.bold(text) : text;
@@ -1203,16 +1537,17 @@ async function askMultiToggleWithArrows(label, choices, face, initial) {
         return;
       }
       if (input == "\x1b[A" || input == "\x1bOA") {
-        cursorIndex = (cursorIndex - 1 + choices.length) % choices.length;
+        cursorIndex = stepCursor(-1);
         writeLines(menuLines());
         return;
       }
       if (input == "\x1b[B" || input == "\x1bOB") {
-        cursorIndex = (cursorIndex + 1) % choices.length;
+        cursorIndex = stepCursor(1);
         writeLines(menuLines());
         return;
       }
       if (input == " ") {
+        if (!isSelectable(cursorIndex)) return;
         const key = choices[cursorIndex].value;
         selected[key] = !selected[key];
         writeLines(menuLines());

package/bin/commands/run-core.js

@@ -1,6 +1,5 @@
 import chalk from "chalk";
 import { spawn } from "child_process";
-import { glob } from "glob";
 import { minimatch } from "minimatch";
 import { Channel, MessageType } from "../wipc.js";
 import {
@@ -21,6 +20,7 @@ import { PassThrough } from "stream";
 import { buildWebRunnerSource } from "./web-runner-source.js";
 import { PersistentWebSessionHost } from "./web-session.js";
 import { build } from "./build-core.js";
+import { resolveSpecFiles, emitSelectorWarnings } from "../selectors.js";
 import { createReporter as createDefaultReporter } from "../reporters/default.js";
 import { createTapReporter } from "../reporters/tap.js";
 import { persistCrashRecord } from "../crash-store.js";
@@ -733,14 +733,9 @@ export async function run(
       }
     }
   }
-  const inputPatterns = resolveInputPatterns(config.input, selectors);
-  const includePatterns = inputPatterns.filter((p) => !p.startsWith("!"));
-  const ignorePatterns = inputPatterns
-    .filter((p) => p.startsWith("!"))
-    .map((p) => p.slice(1));
-  const inputFiles = (
-    await glob(includePatterns, { ignore: ignorePatterns })
-  ).sort((a, b) => a.localeCompare(b));
+  const { files: inputFiles, warnings: selectorWarnings } =
+    await resolveSpecFiles(config.input, selectors);
+  emitSelectorWarnings(selectorWarnings);
   const snapshotEnabled = flags.snapshot !== false;
   const createSnapshots = Boolean(flags.createSnapshots);
   const overwriteSnapshots = Boolean(flags.overwriteSnapshots);
@@ -1364,61 +1359,6 @@ function runtimeNameFromCommand(command) {
   const token = command.trim().split(/\s+/)[0];
   return token && token.length ? token : "runtime";
 }
-function resolveInputPatterns(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 = stripSuiteSuffix(selector);
-      for (const configuredInput of configuredInputs) {
-        patterns.add(
-          path.join(path.dirname(configuredInput), `${base}.spec.ts`),
-        );
-      }
-      continue;
-    }
-    patterns.add(selector);
-  }
-  return [...patterns];
-}
-function expandSelectors(selectors) {
-  const expanded = [];
-  for (const selector of selectors) {
-    if (!selector) continue;
-    if (!shouldSplitSelector(selector)) {
-      expanded.push(selector);
-      continue;
-    }
-    for (const token of selector.split(",")) {
-      const trimmed = token.trim();
-      if (!trimmed.length) continue;
-      expanded.push(trimmed);
-    }
-  }
-  return expanded;
-}
-function shouldSplitSelector(selector) {
-  return (
-    selector.includes(",") &&
-    !selector.includes("/") &&
-    !selector.includes("\\") &&
-    !/[*?[\]{}]/.test(selector)
-  );
-}
-function isBareSuiteSelector(selector) {
-  return (
-    !selector.includes("/") &&
-    !selector.includes("\\") &&
-    !/[*?[\]{}]/.test(selector)
-  );
-}
-function stripSuiteSuffix(selector) {
-  return selector.replace(/\.spec\.ts$/, "").replace(/\.ts$/, "");
-}
 function normalizeReport(raw) {
   if (Array.isArray(raw)) {
     return {
@@ -2165,14 +2105,19 @@ async function runProcess(
       runtimeEvents,
     );
     if (synthesized) {
-      reporter.onWarning?.({
-        message:
-          "runtime report payload missing; reconstructed result from streamed lifecycle events",
-      });
-      if (code !== 0 || hasMeaningfulRuntimeOutput(stderrBuffer)) {
+      const exitedEarly = !runtimeEvents.sawFileEnd;
+      if (
+        exitedEarly ||
+        code !== 0 ||
+        hasMeaningfulRuntimeOutput(stderrBuffer)
+      ) {
         const errorParts = [];
         if (code !== 0) {
           errorParts.push(`child process exited with code ${code}`);
+        } else if (exitedEarly) {
+          errorParts.push(
+            "test runtime exited before reporting file completion",
+          );
         }
         const stderrText = normalizeRuntimeOutput(stderrBuffer);
         if (stderrText.length) {
@@ -2201,12 +2146,18 @@ async function runProcess(
           modeName,
           code !== 0
             ? `test runtime failed with exit code ${code}`
-            : "test runtime wrote to stderr",
+            : exitedEarly
+              ? "test runtime exited before completing the test file"
+              : "test runtime wrote to stderr",
           errorText,
           stdoutBuffer,
           stderrBuffer,
         );
       }
+      reporter.onWarning?.({
+        message:
+          "runtime report payload missing; reconstructed result from streamed lifecycle events",
+      });
       return synthesized;
     }
     const errorText = "missing report payload from test runtime";
@@ -2548,14 +2499,19 @@ async function runWebSessionProcess(
       runtimeEvents,
     );
     if (synthesized) {
-      reporter.onWarning?.({
-        message:
-          "runtime report payload missing; reconstructed result from streamed lifecycle events",
-      });
-      if (code !== 0 || hasMeaningfulRuntimeOutput(stderrBuffer)) {
+      const exitedEarly = !runtimeEvents.sawFileEnd;
+      if (
+        exitedEarly ||
+        code !== 0 ||
+        hasMeaningfulRuntimeOutput(stderrBuffer)
+      ) {
         const errorParts = [];
         if (code !== 0) {
           errorParts.push(`child process exited with code ${code}`);
+        } else if (exitedEarly) {
+          errorParts.push(
+            "test runtime exited before reporting file completion",
+          );
         }
         const stderrText = normalizeRuntimeOutput(stderrBuffer);
         if (stderrText.length) {
@@ -2567,10 +2523,35 @@ async function runWebSessionProcess(
           reportStream,
           runtimeEvents,
         );
-        reporter.onWarning?.({
-          message: `${errorParts.join("; ")}\n${diagnostics}`,
+        errorParts.push(diagnostics);
+        const errorText = errorParts.join("\n\n");
+        persistCrashRecord(crashDir, {
+          kind: "test",
+          file: specFile,
+          entryKey: crashEntryKey,
+          mode: modeName ?? "default",
+          error: errorText || "runtime reported an unknown error",
+          stdout: stdoutBuffer,
+          stderr: stderrBuffer,
         });
+        return appendRuntimeFailureReport(
+          synthesized,
+          specFile,
+          modeName,
+          code !== 0
+            ? `test runtime failed with exit code ${code}`
+            : exitedEarly
+              ? "test runtime exited before completing the test file"
+              : "test runtime wrote to stderr",
+          errorText,
+          stdoutBuffer,
+          stderrBuffer,
+        );
       }
+      reporter.onWarning?.({
+        message:
+          "runtime report payload missing; reconstructed result from streamed lifecycle events",
+      });
       return synthesized;
     }
     const diagnostics = buildRuntimeReportDiagnostics(

package/bin/index.js

@@ -41,6 +41,7 @@ import { BuildWorkerPool } from "./build-worker-pool.js";
 import { PersistentWebSessionHost } from "./commands/web-session.js";
 import { buildRecorderStorage } from "./commands/build-core.js";
 import { DependencyGraph } from "./dependency-graph.js";
+import { resolveSpecFiles, emitSelectorWarnings } from "./selectors.js";
 const _args = process.argv.slice(2);
 const flags = [];
 const args = [];
@@ -2344,7 +2345,10 @@ async function runWatchLoop(
           if (byte === 0x03) {
             if (rawModeEnabled) stdin.setRawMode(false);
             closeAllWatchers();
-            process.exit(0);
+            // Exit non-zero if the last run left anything failing, or if a run
+            // is still in flight (an interrupted run counts as a failure), so
+            // quitting a red watch session still fails CI / shell pipelines.
+            process.exit(isRunning || failingSpecs.size ? 1 : 0);
           }
           if (isRunning) break;
           if (byte === 0x77 || byte === 0x57) {
@@ -2394,7 +2398,8 @@ async function runWatchLoop(
   process.on("SIGINT", () => {
     if (rawModeEnabled) stdin.setRawMode(false);
     closeAllWatchers();
-    process.exit(0);
+    // Mirror the raw-mode ctrl+c path: a failing or in-flight run exits 1.
+    process.exit(isRunning || failingSpecs.size ? 1 : 0);
   });
   // Keep the process alive
   await new Promise(() => {});
@@ -3851,9 +3856,9 @@ async function resolveSelectedFiles(configPath, selectors, warn = true) {
   const resolvedConfigPath =
     configPath ?? path.join(process.cwd(), "./as-test.config.json");
   const config = loadConfig(resolvedConfigPath, warn);
-  const patterns = resolveInputPatterns(config.input, selectors);
-  const matches = await glob(patterns);
-  const specs = matches.filter((file) => file.endsWith(".spec.ts"));
+  const { files, warnings } = await resolveSpecFiles(config.input, selectors);
+  if (warn) emitSelectorWarnings(warnings);
+  const specs = files.filter((file) => file.endsWith(".spec.ts"));
   return [...new Set(specs)].sort((a, b) => a.localeCompare(b));
 }
 async function resolveSelectedFuzzFiles(
@@ -3992,27 +3997,6 @@ function levenshteinDistance(left, right) {
   }
   return matrix[left.length][right.length];
 }
-function resolveInputPatterns(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 = stripSuiteSuffix(selector);
-      for (const configuredInput of configuredInputs) {
-        patterns.add(
-          path.join(path.dirname(configuredInput), `${base}.spec.ts`),
-        );
-      }
-      continue;
-    }
-    patterns.add(selector);
-  }
-  return [...patterns];
-}
 function resolveFuzzPatterns(configured, selectors) {
   const configuredInputs = Array.isArray(configured)
     ? configured

package/bin/selectors.js

@@ -0,0 +1,208 @@
+import { glob } from "glob";
+import chalk from "chalk";
+import * as path from "path";
+// Selector resolution runs in several places per command (the orchestrator,
+// then build/run cores per file); dedupe by text so a warning prints once per
+// process regardless of how many resolvers see the same selector.
+const reportedSelectorWarnings = new Set();
+export function emitSelectorWarnings(warnings) {
+  for (const warning of warnings) {
+    if (reportedSelectorWarnings.has(warning)) continue;
+    reportedSelectorWarnings.add(warning);
+    process.stderr.write(`${chalk.yellow.bold("WARN")} ${warning}\n`);
+  }
+}
+const GLOB_MAGIC = /[*?[\]{}]/;
+function hasGlobMagic(selector) {
+  return GLOB_MAGIC.test(selector);
+}
+function endsWithSlash(selector) {
+  return /[\\/]$/.test(selector);
+}
+function stripTrailingSlash(selector) {
+  return selector.replace(/[\\/]+$/, "");
+}
+function stripSuiteSuffix(selector) {
+  return selector.replace(/\.spec\.ts$/, "").replace(/\.ts$/, "");
+}
+function isCwdRelative(selector) {
+  return (
+    selector.startsWith("./") ||
+    selector.startsWith("../") ||
+    selector.startsWith(".\\") ||
+    selector.startsWith("..\\") ||
+    selector.startsWith("/") ||
+    selector.startsWith("~") ||
+    path.isAbsolute(selector)
+  );
+}
+// A selector with a path separator that is not merely a single trailing slash
+// (e.g. `assembly/__tests__/foo.spec.ts`, passed verbatim by the orchestrator)
+// is treated as a direct cwd-relative path rather than a test-folder alias.
+function hasInternalSlash(selector) {
+  return /[\\/]/.test(stripTrailingSlash(selector));
+}
+// The longest leading run of path segments containing no glob magic — the
+// static "test folder" of an input pattern (`assembly/__tests__/**/*.spec.ts`
+// -> `assembly/__tests__`).
+function globBase(pattern) {
+  const segments = pattern.split("/");
+  const base = [];
+  for (const segment of segments) {
+    if (hasGlobMagic(segment)) break;
+    base.push(segment);
+  }
+  return base.join("/") || ".";
+}
+function uniqueInputRoots(configuredInputs) {
+  const roots = new Set();
+  for (const pattern of configuredInputs) {
+    if (pattern.startsWith("!")) continue;
+    roots.add(globBase(pattern));
+  }
+  return [...roots];
+}
+// Turn a cwd-relative selector into the spec glob(s) it stands for.
+function cwdPatterns(selector) {
+  if (endsWithSlash(selector)) {
+    return [`${stripTrailingSlash(selector)}/**/*.spec.ts`];
+  }
+  if (/\.ts$/.test(selector)) return [selector];
+  return [`${stripSuiteSuffix(selector)}.spec.ts`];
+}
+// Turn a bare selector into the spec glob(s) it stands for, anchored to a
+// configured input root and searched recursively beneath it. A selector that
+// already carries glob magic (`rfc/*.spec.ts`, `*.spec.ts`) is appended
+// verbatim so the user's pattern controls the match; a plain folder/name has
+// the spec suffix supplied.
+function barePatterns(root, selector) {
+  if (hasGlobMagic(selector)) {
+    return [`${root}/**/${selector}`];
+  }
+  if (endsWithSlash(selector)) {
+    return [`${root}/**/${stripTrailingSlash(selector)}/**/*.spec.ts`];
+  }
+  return [`${root}/**/${stripSuiteSuffix(selector)}.spec.ts`];
+}
+// Split comma-joined bare selectors (`a,b,c`) while leaving paths and globs
+// (which can legitimately contain commas, e.g. `{a,b}`) intact.
+function expandSelectors(selectors) {
+  const expanded = [];
+  for (const selector of selectors) {
+    if (!selector) continue;
+    if (
+      selector.includes(",") &&
+      !hasInternalSlash(selector) &&
+      !endsWithSlash(selector) &&
+      !hasGlobMagic(selector)
+    ) {
+      for (const token of selector.split(",")) {
+        const trimmed = token.trim();
+        if (trimmed.length) expanded.push(trimmed);
+      }
+      continue;
+    }
+    expanded.push(selector);
+  }
+  return expanded;
+}
+async function globFiles(patterns) {
+  return glob(patterns);
+}
+async function resolveSelector(selector, inputRoots) {
+  const warnings = [];
+  const isGlob = hasGlobMagic(selector);
+  // Explicit cwd-relative selector (`./`, `../`, absolute, `~`) — resolve from
+  // the cwd only. A glob is matched verbatim; a plain path gets the spec suffix.
+  if (isCwdRelative(selector)) {
+    const files = await globFiles(isGlob ? [selector] : cwdPatterns(selector));
+    if (!files.length) {
+      const bare = selector.replace(/^\.[\\/]/, "");
+      let suggestion = null;
+      for (const root of inputRoots) {
+        const inRoot = await globFiles(barePatterns(root, bare));
+        if (inRoot.length) {
+          suggestion = bare;
+          break;
+        }
+      }
+      warnings.push(
+        suggestion
+          ? `"${selector}" not found relative to the current directory — did you mean "${suggestion}" (searches the configured test folder)?`
+          : `"${selector}" not found relative to the current directory`,
+      );
+    }
+    return { files, warnings };
+  }
+  // A plain path with an internal separator (e.g. the orchestrator's own
+  // `assembly/__tests__/foo.spec.ts`) resolves from the cwd verbatim. Globs
+  // skip this and fall through to test-folder anchoring below.
+  if (!isGlob && hasInternalSlash(selector)) {
+    const direct = await globFiles(cwdPatterns(selector));
+    if (direct.length) return { files: direct, warnings };
+    // Fall through to test-folder resolution for user shorthands like
+    // `nested/array` that aren't a real cwd path.
+  }
+  // Bare name/folder or relative glob — configured input root(s) first.
+  const perRoot = [];
+  for (const root of inputRoots) {
+    const files = await globFiles(barePatterns(root, selector));
+    if (files.length) perRoot.push({ root, files });
+  }
+  if (perRoot.length) {
+    if (perRoot.length > 1) {
+      warnings.push(
+        `selector "${selector}" matched specs under ${perRoot.length} input roots (${perRoot
+          .map((entry) => entry.root)
+          .join(", ")}) — running all of them`,
+      );
+    }
+    return { files: perRoot.flatMap((entry) => entry.files), warnings };
+  }
+  // Fall back to the cwd before giving up.
+  const cwdFiles = await globFiles(
+    isGlob ? [selector] : cwdPatterns(`./${selector}`),
+  );
+  if (cwdFiles.length) {
+    return { files: cwdFiles, warnings };
+  }
+  warnings.push(
+    inputRoots.length
+      ? `no spec files matched "${selector}" in ${inputRoots.join(", ")} or the current directory`
+      : `no spec files matched "${selector}"`,
+  );
+  return { files: [], warnings };
+}
+// Resolve configured input patterns + positional selectors into the concrete
+// set of spec files to act on, along with any human-readable warnings. With no
+// selectors this is just the configured globs (honoring `!`-negations); with
+// selectors the per-selector rules above apply and config negations are
+// intentionally bypassed so an explicit pick always wins.
+export async function resolveSpecFiles(configured, selectors) {
+  const configuredInputs = Array.isArray(configured)
+    ? configured
+    : [configured];
+  if (!selectors.length) {
+    const include = configuredInputs.filter((p) => !p.startsWith("!"));
+    const ignore = configuredInputs
+      .filter((p) => p.startsWith("!"))
+      .map((p) => p.slice(1));
+    const files = (await glob(include, { ignore })).sort((a, b) =>
+      a.localeCompare(b),
+    );
+    return { files, warnings: [] };
+  }
+  const inputRoots = uniqueInputRoots(configuredInputs);
+  const files = new Set();
+  const warnings = [];
+  for (const selector of expandSelectors(selectors)) {
+    if (!selector) continue;
+    const resolved = await resolveSelector(selector, inputRoots);
+    for (const file of resolved.files) files.add(file);
+    warnings.push(...resolved.warnings);
+  }
+  return {
+    files: [...files].sort((a, b) => a.localeCompare(b)),
+    warnings,
+  };
+}

package/lib/build/index.js

@@ -220,6 +220,7 @@ async function instantiateEsmInstance(wasmPath, helperPath, imports) {
       "esm bindings do not support custom imports in as-test/lib; pass {} or switch to raw bindings",
     );
   }
+  patchNodeIo();
   const instance = await captureHelperInstance(async () => {
     await import(`${pathToFileURL(helperPath).href}?t=${Date.now()}`);
   });

package/lib/src/index.ts

@@ -272,6 +272,10 @@ async function instantiateEsmInstance(
       "esm bindings do not support custom imports in as-test/lib; pass {} or switch to raw bindings",
     );
   }
+  // The esm helper auto-instantiates at import time and writes the WIPC report
+  // by calling the global process.stdout.write with an ArrayBuffer. Patch node
+  // IO before importing so that write (and stdin.read) accept the raw buffer.
+  patchNodeIo();
   const instance = await captureHelperInstance(async () => {
     await import(`${pathToFileURL(helperPath).href}?t=${Date.now()}`);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -80,10 +80,10 @@
     "build:transform": "rm -rf ./transform/lib && tsc -p ./transform && prettier -w ./transform/",
     "test": "node ./bin/index.js test --parallel",
     "test:integration": "node --test tests/*.test.mjs",
-    "test:modes": "npm run test -- --mode node:bindings,node:wasi,wasmtime,wasmer,wazero,firefox,chromium,webkit,firefox:headless,chromium:headless,webkit:headless",
+    "test:modes": "npm run test -- --mode node:bindings,node:bindings:raw,node:bindings:esm,node:wasi,wasmtime,wasmer,wazero,firefox,chromium,webkit,firefox:headless,chromium:headless,webkit:headless",
     "test:examples": "npm --prefix ./examples run test",
     "test:all": "npm run build && npm run test:modes && npm run test:integration && npm run test:examples",
-    "test:ci": "npm run test -- --enable try-as --config ./as-test.ci.config.json",
+    "test:ci": "npm run test -- --mode node:bindings,node:wasi,wasmtime",
     "fuzz": "node ./bin/index.js fuzz",
     "bench:seed": "node ./bin/index.js fuzz --config ./as-test.bench.config.json --clean",
     "bench:seed:compare": "bash ./tools/bench-seed-compare.sh 7",