vitest 4.0.17 → 4.1.0-beta.2

package/dist/chunks/{index.6Qv1eEA6.js → index.CAN630q3.js}

@@ -1,25 +1,25 @@
 import { chai } from '@vitest/expect';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.Cm-kSBVi.js';
-import { r as rpc } from './rpc.BoxB0q7B.js';
-import { g as getWorkerState } from './utils.DvEY5TfP.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.B8ej_ZHS.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.cvFp-ao9.js';
+import { r as rpc } from './rpc.DcRWTy5G.js';
+import { g as getWorkerState } from './utils.DT4VyRyl.js';
+import { T as TestRunner, N as NodeBenchmarkRunner } from './test.G82XYNFk.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
 }
 
-async function resolveSnapshotEnvironment(config, executor) {
+async function resolveSnapshotEnvironment(config, moduleRunner) {
 	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.Ce0vMQM7.js');
+		const { VitestNodeSnapshotEnvironment } = await import('./node.CrSEwhm4.js');
 		return new VitestNodeSnapshotEnvironment();
 	}
-	const mod = await executor.import(config.snapshotEnvironment);
+	const mod = await moduleRunner.import(config.snapshotEnvironment);
 	if (typeof mod.default !== "object" || !mod.default) throw new Error("Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`");
 	return mod.default;
 }
 
 async function getTestRunnerConstructor(config, moduleRunner) {
-	if (!config.runner) return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
+	if (!config.runner) return config.mode === "test" ? TestRunner : NodeBenchmarkRunner;
 	const mod = await moduleRunner.import(config.runner);
 	if (!mod.default && typeof mod.default !== "function") throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
 	return mod.default;
@@ -78,6 +78,18 @@ async function resolveTestRunner(config, moduleRunner, traces) {
 			state.durations.prepare = 0;
 			state.durations.environment = 0;
 		});
+		// Strip function conditions from retry config before sending via RPC
+		// Functions cannot be cloned by structured clone algorithm
+		const sanitizeRetryConditions = (task) => {
+			if (task.retry && typeof task.retry === "object" && typeof task.retry.condition === "function")
+ // Remove function condition - it can't be serialized
+			task.retry = {
+				...task.retry,
+				condition: void 0
+			};
+			if (task.tasks) task.tasks.forEach(sanitizeRetryConditions);
+		};
+		files.forEach(sanitizeRetryConditions);
 		rpc().onCollected(files);
 		await originalOnCollected?.call(testRunner, files);
 	};

package/dist/chunks/{index.C5r1PdPD.js → index.CFulQRmC.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.M8mOzt4Y.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.B-iBE_Gx.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils/helpers';
 

package/dist/chunks/{index.Z5E_ObnR.js → index.CouFDptX.js}

@@ -1,5 +1,5 @@
-import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.2VT5v0um.js';
-import { b as bench } from './benchmark.B3N2zMcH.js';
+import { N as NodeBenchmarkRunner, T as TestRunner, a as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, b as vitest } from './test.G82XYNFk.js';
+import { b as bench } from './benchmark.BoqSLF53.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
@@ -9,7 +9,9 @@ const assertType = function assertType() {};
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  BenchmarkRunner: NodeBenchmarkRunner,
   EvaluatedModules: VitestEvaluatedModules,
+  TestRunner: TestRunner,
   afterAll: afterAll,
   afterEach: afterEach,
   assert: assert,

package/dist/chunks/{init-forks.BC6ZwHQN.js → init-forks.BnCXPazU.js}

@@ -1,4 +1,4 @@
-import { i as init } from './init.C9kljSTm.js';
+import { i as init } from './init.B95Mm0Iz.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them

package/dist/chunks/{init-threads.CxSxLC0N.js → init-threads.Cyh2PqXi.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.C9kljSTm.js';
+import { i as init } from './init.B95Mm0Iz.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {

package/dist/chunks/{init.C9kljSTm.js → init.B95Mm0Iz.js}

@@ -3,11 +3,12 @@ import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
 import { ModuleRunner } from 'vite/module-runner';
-import { b as VitestTransport } from './startModuleRunner.DEj0jb3e.js';
+import { b as VitestTransport } from './startVitestModuleRunner.BK-u7y4N.js';
 import { e as environments } from './index.CyBMJtT7.js';
+import { serializeValue } from '@vitest/utils/serialize';
 import { serializeError } from '@vitest/utils/error';
 import { T as Traces } from './traces.CCmnQaNT.js';
-import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BoxB0q7B.js';
+import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.DcRWTy5G.js';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { s as setupInspect } from './inspector.CvyFGlXm.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
@@ -46,11 +47,11 @@ function createEnvironmentLoader(root, rpc) {
 	}
 	return _loaders.get(root);
 }
-async function loadEnvironment(name, root, rpc, traces) {
-	if (isBuiltinEnvironment(name)) return { environment: environments[name] };
-	const loader = createEnvironmentLoader(root, rpc);
-	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await traces.$("vitest.runtime.environment.resolve", () => rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__")))?.id ?? resolve(root, name);
-	const pkg = await traces.$("vitest.runtime.environment.import", () => loader.import(packageId));
+async function loadNativeEnvironment(name, root, traces) {
+	const packageId = name[0] === "." || name[0] === "/" ? pathToFileURL(resolve(root, name)).toString() : import.meta.resolve(`vitest-environment-${name}`, pathToFileURL(root).toString());
+	return resolveEnvironmentFromModule(name, packageId, await traces.$("vitest.runtime.environment.import", () => import(packageId)));
+}
+function resolveEnvironmentFromModule(name, packageId, pkg) {
 	if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
 	const environment = pkg.default;
 	if (environment.transformMode != null && environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web", received "${environment.transformMode}".`);
@@ -59,14 +60,65 @@ async function loadEnvironment(name, root, rpc, traces) {
 		// keep for backwards compat
 		environment.viteEnvironment ??= environment.transformMode === "ssr" ? "ssr" : "client";
 	}
+	return environment;
+}
+async function loadEnvironment(name, root, rpc, traces, viteModuleRunner) {
+	if (isBuiltinEnvironment(name)) return { environment: environments[name] };
+	if (!viteModuleRunner) return { environment: await loadNativeEnvironment(name, root, traces) };
+	const loader = createEnvironmentLoader(root, rpc);
+	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await traces.$("vitest.runtime.environment.resolve", () => rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__")))?.id ?? resolve(root, name);
 	return {
-		environment,
+		environment: resolveEnvironmentFromModule(name, packageId, await traces.$("vitest.runtime.environment.import", () => loader.import(packageId))),
 		loader
 	};
 }
 
+const cleanupListeners = /* @__PURE__ */ new Set();
+const moduleRunnerListeners = /* @__PURE__ */ new Set();
+function onCleanup(cb) {
+	cleanupListeners.add(cb);
+}
+async function cleanup() {
+	await Promise.all([...cleanupListeners].map((l) => l()));
+}
+function onModuleRunner(cb) {
+	moduleRunnerListeners.add(cb);
+}
+function emitModuleRunner(moduleRunner) {
+	moduleRunnerListeners.forEach((l) => l(moduleRunner));
+}
+
+// Store globals in case tests overwrite them
+const processListeners = process.listeners.bind(process);
+const processOn = process.on.bind(process);
+const processOff = process.off.bind(process);
+const dispose = [];
+function listenForErrors(state) {
+	dispose.forEach((fn) => fn());
+	dispose.length = 0;
+	function catchError(err, type, event) {
+		const worker = state();
+		// if there is another listener, assume that it's handled by user code
+		// one is Vitest's own listener
+		if (processListeners(event).length > 1) return;
+		const error = serializeValue(err);
+		if (typeof error === "object" && error != null) {
+			error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0;
+			if (worker.filepath) error.VITEST_TEST_PATH = worker.filepath;
+		}
+		state().rpc.onUnhandledError(error, type);
+	}
+	const uncaughtException = (e) => catchError(e, "Uncaught Exception", "uncaughtException");
+	const unhandledRejection = (e) => catchError(e, "Unhandled Rejection", "unhandledRejection");
+	processOn("uncaughtException", uncaughtException);
+	processOn("unhandledRejection", unhandledRejection);
+	dispose.push(() => {
+		processOff("uncaughtException", uncaughtException);
+		processOff("unhandledRejection", unhandledRejection);
+	});
+}
+
 const resolvingModules = /* @__PURE__ */ new Set();
-const globalListeners = /* @__PURE__ */ new Set();
 async function execute(method, ctx, worker, traces) {
 	const prepareStart = performance.now();
 	const cleanups = [setupInspect(ctx)];
@@ -92,7 +144,7 @@ async function execute(method, ctx, worker, traces) {
 			},
 			rpc,
 			onCancel,
-			onCleanup: (listener) => globalListeners.add(listener),
+			onCleanup: onCleanup,
 			providedContext: ctx.providedContext,
 			onFilterStackTrace(stack) {
 				return createStackString(parseStacktrace(stack));
@@ -114,7 +166,7 @@ function collect(ctx, worker, traces) {
 	return execute("collect", ctx, worker, traces);
 }
 async function teardown() {
-	await Promise.all([...globalListeners].map((l) => l()));
+	await cleanup();
 }
 const env = process.env;
 function createImportMetaEnvProxy() {
@@ -146,6 +198,7 @@ let traces;
 /** @experimental */
 function init(worker) {
 	worker.on(onMessage);
+	if (worker.onModuleRunner) onModuleRunner(worker.onModuleRunner);
 	let runPromise;
 	let isRunning = false;
 	let workerTeardown;
@@ -316,4 +369,4 @@ function getFilesWithLocations(files) {
 	});
 }
 
-export { init as i, loadEnvironment as l };
+export { listenForErrors as a, emitModuleRunner as e, init as i, loadEnvironment as l };

package/dist/chunks/native.mV0-490A.js

@@ -0,0 +1,148 @@
+import module$1, { isBuiltin } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { MessageChannel } from 'node:worker_threads';
+import { initSyntaxLexers, hoistMocks } from '@vitest/mocker/transforms';
+import { cleanUrl } from '@vitest/utils/helpers';
+import { p as parse } from './acorn.B2iPLyUM.js';
+import MagicString from 'magic-string';
+import { resolve } from 'pathe';
+import c from 'tinyrainbow';
+import { distDir } from '../path.js';
+import { t as toBuiltin } from './modules.BJuCwlRJ.js';
+import 'node:path';
+
+const NOW_LENGTH = Date.now().toString().length;
+const REGEXP_VITEST = /* @__PURE__ */ new RegExp(`%3Fvitest=\\d{${NOW_LENGTH}}`);
+const REGEXP_MOCK_ACTUAL = /\?mock=actual/;
+async function setupNodeLoaderHooks(worker) {
+	if (module$1.setSourceMapsSupport) module$1.setSourceMapsSupport(true);
+	else if (process.setSourceMapsEnabled) process.setSourceMapsEnabled(true);
+	if (worker.config.experimental.nodeLoader !== false) await initSyntaxLexers();
+	if (typeof module$1.registerHooks === "function") module$1.registerHooks({
+		resolve(specifier, context, nextResolve) {
+			if (specifier.includes("mock=actual")) {
+				// url is already resolved by `importActual`
+				const moduleId = specifier.replace(REGEXP_MOCK_ACTUAL, "");
+				const builtin = isBuiltin(moduleId);
+				return {
+					url: builtin ? toBuiltin(moduleId) : moduleId,
+					format: builtin ? "builtin" : void 0,
+					shortCircuit: true
+				};
+			}
+			const isVitest = specifier.includes("%3Fvitest=");
+			const result = nextResolve(isVitest ? specifier.replace(REGEXP_VITEST, "") : specifier, context);
+			// avoid tracking /node_modules/ module graph for performance reasons
+			if (context.parentURL && result.url && !result.url.includes("/node_modules/")) worker.rpc.ensureModuleGraphEntry(result.url, context.parentURL).catch(() => {
+				// ignore errors
+			});
+			// this is require for in-source tests to be invalidated if
+			// one of the files already imported it in --maxWorkers=1 --no-isolate
+			if (isVitest) result.url = `${result.url}?vitest=${Date.now()}`;
+			if (worker.config.experimental.nodeLoader === false || !context.parentURL || result.url.includes(distDir) || context.parentURL?.toString().includes(distDir)) return result;
+			const mockedResult = getNativeMocker()?.resolveMockedModule(result.url, context.parentURL);
+			if (mockedResult != null) return mockedResult;
+			return result;
+		},
+		load: worker.config.experimental.nodeLoader === false ? void 0 : createLoadHook()
+	});
+	else if (module$1.register) {
+		if (worker.config.experimental.nodeLoader !== false) console.warn(`${c.bgYellow(" WARNING ")} "module.registerHooks" is not supported in Node.js ${process.version}. This means that some features like module mocking or in-source testing are not supported. Upgrade your Node.js version to at least 22.15 or disable "experimental.nodeLoader" flag manually.\n`);
+		const { port1, port2 } = new MessageChannel();
+		port1.unref();
+		port2.unref();
+		port1.on("message", (data) => {
+			if (!data || typeof data !== "object") return;
+			switch (data.event) {
+				case "register-module-graph-entry": {
+					const { url, parentURL } = data;
+					worker.rpc.ensureModuleGraphEntry(url, parentURL);
+					return;
+				}
+				default: console.error("Unknown message event:", data.event);
+			}
+		});
+		/** Registers {@link file://./../nodejsWorkerLoader.ts} */
+		module$1.register("#nodejs-worker-loader", {
+			parentURL: import.meta.url,
+			data: { port: port2 },
+			transferList: [port2]
+		});
+	} else if (!process.versions.deno && !process.versions.bun) console.warn("\"module.registerHooks\" and \"module.register\" are not supported. Some Vitest features may not work. Please, use Node.js 18.19.0 or higher.");
+}
+function replaceInSourceMarker(url, source, ms) {
+	const re = /import\.meta\.vitest/g;
+	let match;
+	let overridden = false;
+	// eslint-disable-next-line no-cond-assign
+	while (match = re.exec(source)) {
+		const { index, "0": code } = match;
+		overridden = true;
+		// should it support process.vitest for CJS modules?
+		ms().overwrite(index, index + code.length, "IMPORT_META_TEST()");
+	}
+	if (overridden) {
+		const filename = resolve(fileURLToPath(url));
+		// appending instead of prepending because functions are hoisted and we don't change the offset
+		ms().append(`;\nfunction IMPORT_META_TEST() { return typeof __vitest_worker__ !== 'undefined' && __vitest_worker__.filepath === "${filename.replace(/"/g, "\\\"")}" ? __vitest_index__ : undefined; }`);
+	}
+}
+const ignoreFormats = new Set([
+	"addon",
+	"builtin",
+	"wasm"
+]);
+function createLoadHook(_worker) {
+	return (url, context, nextLoad) => {
+		const result = url.includes("mock=") && isBuiltin(cleanUrl(url)) ? { format: "commonjs" } : nextLoad(url, context);
+		if (result.format && ignoreFormats.has(result.format) || url.includes(distDir)) return result;
+		const mocker = getNativeMocker();
+		mocker?.checkCircularManualMock(url);
+		if (url.includes("mock=automock") || url.includes("mock=autospy")) {
+			const automockedResult = mocker?.loadAutomock(url, result);
+			if (automockedResult != null) return automockedResult;
+			return result;
+		}
+		if (url.includes("mock=manual")) {
+			const mockedResult = mocker?.loadManualMock(url, result);
+			if (mockedResult != null) return mockedResult;
+			return result;
+		}
+		// ignore non-vitest modules for performance reasons,
+		// vi.hoisted and vi.mock won't work outside of test files or setup files
+		if (!result.source || !url.includes("vitest=")) return result;
+		const filename = url.startsWith("file://") ? fileURLToPath(url) : url;
+		const source = result.source.toString();
+		const transformedCode = result.format?.includes("typescript") ? module$1.stripTypeScriptTypes(source) : source;
+		let _ms;
+		const ms = () => _ms || (_ms = new MagicString(source));
+		if (source.includes("import.meta.vitest")) replaceInSourceMarker(url, source, ms);
+		hoistMocks(transformedCode, filename, (code) => parse(code, {
+			ecmaVersion: "latest",
+			sourceType: result.format === "module" || result.format === "module-typescript" || result.format === "typescript" ? "module" : "script"
+		}), {
+			magicString: ms,
+			globalThisAccessor: "\"__vitest_mocker__\""
+		});
+		let code;
+		if (_ms) code = `${_ms.toString()}\n//# sourceMappingURL=${genSourceMapUrl(_ms.generateMap({
+			hires: "boundary",
+			source: filename
+		}))}`;
+		else code = source;
+		return {
+			format: result.format,
+			shortCircuit: true,
+			source: code
+		};
+	};
+}
+function genSourceMapUrl(map) {
+	if (typeof map !== "string") map = JSON.stringify(map);
+	return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
+}
+function getNativeMocker() {
+	return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : void 0;
+}
+
+export { setupNodeLoaderHooks };

package/dist/chunks/nativeModuleMocker.D_q5sFv6.js

@@ -0,0 +1,206 @@
+import module$1, { isBuiltin } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { automockModule, createManualModuleSource, collectModuleExports } from '@vitest/mocker/transforms';
+import { cleanUrl, createDefer } from '@vitest/utils/helpers';
+import { p as parse } from './acorn.B2iPLyUM.js';
+import { isAbsolute } from 'pathe';
+import { t as toBuiltin } from './modules.BJuCwlRJ.js';
+import { B as BareModuleMocker, n as normalizeModuleId } from './startVitestModuleRunner.BK-u7y4N.js';
+import 'node:fs';
+import './utils.DT4VyRyl.js';
+import '@vitest/utils/timers';
+import '../path.js';
+import 'node:path';
+import '../module-evaluator.js';
+import 'node:vm';
+import 'vite/module-runner';
+import './traces.CCmnQaNT.js';
+import '@vitest/mocker';
+import '@vitest/mocker/redirect';
+
+class NativeModuleMocker extends BareModuleMocker {
+	wrapDynamicImport(moduleFactory) {
+		if (typeof moduleFactory === "function") return new Promise((resolve, reject) => {
+			this.resolveMocks().finally(() => {
+				moduleFactory().then(resolve, reject);
+			});
+		});
+		return moduleFactory;
+	}
+	resolveMockedModule(url, parentURL) {
+		// don't mock modules inside of packages because there is
+		// a high chance that it uses `require` which is not mockable
+		// because we use top-level await in "manual" mocks.
+		// for the sake of consistency we don't support mocking anything at all
+		if (parentURL.includes("/node_modules/")) return;
+		const moduleId = normalizeModuleId(url.startsWith("file://") ? fileURLToPath(url) : url);
+		const mockedModule = this.getDependencyMock(moduleId);
+		if (!mockedModule) return;
+		if (mockedModule.type === "redirect") return {
+			url: pathToFileURL(mockedModule.redirect).toString(),
+			shortCircuit: true
+		};
+		if (mockedModule.type === "automock" || mockedModule.type === "autospy") return {
+			url: injectQuery(url, parentURL, `mock=${mockedModule.type}`),
+			shortCircuit: true
+		};
+		if (mockedModule.type === "manual") return {
+			url: injectQuery(url, parentURL, "mock=manual"),
+			shortCircuit: true
+		};
+	}
+	loadAutomock(url, result) {
+		const moduleId = cleanUrl(normalizeModuleId(url.startsWith("file://") ? fileURLToPath(url) : url));
+		let source;
+		if (isBuiltin(moduleId)) {
+			const builtinModule = getBuiltinModule(moduleId);
+			const exports$1 = Object.keys(builtinModule);
+			source = `
+import * as builtinModule from '${toBuiltin(moduleId)}?mock=actual'
+
+${exports$1.map((key, index) => {
+				return `
+const __${index} = builtinModule["${key}"]
+export { __${index} as "${key}" }
+`;
+			}).join("")}`;
+		} else source = result.source?.toString();
+		if (source == null) return;
+		const mockType = url.includes("mock=automock") ? "automock" : "autospy";
+		const transformedCode = transformCode(source, result.format || "module", moduleId);
+		try {
+			const ms = automockModule(transformedCode, mockType, (code) => parse(code, {
+				sourceType: "module",
+				ecmaVersion: "latest"
+			}), { id: moduleId });
+			return {
+				format: "module",
+				source: `${ms.toString()}\n//# sourceMappingURL=${genSourceMapUrl(ms.generateMap({
+					hires: "boundary",
+					source: moduleId
+				}))}`,
+				shortCircuit: true
+			};
+		} catch (cause) {
+			throw new Error(`Cannot automock '${url}' because it failed to parse.`, { cause });
+		}
+	}
+	loadManualMock(url, result) {
+		const moduleId = cleanUrl(normalizeModuleId(url.startsWith("file://") ? fileURLToPath(url) : url));
+		// should not be possible
+		if (this.getDependencyMock(moduleId)?.type !== "manual") {
+			console.warn(`Vitest detected unregistered manual mock ${moduleId}. This is a bug in Vitest. Please, open a new issue with reproduction.`);
+			return;
+		}
+		if (isBuiltin(moduleId)) {
+			const builtinModule = getBuiltinModule(toBuiltin(moduleId));
+			return {
+				format: "module",
+				source: createManualModuleSource(moduleId, Object.keys(builtinModule)),
+				shortCircuit: true
+			};
+		}
+		if (!result.source) return;
+		const transformedCode = transformCode(result.source.toString(), result.format || "module", moduleId);
+		if (transformedCode == null) return;
+		const format = result.format?.startsWith("module") ? "module" : "commonjs";
+		try {
+			return {
+				format: "module",
+				source: createManualModuleSource(moduleId, collectModuleExports(moduleId, transformedCode, format)),
+				shortCircuit: true
+			};
+		} catch (cause) {
+			throw new Error(`Failed to mock '${url}'. See the cause for more information.`, { cause });
+		}
+	}
+	processedModules = /* @__PURE__ */ new Map();
+	checkCircularManualMock(url) {
+		const id = cleanUrl(normalizeModuleId(url.startsWith("file://") ? fileURLToPath(url) : url));
+		this.processedModules.set(id, (this.processedModules.get(id) ?? 0) + 1);
+		// the module is mocked and requested a second time, let's resolve
+		// the factory function that will redefine the exports later
+		if (this.originalModulePromises.has(id)) {
+			const factoryPromise = this.factoryPromises.get(id);
+			this.originalModulePromises.get(id)?.resolve({ __factoryPromise: factoryPromise });
+		}
+	}
+	originalModulePromises = /* @__PURE__ */ new Map();
+	factoryPromises = /* @__PURE__ */ new Map();
+	// potential performance improvement:
+	// store by URL, not ids, no need to call url.*to* methods and normalizeModuleId
+	getFactoryModule(id) {
+		const mock = this.getMockerRegistry().getById(id);
+		if (!mock || mock.type !== "manual") throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+		const mockResult = mock.resolve();
+		if (mockResult instanceof Promise) {
+			// to avoid circular dependency, we resolve this function as {__factoryPromise} in `checkCircularManualMock`
+			// when it's requested the second time. then the exports are exposed as `undefined`,
+			// but later redefined when the promise is actually resolved
+			const promise = createDefer();
+			promise.finally(() => {
+				this.originalModulePromises.delete(id);
+			});
+			mockResult.then(promise.resolve, promise.reject).finally(() => {
+				this.factoryPromises.delete(id);
+			});
+			this.factoryPromises.set(id, mockResult);
+			this.originalModulePromises.set(id, promise);
+			// Node.js on windows processes all the files first, and then runs them
+			// unlike Node.js logic on Mac and Unix where it also runs the code while evaluating
+			// So on Linux/Mac this `if` won't be hit because `checkCircularManualMock` will resolve it
+			// And on Windows, the `checkCircularManualMock` will never have `originalModulePromises`
+			// because `getFactoryModule` is not called until the evaluation phase
+			// But if we track how many times the module was transformed,
+			// we can deduce when to return `__factoryPromise` to support circular modules
+			if ((this.processedModules.get(id) ?? 0) > 1) {
+				this.processedModules.set(id, (this.processedModules.get(id) ?? 1) - 1);
+				promise.resolve({ __factoryPromise: mockResult });
+			}
+			return promise;
+		}
+		return mockResult;
+	}
+	importActual(rawId, importer) {
+		const resolvedId = import.meta.resolve(rawId, pathToFileURL(importer).toString());
+		const url = new URL(resolvedId);
+		url.searchParams.set("mock", "actual");
+		return import(url.toString());
+	}
+	importMock(rawId, importer) {
+		const resolvedId = import.meta.resolve(rawId, pathToFileURL(importer).toString());
+		// file is already mocked
+		if (resolvedId.includes("mock=")) return import(resolvedId);
+		const filename = fileURLToPath(resolvedId);
+		const external = !isAbsolute(filename) || this.isModuleDirectory(resolvedId) ? normalizeModuleId(rawId) : null;
+		// file is not mocked, automock or redirect it
+		const redirect = this.findMockRedirect(filename, external);
+		if (redirect) return import(pathToFileURL(redirect).toString());
+		const url = new URL(resolvedId);
+		url.searchParams.set("mock", "automock");
+		return import(url.toString());
+	}
+}
+const replacePercentageRE = /%/g;
+function injectQuery(url, importer, queryToInject) {
+	const { search, hash } = new URL(url.replace(replacePercentageRE, "%25"), importer);
+	return `${cleanUrl(url)}?${queryToInject}${search ? `&${search.slice(1)}` : ""}${hash ?? ""}`;
+}
+let __require;
+function getBuiltinModule(moduleId) {
+	__require ??= module$1.createRequire(import.meta.url);
+	return __require(`${moduleId}?mock=actual`);
+}
+function genSourceMapUrl(map) {
+	if (typeof map !== "string") map = JSON.stringify(map);
+	return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
+}
+function transformCode(code, format, filename) {
+	if (format.includes("typescript")) {
+		if (!module$1.stripTypeScriptTypes) throw new Error(`Cannot parse '${filename}' because "module.stripTypeScriptTypes" is not supported. Module mocking requires Node.js 22.15 or higher. This is NOT a bug of Vitest.`);
+		return module$1.stripTypeScriptTypes(code);
+	}
+	return code;
+}
+
+export { NativeModuleMocker };

package/dist/chunks/nativeModuleRunner.BIakptoF.js

@@ -0,0 +1,36 @@
+import { pathToFileURL } from 'node:url';
+import { r as resolveModule } from './index.BCY_7LL2.js';
+import { resolve } from 'pathe';
+import { ModuleRunner } from 'vite/module-runner';
+
+class NativeModuleRunner extends ModuleRunner {
+	/**
+	* @internal
+	*/
+	mocker;
+	constructor(root, mocker) {
+		super({
+			hmr: false,
+			sourcemapInterceptor: false,
+			transport: { invoke() {
+				throw new Error("Unexpected `invoke`");
+			} }
+		});
+		this.root = root;
+		this.mocker = mocker;
+		if (mocker) Object.defineProperty(globalThis, "__vitest_mocker__", {
+			configurable: true,
+			writable: true,
+			value: mocker
+		});
+	}
+	async import(moduleId) {
+		const path = resolveModule(moduleId, { paths: [this.root] }) ?? resolve(this.root, moduleId);
+		// resolveModule doesn't keep the query params, so we need to add them back
+		let queryParams = "";
+		if (moduleId.includes("?") && !path.includes("?")) queryParams = moduleId.slice(moduleId.indexOf("?"));
+		return import(pathToFileURL(path + queryParams).toString());
+	}
+}
+
+export { NativeModuleRunner as N };

package/dist/chunks/{node.Ce0vMQM7.js → node.CrSEwhm4.js}

@@ -1,5 +1,5 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.DvEY5TfP.js';
+import { g as getWorkerState } from './utils.DT4VyRyl.js';
 import '@vitest/utils/timers';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {

package/dist/chunks/{plugin.d.CtqpEehP.d.ts → plugin.d.C9o5bttz.d.ts}

@@ -1,5 +1,5 @@
 import { DevEnvironment } from 'vite';
-import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.CWXNI2jG.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.7faYdkxy.js';
 
 /**
 * Generate a unique cache identifier.