as-test 1.4.1 → 1.5.1

package/bin/commands/run-core.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import { spawn } from "child_process";
 import { glob } from "glob";
+import { minimatch } from "minimatch";
 import { Channel, MessageType } from "../wipc.js";
 import {
   applyMode,
@@ -686,10 +687,60 @@ export async function run(
   const loadedConfig = loadConfig(resolvedConfigPath);
   const mode = applyMode(loadedConfig, options.modeName);
   const config = mode.config;
+  // Mode-level exclusion: when a mode override adds `!`-prefixed negations
+  // beyond the top-level config, honor them even when the orchestrator passes
+  // a single-file selector (`resolveInputPatterns` drops the configured input
+  // in that case). Top-level negations are intentionally not enforced here so
+  // explicit selectors can still override them (e.g. picking a __tmp_* spec).
+  if (options.modeName && selectors.length > 0) {
+    const topInput = Array.isArray(loadedConfig.input)
+      ? loadedConfig.input
+      : [loadedConfig.input];
+    const modeInput = Array.isArray(config.input)
+      ? config.input
+      : [config.input];
+    const topNegations = new Set(topInput.filter((p) => p.startsWith("!")));
+    const modeOnlyNegations = modeInput
+      .filter((p) => p.startsWith("!") && !topNegations.has(p))
+      .map((p) => p.slice(1));
+    if (modeOnlyNegations.length > 0) {
+      const cwd = process.cwd();
+      const allExcluded = selectors.every((sel) => {
+        const abs = path.isAbsolute(sel) ? sel : path.resolve(cwd, sel);
+        const rel = path.relative(cwd, abs).split(path.sep).join("/");
+        return modeOnlyNegations.some((pat) =>
+          minimatch(rel, pat, { dot: true, matchBase: true }),
+        );
+      });
+      if (allExcluded) {
+        return {
+          failed: false,
+          stats: collectRunStats([]),
+          buildTime: 0,
+          snapshotSummary: { matched: 0, created: 0, updated: 0, failed: 0 },
+          coverageSummary: {
+            enabled: false,
+            showPoints: false,
+            total: 0,
+            covered: 0,
+            uncovered: 0,
+            percent: 100,
+            files: [],
+          },
+          reports: [],
+          logSummary: { count: 0, file: null, groups: [], text: "" },
+        };
+      }
+    }
+  }
   const inputPatterns = resolveInputPatterns(config.input, selectors);
-  const inputFiles = (await glob(inputPatterns)).sort((a, b) =>
-    a.localeCompare(b),
-  );
+  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 snapshotEnabled = flags.snapshot !== false;
   const createSnapshots = Boolean(flags.createSnapshots);
   const overwriteSnapshots = Boolean(flags.overwriteSnapshots);
@@ -798,7 +849,20 @@ export async function run(
             token.replace(/<name>/g, fileBase).replace(/<file>/g, fileToken),
           ),
       };
-      const runCommandForLog = formatInvocation(invocation);
+      // A managed web-session run never spawns the standalone runner, so its
+      // repro must re-run the managed CLI command (which renders the same panel
+      // UI) rather than `default.web.js <wasm>`, a different web stack.
+      const runCommandForLog = webSession
+        ? formatInvocation({
+            command: execPath,
+            args: [
+              process.argv[1] ?? "",
+              "run",
+              resolveSpecRelativePath(file, config.input),
+              ...(options.modeName ? ["--mode", options.modeName] : []),
+            ],
+          })
+        : formatInvocation(invocation);
       const snapshotStore = new SnapshotStore(
         file,
         config.snapshotDir,
@@ -1991,7 +2055,7 @@ async function runProcess(
       if (reportStream.sawChunkStart && !reportStream.sawChunkEnd) {
         reportStream.chunkFramesReceived++;
         reportStream.chunkBytesReceived += data.length;
-        reportStream.chunks.push(data.toString("utf8"));
+        reportStream.chunks.push(Buffer.from(data));
         return;
       }
       try {
@@ -2041,7 +2105,9 @@ async function runProcess(
       parseError =
         parseError ?? "missing report:end marker for chunked report payload";
     } else {
-      const chunkedPayload = reportStream.chunks.join("");
+      const chunkedPayload = Buffer.concat(reportStream.chunks).toString(
+        "utf8",
+      );
       try {
         report = JSON.parse(chunkedPayload);
         parseError = null;
@@ -2099,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) {
@@ -2135,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";
@@ -2375,7 +2452,7 @@ async function runWebSessionProcess(
       if (reportStream.sawChunkStart && !reportStream.sawChunkEnd) {
         reportStream.chunkFramesReceived++;
         reportStream.chunkBytesReceived += data.length;
-        reportStream.chunks.push(data.toString("utf8"));
+        reportStream.chunks.push(Buffer.from(data));
         return;
       }
       try {
@@ -2422,7 +2499,9 @@ async function runWebSessionProcess(
       parseError =
         parseError ?? "missing report:end marker for chunked report payload";
     } else {
-      const chunkedPayload = reportStream.chunks.join("");
+      const chunkedPayload = Buffer.concat(reportStream.chunks).toString(
+        "utf8",
+      );
       try {
         report = JSON.parse(chunkedPayload);
         parseError = null;
@@ -2480,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) {
@@ -2499,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/commands/web-session.js

@@ -16,6 +16,8 @@ export class PersistentWebSessionHost {
     this.serverSockets = new Set();
     this.wsSocket = null;
     this.wsBuffer = Buffer.alloc(0);
+    this.wsFragmentOpcode = 0;
+    this.wsFragments = [];
     this.ready = false;
     this.closed = false;
     this.currentJob = null;
@@ -334,14 +336,32 @@ export class PersistentWebSessionHost {
         payload = Buffer.from(payload);
       }
       this.wsBuffer = this.wsBuffer.subarray(offset + maskLength + length);
-      if (opcode == 0x8) {
+      // Reassemble fragmented messages: a non-final data frame (0x1/0x2 with
+      // FIN=0) starts a sequence continued by 0x0 frames until FIN=1. Chromium
+      // fragments large (64KB) frames, so without this the wipc stream desyncs
+      // and the report payload is corrupted.
+      const fin = (first & 0x80) !== 0;
+      let effectiveOpcode = opcode;
+      if (opcode == 0x0) {
+        this.wsFragments.push(payload);
+        if (!fin) continue;
+        payload = Buffer.concat(this.wsFragments);
+        this.wsFragments = [];
+        effectiveOpcode = this.wsFragmentOpcode;
+        this.wsFragmentOpcode = 0;
+      } else if ((opcode == 0x1 || opcode == 0x2) && !fin) {
+        this.wsFragmentOpcode = opcode;
+        this.wsFragments = [payload];
+        continue;
+      }
+      if (effectiveOpcode == 0x8) {
         return;
       }
-      if (opcode == 0x1) {
+      if (effectiveOpcode == 0x1) {
         this.onControl(payload.toString("utf8"));
         continue;
       }
-      if (opcode == 0x2 && this.currentJob) {
+      if (effectiveOpcode == 0x2 && this.currentJob) {
         this.currentJob.onBinary(Buffer.from(payload));
       }
     }
@@ -1012,6 +1032,10 @@ async function instantiate(imports) {
     if (typeof helper.instantiate != "function") {
       throw new Error("bindings helper missing instantiate export");
     }
+    // Stub before the helper runs: it reads imports.<module> while building its
+    // import object, so a missing import must be filled here, not just in the
+    // WebAssembly.instantiate wrapper (which runs too late for raw bindings).
+    stubMissingImports(module, imports, ["wasi_snapshot_preview1"]);
     const instance = await captureInstantiateInstance(async () => {
       await helper.instantiate(module, imports);
     });
@@ -1026,11 +1050,31 @@ async function instantiate(imports) {
   }
   const binary = await fetchWasmBinary(wasmUrl);
   const module = new WebAssembly.Module(binary);
+  stubMissingImports(module, imports, ["wasi_snapshot_preview1"]);
   const result = await WebAssembly.instantiate(module, imports);
   const wasmInstance = result instanceof WebAssembly.Instance ? result : result.instance;
   return decorateInstance(wasmInstance);
 }
 
+// Fills function imports the module declares but nothing provided with a no-op
+// stub, so instantiation never fails on a missing import (e.g. an unmocked
+// mockImport target with no host implementation). Mirrors the node runner.
+function stubMissingImports(module, importObject, skipModules) {
+  const skip = new Set(skipModules || []);
+  for (const entry of WebAssembly.Module.imports(module)) {
+    if (entry.kind !== "function" || skip.has(entry.module)) continue;
+    let mod = importObject[entry.module];
+    if (!mod || typeof mod !== "object") {
+      mod = {};
+      importObject[entry.module] = mod;
+    }
+    if (!(entry.name in mod)) {
+      mod[entry.name] = () => 0;
+    }
+  }
+  return importObject;
+}
+
 async function fetchWasmBinary(wasmUrl) {
   const response = await fetch(wasmUrl);
   if (!response.ok) throw new Error("failed to fetch wasm artifact: " + response.status);
@@ -1041,6 +1085,9 @@ async function captureInstantiateInstance(run) {
   const originalInstantiate = WebAssembly.instantiate.bind(WebAssembly);
   let captured = null;
   WebAssembly.instantiate = async (source, importObject) => {
+    if (source instanceof WebAssembly.Module && importObject) {
+      stubMissingImports(source, importObject, ["wasi_snapshot_preview1"]);
+    }
     const result = await originalInstantiate(source, importObject);
     captured = result instanceof WebAssembly.Instance ? result : result.instance;
     return result;

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/bin/wipc.js

@@ -45,14 +45,52 @@ export class Channel {
       if (this.buffer.length < Channel.HEADER_SIZE) return;
       const type = this.buffer.readUInt8(4);
       const length = this.buffer.readUInt32LE(5);
+      // The magic can occur by chance inside ordinary stdout output (e.g. a
+      // test printing binary data or the literal string "WIPC"). A genuine
+      // frame always carries a known type and a bounded length; if either
+      // check fails the match is coincidental, so surface the magic bytes as
+      // passthrough and resume scanning past them rather than crash or stall.
+      if (!Channel.isKnownType(type) || length > Channel.MAX_FRAME_SIZE) {
+        this.resyncPastMagic();
+        continue;
+      }
       const frameSize = Channel.HEADER_SIZE + length;
       if (this.buffer.length < frameSize) return;
       const payload = this.buffer.subarray(Channel.HEADER_SIZE, frameSize);
+      if (type === MessageType.CALL) {
+        // CALL payloads are always JSON. If the bytes do not parse the magic
+        // was coincidental — do NOT consume the frame; treat the magic as
+        // output and resync so the rest flushes as passthrough.
+        let parsed;
+        try {
+          parsed = JSON.parse(payload.toString("utf8"));
+        } catch {
+          this.resyncPastMagic();
+          continue;
+        }
+        this.buffer = this.buffer.subarray(frameSize);
+        this.onCall(parsed);
+        continue;
+      }
       this.buffer = this.buffer.subarray(frameSize);
-      this.handleFrame(type, payload);
+      this.dispatchFrame(type, payload);
     }
   }
-  handleFrame(type, payload) {
+  static isKnownType(type) {
+    return (
+      type === MessageType.OPEN ||
+      type === MessageType.CLOSE ||
+      type === MessageType.CALL ||
+      type === MessageType.DATA
+    );
+  }
+  // A coincidental magic match: emit the magic bytes as ordinary output and
+  // advance past them so scanning can continue from the next byte.
+  resyncPastMagic() {
+    this.onPassthrough(this.buffer.subarray(0, Channel.MAGIC.length));
+    this.buffer = this.buffer.subarray(Channel.MAGIC.length);
+  }
+  dispatchFrame(type, payload) {
     switch (type) {
       case MessageType.OPEN:
         this.onOpen();
@@ -60,14 +98,9 @@ export class Channel {
       case MessageType.CLOSE:
         this.onClose();
         break;
-      case MessageType.CALL:
-        this.onCall(JSON.parse(payload.toString("utf8")));
-        break;
       case MessageType.DATA:
         this.onDataMessage(payload);
         break;
-      default:
-        throw new Error(`Unknown frame type: ${type}`);
     }
   }
   onPassthrough(_data) {}
@@ -79,3 +112,9 @@ export class Channel {
 Channel.MAGIC = Buffer.from("WIPC");
 Channel.HEADER_SIZE = 9;
 Channel.MAGIC_PREFIX_MAX = Channel.MAGIC.length - 1;
+// Upper bound on a single frame's declared payload length. Real frames are
+// small JSON events or report chunks (<= 64 KiB); anything larger means the
+// 4 magic bytes appeared by coincidence inside passthrough output. Without
+// this bound a forged length would make us buffer (and swallow real frames)
+// indefinitely. The margin over 64 KiB future-proofs larger report chunks.
+Channel.MAX_FRAME_SIZE = 16 * 1024 * 1024;

package/lib/build/index.js

@@ -200,7 +200,11 @@ async function instantiateRawInstance(wasmPath, helperPath, imports) {
   if (typeof helper.instantiate != "function") {
     throw new Error("bindings helper missing instantiate export");
   }
-  const mergedImports = mergeImports(withNodeIo({}), imports);
+  const mergedImports = stubMissingImports(
+    module,
+    mergeImports(withNodeIo({}), imports),
+    ["wasi_snapshot_preview1"],
+  );
   const instance = await captureHelperInstance(async () => {
     await helper.instantiate(module, mergedImports);
   });
@@ -216,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()}`);
   });
@@ -279,6 +284,8 @@ async function instantiateWebInstance(wasmPath, imports) {
     let ready = false;
     let wsSocket = null;
     let wsBuffer = Buffer.alloc(0);
+    let wsFragmentOpcode = 0;
+    let wsFragments = [];
     let stdinBuffer = Buffer.alloc(0);
     let browserProcess = null;
     let browserStderr = "";
@@ -420,15 +427,29 @@ async function instantiateWebInstance(wasmPath, imports) {
           payload = Buffer.from(payload);
         }
         wsBuffer = wsBuffer.subarray(offset + maskLength + length);
-        if (opcode == 0x8) {
+        const fin = (first & 0x80) !== 0;
+        let effectiveOpcode = opcode;
+        if (opcode == 0x0) {
+          wsFragments.push(payload);
+          if (!fin) continue;
+          payload = Buffer.concat(wsFragments);
+          wsFragments = [];
+          effectiveOpcode = wsFragmentOpcode;
+          wsFragmentOpcode = 0;
+        } else if ((opcode == 0x1 || opcode == 0x2) && !fin) {
+          wsFragmentOpcode = opcode;
+          wsFragments = [payload];
+          continue;
+        }
+        if (effectiveOpcode == 0x8) {
           finish(0);
           return;
         }
-        if (opcode == 0x1) {
+        if (effectiveOpcode == 0x1) {
           onControl(payload.toString("utf8"));
           continue;
         }
-        if (opcode == 0x2) {
+        if (effectiveOpcode == 0x2) {
           process.stdout.write(payload);
         }
       }
@@ -626,20 +647,23 @@ function hasUserImports(imports) {
   return Object.keys(imports).length > 0;
 }
 function createWasmImports(module, imports) {
-  const mergedImports = mergeImports(withNodeIo({}), imports);
-  if (!mergedImports.env || typeof mergedImports.env != "object") {
-    mergedImports.env = {};
-  }
+  return stubMissingImports(module, mergeImports(withNodeIo({}), imports));
+}
+function stubMissingImports(module, imports, skipModules = []) {
+  const skip = new Set(skipModules);
+  const bag = imports;
   for (const entry of WebAssembly.Module.imports(module)) {
-    if (
-      entry.module == "env" &&
-      entry.kind == "function" &&
-      !(entry.name in mergedImports.env)
-    ) {
-      mergedImports.env[entry.name] = () => 0;
+    if (entry.kind != "function" || skip.has(entry.module)) continue;
+    let mod = bag[entry.module];
+    if (!mod || typeof mod != "object") {
+      mod = {};
+      bag[entry.module] = mod;
+    }
+    if (!(entry.name in mod)) {
+      mod[entry.name] = () => 0;
     }
   }
-  return mergedImports;
+  return imports;
 }
 let patchedWasiWarning = false;
 function suppressExperimentalWasiWarning() {
@@ -1153,6 +1177,12 @@ async function captureHelperInstance(runHelper) {
   const originalInstantiate = WebAssembly.instantiate.bind(WebAssembly);
   let instance = null;
   WebAssembly.instantiate = async (source, importObject) => {
+    if (source instanceof WebAssembly.Module && importObject) {
+      stubMissingImports(source, importObject, [
+        "env",
+        "wasi_snapshot_preview1",
+      ]);
+    }
     const result = await originalInstantiate(source, importObject);
     if (result instanceof WebAssembly.Instance) {
       instance = result;

package/lib/build/web-runner/worker.js

@@ -109,6 +109,10 @@ async function instantiate(imports) {
     if (typeof helper.instantiate != "function") {
       throw new Error("bindings helper missing instantiate export");
     }
+    // Stub before the helper runs: it reads imports.<module> while building its
+    // import object, so a missing import must be filled here, not just in the
+    // WebAssembly.instantiate wrapper (which runs too late for raw bindings).
+    stubMissingImports(module, imports, ["wasi_snapshot_preview1"]);
     const instance = await captureInstantiateInstance(async () => {
       await helper.instantiate(module, imports);
     });
@@ -125,11 +129,31 @@ async function instantiate(imports) {
   }
   const binary = await fetchWasmBinary(wasmUrl);
   const module = new WebAssembly.Module(binary);
+  stubMissingImports(module, imports, ["wasi_snapshot_preview1"]);
   const result = await WebAssembly.instantiate(module, imports);
   const instance = result instanceof WebAssembly.Instance ? result : result.instance;
   return decorateInstance(instance);
 }
 
+// Fills function imports the module declares but nothing provided with a no-op
+// stub, so instantiation never fails on a missing import (e.g. an unmocked
+// mockImport target with no host implementation). Mirrors the node runner.
+function stubMissingImports(module, importObject, skipModules) {
+  const skip = new Set(skipModules || []);
+  for (const entry of WebAssembly.Module.imports(module)) {
+    if (entry.kind !== "function" || skip.has(entry.module)) continue;
+    let mod = importObject[entry.module];
+    if (!mod || typeof mod !== "object") {
+      mod = {};
+      importObject[entry.module] = mod;
+    }
+    if (!(entry.name in mod)) {
+      mod[entry.name] = () => 0;
+    }
+  }
+  return importObject;
+}
+
 async function fetchWasmBinary(wasmUrl) {
   const response = await fetch(wasmUrl);
   if (!response.ok) {
@@ -142,6 +166,9 @@ async function captureInstantiateInstance(run) {
   const originalInstantiate = WebAssembly.instantiate.bind(WebAssembly);
   let captured = null;
   WebAssembly.instantiate = async (source, importObject) => {
+    if (source instanceof WebAssembly.Module && importObject) {
+      stubMissingImports(source, importObject, ["wasi_snapshot_preview1"]);
+    }
     const result = await originalInstantiate(source, importObject);
     if (result instanceof WebAssembly.Instance) {
       captured = result;