as-test 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Change Log
 
+## 2026-05-28 - v1.5.0
+
+### `mockFn` and `mockImport` now work anywhere
+
+- feat: `mockFn(target, callback)` and `unmockFn(target)` can be called from **anywhere** in the source — including inside a `test()` / `it()` callback — not just module top-level. The MockTransform now reads the visitor's enclosing-statement `ref` so it locates and removes the directive wherever it lives, defers list mutations to the end of `visitSource` so traversal isn't disturbed, and `unshift`s the generated mock fn to module scope so every rewritten call site can reach it. Previously, a nested `mockFn` silently no-op'd because the transform's top-level-statement scan never found the directive — calls remained un-rewritten and the test passed only because trivial assertions passed too.
+- feat: `mockImport(path, callback)` + `unmockImport(path)` now retains the real import as a fallback (call this "route 2"). When a `mockImport`'d path is **never unmocked**, the `@external` import is removed and the wrapper always dispatches through `__mock_import` — same as before. When a path **is** unmocked somewhere, the transform keeps the real import (renamed `__as_test_real_<name>`, de-exported), and the wrapper becomes `if (__mock_import.has(path)) call_indirect(...) else __as_test_real_<name>(...)`. So a call after `unmockImport` falls back to the host binding instead of trapping on a missing `__mock_import` entry.
+- fix: the runtime import-stub now covers any module the wasm declares (not just `env`), so a retained `mockImport` target with no host implementation (e.g. an artificial test import) gets a `() => 0` no-op stub before `WebAssembly.instantiate`. Without this, the wasm `LinkError`s on instantiation. `env` is no longer skipped — asc raw bindings put their `abort`/`trace`/`seed` defaults on the inner object and user env imports on the prototype, so the stub fills missing `env.*` user imports without clobbering asc's defaults.
+- fix: in raw bindings the helper reads `imports.<module>` while building its import object, so the stub had to be applied **before** `helper.instantiate(module, imports)` is called — adding it inside the `WebAssembly.instantiate` wrapper alone was too late and surfaced as `instantiate@.../<spec>.js:...` failures (this was the chromium-headful + watch + full-suite crash where one bad job poisoned the persistent session).
+
+### Class serializer rename — `__AS_TEST_TO_JSON()`
+
+- change: the transform-injected class serializer is now emitted under an internal name `__AS_TEST_TO_JSON(): string` instead of `toJSON(): string`. Users can't accidentally call the generated method, and a hand-written `toJSON()` no longer collides with the generated one.
+- feat: at runtime, `stringify<T>` for a managed class calls a user `toJSON()` only when its return type is a string (probed via a generic-parameter helper so the dead branch is pruned at compile time); a non-string `toJSON` cleanly falls back to the generated `__AS_TEST_TO_JSON()` structural serializer instead of being a compile error. The transform now generates `__AS_TEST_TO_JSON` for every eligible class so the fallback always exists.
+
+### Chromium fix — fragmented WebSocket frames
+
+- fix: chromium fragments outbound WebSocket binary messages at ~128KB. The two web server frame parsers (standalone runner in `lib/src/index.ts` and managed `PersistentWebSessionHost` in `cli/commands/web-session.ts`) read the opcode but **never checked the FIN bit or handled continuation frames (`0x0`)** — so chromium's continuation frame was silently dropped, the wipc byte stream desynced, and frame-header bytes bled into report payloads as `Bad control character in JSON`. Both parsers now reassemble fragments (buffer `0x1`/`0x2` with FIN=0, append `0x0` until FIN=1). firefox and webkit don't fragment at that size, which is why they always worked.
+- fix: the CLI reassembled chunked report payloads by `data.toString("utf8")` per-chunk then joining. The producer (`assembly/util/wipc.ts`) chunks raw UTF-8 bytes, so a multibyte character straddling a chunk boundary was getting mis-decoded into replacement chars (or worse) on any transport, not just chromium. Chunks are now buffered as `Buffer`s and decoded UTF-8 once after `Buffer.concat`.
+
+### Web mode — repro command + browser test infrastructure
+
+- fix: when a managed web run (`ast test --mode firefox/chromium/webkit`) fails, the printed repro now points at the **managed CLI command** (`node ./bin/index.js run <spec> --mode <browser>`) instead of `node .as-test/runners/default.web.js <wasm>`. The managed path uses `PersistentWebSessionHost`'s panel UI; the standalone runner uses `lib/src/web-runner/*`'s terminal UI — completely different stacks. So the old repro never actually reproduced the failing run, and showed a different UI to boot. Top-level negations in `runCommandForLog` are now mode-aware via `webSession`.
+- change: removed `tests/fixtures/fake-browser.mjs`. The integration suite's web tests now use real headless chromium (auto-detected from PATH or the Playwright cache), and `AS_TEST_SKIP_WEB=1` cleanly skips them in CI. CI workflows (`.github/workflows/as-test.yml`, `release.yml`) already set `AS_TEST_SKIP_WEB=1`. Without this, the shim's flow hung indefinitely in some local environments, eating ~hours of integration time.
+- feat: a small "browser-closes-early" test now ships a `process.exit(0)` shebanged executable as `--browser` to verify the framework reports a clean disconnect error rather than hanging.
+
+### Per-mode spec exclusion
+
+- feat: mode-level `input` overrides can use `!`-prefixed patterns to exclude specific specs from that mode. The orchestrator's per-mode `run()` call now checks the **mode-only additions** (negations in the mode's `input` array that aren't in the top-level `input`) against the selector and returns an empty result for excluded files. Top-level negations remain ignored when a file is explicitly selected, so `test __tmp_foo` still works for paths the top-level config would otherwise filter.
+- chore: `mock.spec` is excluded from `wasmtime`, `wasmer`, and `wazero` modes in `as-test.config.json`. Those CLI-only WASI runtimes can't accept arbitrary imports at instantiation, so the retained `env.*` `mockImport` target has no JS host to satisfy it.
+
+### Scripts and CI standardization
+
+- feat: new `build` script aliases `build:cli && build:lib && build:transform`. `test:all`, `release:check`, and `prepublishOnly` now compose with it instead of repeating the three sub-builds. `test:all` runs `build && test:modes && test:integration && test:examples`.
+- chore: `test:modes` drops the duplicate `--parallel` (the base `test` script already has it), and `test:ci` composes with `npm run test --` instead of hard-coding the bin path.
+- chore: `.github/workflows/as-test.yml` and `release.yml` now share identical test-job setup (checkout@v4, `actions/setup-node@v4`, `oven-sh/setup-bun@v1`, install Wasmtime, lint, typecheck, build, `test:ci`, `test:integration`). `as-test.yml` keeps the Test Summary action for PR feedback; the manual `curl`/`tar` Node bootstrap and the inline Bun installer are gone. `examples.yml` uses the `build` alias.
+
+## 2026-05-27 - v1.4.1
+
+### Dependency hygiene
+
+- fix: declare `minimatch` (`^10.2.5`) as a direct dependency. The watch-mode exclusion matcher (`matchesAnyExclusion` in `cli/index.ts`) imported `minimatch` but relied on it resolving transitively through `glob` — it would have broken if `glob` ever dropped or changed that dependency. The pinned range matches what `glob` already uses, so the same resolved copy is reused.
+- chore: `cli/dependency-graph.ts` no longer embeds raw NUL bytes. The `(mode, spec)` dependency-graph key delimiter is now written as a `\u0000` escape rather than a literal NUL. Behavior is identical (NUL is still the delimiter — it can't appear in a mode name or filesystem path, so keys stay collision-proof), but the source and its compiled `bin/` output are now plain text instead of being flagged binary by `git`/`grep`.
+
 ## 2026-05-26 - v1.4.0
 
 ### Dependency-free value serialization (json-as removed)

package/assembly/src/expectation.ts

@@ -20,8 +20,8 @@ function safeStringify<T>(value: T): string {
     !isString<T>() &&
     !isArray<T>()
   ) {
-    // @ts-expect-error: optional user-supplied serializer
-    if (!isDefined(value.toJSON)) {
+    // @ts-expect-error: warn only when nothing serializes it — no user `toJSON` and no transform-generated `__AS_TEST_TO_JSON` → renders as a `<TypeName>` placeholder.
+    if (!isDefined(value.toJSON) && !isDefined(value.__AS_TEST_TO_JSON)) {
       sendWarning(
         "Class " +
           nameof<T>() +

package/assembly/src/stringify.ts

@@ -15,8 +15,11 @@
 //   * Array / StaticArray               → element-wise recursion
 //   * Set                               → array of values
 //   * Map                               → object with stringified keys
-//   * managed with `toJSON(): string`   → call it
-//   * managed without `toJSON()`        → "<TypeName>" placeholder
+//   * managed, user `toJSON()` returns string → call it
+//   * managed otherwise                       → `__AS_TEST_TO_JSON()`
+//       (transform-generated structural serializer; the fallback when a
+//        user `toJSON` returns a non-string, or when there's no `toJSON`)
+//   * managed with neither                    → "<TypeName>" placeholder
 //
 // The Date/ArrayBuffer/typed-array/StaticArray/Set/Map branches use
 // `value instanceof X` guards. In a generic function AssemblyScript resolves
@@ -134,8 +137,16 @@ export function stringify<T>(value: T): string {
   }
 
   if (isManaged<T>()) {
-    // @ts-ignore: hand-written or transform-generated serializer
-    if (isDefined(value.toJSON)) return value.toJSON();
+    // A user-supplied `toJSON` wins, but only when it returns a string.
+    // `preferToJSONString` decides that on the return type and otherwise
+    // falls back to the transform-generated structural serializer.
+    // @ts-ignore: optional user-supplied serializer
+    if (isDefined(value.toJSON)) {
+      // @ts-ignore: optional user-supplied serializer
+      return preferToJSONString(value, value.toJSON());
+    }
+    // @ts-ignore: transform-generated structural serializer
+    if (isDefined(value.__AS_TEST_TO_JSON)) return value.__AS_TEST_TO_JSON();
     return escape("<" + nameof<T>() + ">");
   }
 
@@ -144,6 +155,20 @@ export function stringify<T>(value: T): string {
   return escape("<" + nameof<T>() + ">");
 }
 
+// Given a managed value and the result of calling its `toJSON()`, return
+// that result when it's a string, otherwise the transform-generated
+// `__AS_TEST_TO_JSON` structural serializer (or a `<TypeName>` placeholder
+// if neither applies). `R` is the `toJSON` return type, so the
+// `result`-returning branch is pruned — and never type-checked — for any
+// non-string return type. That's what lets a `toJSON` returning, say,
+// `i32` fall back here instead of being a hard compile error.
+function preferToJSONString<T, R>(value: T, result: R): string {
+  if (isString<R>()) return result as string;
+  // @ts-ignore: transform-generated structural serializer
+  if (isDefined(value.__AS_TEST_TO_JSON)) return value.__AS_TEST_TO_JSON();
+  return escape("<" + nameof<T>() + ">");
+}
+
 // JSON string escape per RFC 8259, with explicit handling for UTF-16
 // surrogates (matches json-as's serializeString behaviour).
 //

package/bin/commands/build-core.js

@@ -68,9 +68,13 @@ export async function build(
   const sourceInputPatterns =
     overrides.kind === "fuzz" ? config.fuzz.input : config.input;
   const inputPatterns = resolveInputPatterns(sourceInputPatterns, 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));
   await assertNoArtifactCollisions(sourceInputPatterns);
   warnOnUnknownModeReferences(inputFiles, loadedConfig.modes ?? {});
   const coverageEnabled = resolveCoverageEnabled(

package/bin/commands/fuzz-core.js

@@ -13,6 +13,10 @@ import { persistCrashRecord } from "../crash-store.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 const MAGIC = Buffer.from("WIPC");
 const HEADER_SIZE = 9;
+// See cli/wipc.ts: the magic can occur by chance in passthrough output, so a
+// declared length above this bound means the match is coincidental.
+const MAX_FRAME_SIZE = 16 * 1024 * 1024;
+const KNOWN_FRAME_TYPES = new Set([0x00, 0x01, 0x02, 0x03]);
 const MAX_DEFAULT_SEED = 0x7fffffff;
 export async function fuzz(
   configPath = DEFAULT_CONFIG_PATH,
@@ -135,7 +139,14 @@ async function runFuzzTarget(
   };
   const captured = captureFrames((type, payload, respond) => {
     if (type == 0x02) {
-      const event = JSON.parse(payload.toString("utf8"));
+      // A coincidental magic + CALL match whose payload is not JSON must not
+      // crash the run (it would be misreported as a fuzz crash); drop it.
+      let event;
+      try {
+        event = JSON.parse(payload.toString("utf8"));
+      } catch {
+        return;
+      }
       const kind = String(event.kind ?? "");
       if (kind == "fuzz:config") {
         const resolved = config;
@@ -419,6 +430,16 @@ function captureFrames(onFrame) {
       if (buffer.length < HEADER_SIZE) return true;
       const type = buffer.readUInt8(4);
       const length = buffer.readUInt32LE(5);
+      // A coincidental magic match in passthrough output: an unknown type or
+      // an implausible length means these 4 bytes are data, not a frame.
+      // Emit them and resync past the magic so we don't stall or misparse.
+      if (!KNOWN_FRAME_TYPES.has(type) || length > MAX_FRAME_SIZE) {
+        const raw = buffer.subarray(0, MAGIC.length);
+        passthrough = Buffer.concat([passthrough, raw]);
+        originalWrite(raw);
+        buffer = buffer.subarray(MAGIC.length);
+        continue;
+      }
       const frameSize = HEADER_SIZE + length;
       if (buffer.length < frameSize) return true;
       const payload = buffer.subarray(HEADER_SIZE, frameSize);

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;
@@ -2375,7 +2441,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 +2488,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;

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/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);
   });
@@ -279,6 +283,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 +426,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 +646,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 +1176,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;

package/lib/src/index.ts

@@ -247,7 +247,11 @@ async function instantiateRawInstance(
   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);
   });
@@ -347,6 +351,8 @@ async function instantiateWebInstance(
     let ready = false;
     let wsSocket: Duplex | null = null;
     let wsBuffer = Buffer.alloc(0);
+    let wsFragmentOpcode = 0;
+    let wsFragments: Buffer[] = [];
     let stdinBuffer = Buffer.alloc(0);
     let browserProcess: ChildProcess | null = null;
     let browserStderr = "";
@@ -488,15 +494,33 @@ async function instantiateWebInstance(
           payload = Buffer.from(payload);
         }
         wsBuffer = 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) {
+          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);
         }
       }
@@ -703,20 +727,33 @@ function createWasmImports(
   module: WebAssembly.Module,
   imports: AnyImports,
 ): AnyImports {
-  const mergedImports = mergeImports(withNodeIo({}), imports);
-  if (!mergedImports.env || typeof mergedImports.env != "object") {
-    mergedImports.env = {};
-  }
+  return stubMissingImports(module, mergeImports(withNodeIo({}), imports));
+}
+
+// Fills any function import the module declares but the caller didn't provide
+// with a no-op stub, so instantiation never fails on a missing import. This
+// covers imports an unmocked `mockImport` target reintroduces (which keep
+// their real binding but have no host implementation in tests). `skipModules`
+// leaves bindings-helper-owned modules (env / wasi) for the helper to fill.
+function stubMissingImports(
+  module: WebAssembly.Module,
+  imports: AnyImports,
+  skipModules: readonly string[] = [],
+): AnyImports {
+  const skip = new Set(skipModules);
+  const bag = imports as Record<string, Record<string, unknown>>;
   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;
@@ -1306,6 +1343,16 @@ async function captureHelperInstance(
     source: BufferSource | WebAssembly.Module,
     importObject?: WebAssembly.Imports,
   ) => {
+    // Stub any import the bindings helper left unprovided (e.g. an unmocked
+    // mockImport target with no host implementation), so esm/raw bindings
+    // instantiate instead of failing with a LinkError. env/wasi stay with the
+    // helper.
+    if (source instanceof WebAssembly.Module && importObject) {
+      stubMissingImports(source, importObject as AnyImports, [
+        "env",
+        "wasi_snapshot_preview1",
+      ]);
+    }
     const result = await originalInstantiate(source, importObject);
     if (result instanceof WebAssembly.Instance) {
       instance = result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -9,6 +9,7 @@
   "dependencies": {
     "chalk": "^5.6.2",
     "glob": "^13.0.6",
+    "minimatch": "^10.2.5",
     "typer-diff": "^1.1.1",
     "wipc-js": "^0.1.1"
   },
@@ -73,30 +74,31 @@
     "access": "public"
   },
   "scripts": {
-    "test": "npm run test:as && npm run test:integration",
-    "test:as": "node ./bin/index.js test --parallel --enable try-as",
-    "test:integration": "npm run build:cli && npm run build:lib && node --test tests/*.test.mjs",
-    "test:ci": "node ./bin/index.js test --parallel --tap --enable try-as --config ./as-test.ci.config.json",
+    "build": "npm run build:cli && npm run build:lib && npm run build:transform",
+    "build:cli": "rm -rf ./bin/ && tsc -p cli && prettier -w ./cli/ && chmod +x ./bin/index.js",
+    "build:lib": "tsc -p ./tsconfig.lib.json",
+    "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: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",
     "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",
-    "test:examples": "npm --prefix ./examples run test",
-    "ci:act": "bash ./tools/act.sh push",
-    "ci:act:pr": "bash ./tools/act.sh pull_request",
-    "ci:act:tests": "act push -W .github/workflows/as-test.yml",
-    "ci:act:examples": "act push -W .github/workflows/examples.yml",
     "typecheck": "tsc -p cli --noEmit && tsc -p tsconfig.lib.json --noEmit && tsc -p transform --noEmit",
     "lint": "eslint transform/src/**/*.ts tools/**/*.js eslint.config.js",
-    "build:lib": "tsc -p ./tsconfig.lib.json",
-    "build:transform": "rm -rf ./transform/lib && tsc -p ./transform && prettier -w ./transform/",
-    "build:cli": "rm -rf ./bin/ && tsc -p cli && prettier -w ./cli/ && chmod +x ./bin/index.js",
-    "build:run": "npm run build:cli",
+    "format": "prettier -w .",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs",
-    "format": "prettier -w .",
-    "release:check": "npm run build:cli && npm run build:lib && npm run build:transform && npm run test && npm run test:examples && npm pack --dry-run --cache /tmp/as-test-npm-cache",
-    "prepublishOnly": "npm run build:cli && npm run build:lib && npm run build:transform && npm run test && npm run format",
+    "release:check": "npm run build && npm run test && npm run test:examples && npm pack --dry-run --cache /tmp/as-test-npm-cache",
+    "prepublishOnly": "npm run build && npm run test && npm run format",
+    "ci:act": "bash ./tools/act.sh push",
+    "ci:act:pr": "bash ./tools/act.sh pull_request",
+    "ci:act:tests": "act push -W .github/workflows/as-test.yml",
+    "ci:act:examples": "act push -W .github/workflows/examples.yml",
     "commitmsg:verify": "bash ./scripts/commit-msg.sh",
     "precommit:verify": "bash ./scripts/pre-commit.sh",
     "prepare": "husky"

package/transform/lib/equals.js

@@ -4,7 +4,7 @@ import { readFileSync } from "fs";
 import { join } from "path";
 import { SimpleParser, isStdlib } from "./util.js";
 const EQUALS_METHOD = "__AS_TEST_EQUALS";
-const TOJSON_METHOD = "toJSON";
+const GENERATED_TOJSON_METHOD = "__AS_TEST_TO_JSON";
 const REFLECT_LOCAL = "__AS_TEST_REFLECT_EQUALS_INTERNAL";
 const STRINGIFY_LOCAL = "__AS_TEST_STRINGIFY_INTERNAL";
 const ALREADY_INJECTED_EQUALS = new WeakSet();
@@ -165,7 +165,7 @@ export class EqualsTransform {
     injectToJSONMethod(klass) {
         if (ALREADY_INJECTED_TOJSON.has(klass))
             return false;
-        if (declaresMethod(klass, TOJSON_METHOD))
+        if (declaresMethod(klass, GENERATED_TOJSON_METHOD))
             return false;
         if (hasAnyDecorator(klass, JSON_DECORATORS))
             return false;
@@ -189,7 +189,7 @@ export class EqualsTransform {
         const body = parts.length
             ? `return "{" + ${parts.join(" + ")} + "}";`
             : `return "{}";`;
-        const code = `toJSON(): string { ${body} }`;
+        const code = `${GENERATED_TOJSON_METHOD}(): string { ${body} }`;
         try {
             const method = SimpleParser.parseClassMember(code, klass);
             klass.members.push(method);

package/transform/lib/index.js

@@ -37,6 +37,10 @@ export default class Transformer extends Transform {
         for (const target of mockedImportTargets) {
             mock.importMocked.add(target);
         }
+        const unmockedImportTargets = collectUnmockImportTargets(sources);
+        for (const target of unmockedImportTargets) {
+            mock.importUnmocked.add(target);
+        }
         for (const source of sources) {
             const sourceInfo = analyzeSourceText(source.text);
             const shouldInjectRunCall = source.sourceKind == 1 &&
@@ -110,8 +114,13 @@ function patchModeName(parser, modeName) {
     }
 }
 function collectMockImportTargets(sources) {
+    return collectImportTargets(sources, /\bmockImport\s*\(\s*["']([^"']+)["']/g);
+}
+function collectUnmockImportTargets(sources) {
+    return collectImportTargets(sources, /\bunmockImport\s*\(\s*["']([^"']+)["']/g);
+}
+function collectImportTargets(sources, pattern) {
     const out = new Set();
-    const pattern = /\bmockImport\s*\(\s*["']([^"']+)["']/g;
     for (const source of sources) {
         const text = stripComments(source.text);
         for (const match of text.matchAll(pattern)) {

package/transform/lib/mock.js

@@ -6,8 +6,11 @@ export class MockTransform extends Visitor {
     globalStatements = [];
     mocked = new Set();
     importMocked = new Set();
-    visitCallExpression(node) {
-        super.visitCallExpression(node);
+    importUnmocked = new Set();
+    pendingHoist = [];
+    pendingRemoval = [];
+    visitCallExpression(node, ref = null) {
+        super.visitCallExpression(node, ref);
         const name = normalizeName(expressionName(node.expression));
         if (this.mocked.has(name + "_mock")) {
             node.expression = Node.createIdentifierExpression(name + "_mock", node.expression.range);
@@ -25,6 +28,7 @@ export class MockTransform extends Visitor {
             if (!oldFn)
                 return;
             this.mocked.delete(normalizeName(expressionName(oldFn)) + "_mock");
+            this.scheduleRemoval(node, ref);
             return;
         }
         if (name == "unmockImport") {
@@ -34,26 +38,21 @@ export class MockTransform extends Visitor {
             return;
         const oldValue = node.args[0];
         const callback = node.args[1];
-        if (!oldValue || !callback)
+        if (!oldValue || !callback || !callback.declaration)
             return;
-        const newName = normalizeName(expressionName(oldValue));
-        const newFn = Node.createFunctionDeclaration(Node.createIdentifierExpression(newName + "_mock", callback.range), callback.declaration.decorators, 0, callback.declaration.typeParameters, callback.declaration.signature, callback.declaration.body, callback.declaration.arrowKind, callback.range);
-        const currentSource = this.srcCurrent;
-        if (!currentSource)
-            return;
-        const stmts = currentSource.statements;
-        let index = -1;
-        for (let i = 0; i < stmts.length; i++) {
-            const stmt = stmts[i];
-            if (stmt.range.start != node.range.start)
-                continue;
-            index = i;
-            break;
-        }
-        if (index === -1)
+        const mockName = normalizeName(expressionName(oldValue)) + "_mock";
+        const newFn = Node.createFunctionDeclaration(Node.createIdentifierExpression(mockName, callback.range), callback.declaration.decorators, 0, callback.declaration.typeParameters, callback.declaration.signature, callback.declaration.body, callback.declaration.arrowKind, callback.range);
+        this.pendingHoist.push(newFn);
+        this.mocked.add(mockName);
+        this.scheduleRemoval(node, ref);
+    }
+    scheduleRemoval(node, ref) {
+        const container = asStatementContainer(ref);
+        if (!container)
             return;
-        stmts.splice(index, 1, newFn);
-        this.mocked.add(newFn.name.text);
+        const stmt = container.statements.find((s) => s.expression === node);
+        if (stmt)
+            this.pendingRemoval.push({ container, stmt });
     }
     visitFunctionDeclaration(node, isDefault) {
         if (this.mocked.has(node.name.text))
@@ -62,11 +61,23 @@ export class MockTransform extends Visitor {
     }
     visitSource(node) {
         this.mocked = new Set();
+        this.pendingHoist = [];
+        this.pendingRemoval = [];
         this.srcCurrent = node;
         super.visitSource(node);
         const currentSource = this.srcCurrent;
         if (!currentSource)
             return;
+        for (const { container, stmt } of this.pendingRemoval) {
+            const i = container.statements.indexOf(stmt);
+            if (i !== -1)
+                container.statements.splice(i, 1);
+        }
+        this.pendingRemoval = [];
+        if (this.pendingHoist.length) {
+            currentSource.statements.unshift(...this.pendingHoist);
+            this.pendingHoist = [];
+        }
         const stmts = currentSource.statements;
         for (let index = 0; index < stmts.length; index++) {
             const node = stmts[index];
@@ -98,6 +109,17 @@ export class MockTransform extends Visitor {
                 index++;
                 continue;
             }
+            if (this.importUnmocked.has(path) && node.signature.returnType) {
+                const realName = "__as_test_real_" + node.name.text;
+                const r = node.range;
+                const wrapper = buildFallbackWrapper(node, path, realName, r);
+                const mutable = node;
+                mutable.name = Node.createIdentifierExpression(realName, r);
+                mutable.flags &= ~2;
+                stmts.splice(index + 1, 0, wrapper);
+                index++;
+                continue;
+            }
             const args = [
                 Node.createCallExpression(Node.createPropertyAccessExpression(Node.createIdentifierExpression("__mock_import", node.range), Node.createIdentifierExpression("get", node.range), node.range), null, [Node.createStringLiteralExpression(path, node.range)], node.range),
             ];
@@ -120,6 +142,27 @@ function isBodylessTopLevelFunction(node) {
         "signature" in candidate &&
         candidate.body == null);
 }
+function buildFallbackWrapper(node, path, realName, range) {
+    const mockImportGet = Node.createCallExpression(Node.createPropertyAccessExpression(Node.createIdentifierExpression("__mock_import", range), Node.createIdentifierExpression("get", range), range), null, [Node.createStringLiteralExpression(path, range)], range);
+    const indirectArgs = [mockImportGet];
+    const forwardArgs = [];
+    for (const param of node.signature.parameters) {
+        indirectArgs.push(Node.createIdentifierExpression(param.name.text, range));
+        forwardArgs.push(Node.createIdentifierExpression(param.name.text, range));
+    }
+    const ifMocked = Node.createIfStatement(Node.createCallExpression(Node.createPropertyAccessExpression(Node.createIdentifierExpression("__mock_import", range), Node.createIdentifierExpression("has", range), range), null, [Node.createStringLiteralExpression(path, range)], range), Node.createReturnStatement(Node.createCallExpression(Node.createIdentifierExpression("call_indirect", range), null, indirectArgs, range), range), null, range);
+    const callReal = Node.createReturnStatement(Node.createCallExpression(Node.createIdentifierExpression(realName, range), null, forwardArgs, range), range);
+    const signature = Node.createFunctionType(node.signature.parameters, node.signature.returnType, node.signature.explicitThisType, node.signature.isNullable, range);
+    const exported = (node.flags & 2) != 0;
+    return Node.createFunctionDeclaration(Node.createIdentifierExpression(node.name.text, range), null, exported ? 2 : 0, node.typeParameters, signature, Node.createBlockStatement([ifMocked, callReal], range), 0, range);
+}
+function asStatementContainer(ref) {
+    const candidate = ref;
+    if (candidate && Array.isArray(candidate.statements)) {
+        return candidate;
+    }
+    return null;
+}
 function normalizeName(value) {
     return value
         .replaceAll(".", "_")