as-test 1.5.0 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Change Log
 
+## 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

@@ -438,10 +438,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
@@ -769,6 +772,7 @@ function getDefaultBuildArgs(
   config,
   featureToggles,
   tryAsAlreadyConfigured = false,
+  bindingsAlreadyConfigured = false,
 ) {
   const buildArgs = [];
   const effectiveFeatures = resolveEffectiveFeatures(config, featureToggles);
@@ -795,7 +799,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 +806,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 +888,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

@@ -2165,14 +2165,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 +2206,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 +2559,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 +2583,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

@@ -2344,7 +2344,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 +2397,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(() => {});

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.1",
   "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",