vitest 4.0.0-beta.4 → 4.0.0-beta.5

package/dist/chunks/{execute.Dt-pCVcL.js → startModuleRunner.C8FtT_BY.js}

@@ -1,15 +1,86 @@
 import fs from 'node:fs';
+import { builtinModules, isBuiltin } from 'node:module';
+import { highlight, isBareImport } from '@vitest/utils';
 import { pathToFileURL } from 'node:url';
-import vm from 'node:vm';
-import { processError } from '@vitest/utils/error';
-import { normalize as normalize$1 } from 'pathe';
-import { ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
-import { isInternalRequest, isNodeBuiltin as isNodeBuiltin$1, isPrimitive, toFilePath } from 'vite-node/utils';
+import { normalize as normalize$1, join as join$1 } from 'pathe';
 import { distDir } from '../path.js';
+import { processError } from '@vitest/utils/error';
+import { VitestModuleEvaluator, unwrapId } from '../module-evaluator.js';
 import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
+import vm from 'node:vm';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
-import { builtinModules } from 'node:module';
-import { highlight } from '@vitest/utils';
+import { ModuleRunner } from 'vite/module-runner';
+import { V as VitestTransport } from './moduleTransport.I-bgQy0S.js';
+
+const bareVitestRegexp = /^@?vitest(?:\/|$)/;
+const normalizedDistDir = normalize$1(distDir);
+const relativeIds = {};
+const externalizeMap = /* @__PURE__ */ new Map();
+// all Vitest imports always need to be externalized
+function getCachedVitestImport(id, state) {
+	if (id.startsWith("/@fs/") || id.startsWith("\\@fs\\")) id = id.slice(process.platform === "win32" ? 5 : 4);
+	if (externalizeMap.has(id)) return {
+		externalize: externalizeMap.get(id),
+		type: "module"
+	};
+	// always externalize Vitest because we import from there before running tests
+	// so we already have it cached by Node.js
+	const root = state().config.root;
+	const relativeRoot = relativeIds[root] ?? (relativeIds[root] = normalizedDistDir.slice(root.length));
+	if (id.includes(distDir) || id.includes(normalizedDistDir)) {
+		const externalize = id.startsWith("file://") ? id : pathToFileURL(id).toString();
+		externalizeMap.set(id, externalize);
+		return {
+			externalize,
+			type: "module"
+		};
+	}
+	if (relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
+		const path = join$1(root, id);
+		const externalize = pathToFileURL(path).toString();
+		externalizeMap.set(id, externalize);
+		return {
+			externalize,
+			type: "module"
+		};
+	}
+	if (bareVitestRegexp.test(id)) {
+		externalizeMap.set(id, id);
+		return {
+			externalize: id,
+			type: "module"
+		};
+	}
+	return null;
+}
+
+const dispose = [];
+function listenForErrors(state) {
+	dispose.forEach((fn) => fn());
+	dispose.length = 0;
+	function catchError(err, type, event) {
+		const worker = state();
+		const listeners = process.listeners(event);
+		// if there is another listener, assume that it's handled by user code
+		// one is Vitest's own listener
+		if (listeners.length > 1) return;
+		const error = processError(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;
+			error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
+		}
+		state().rpc.onUnhandledError(error, type);
+	}
+	const uncaughtException = (e) => catchError(e, "Uncaught Exception", "uncaughtException");
+	const unhandledRejection = (e) => catchError(e, "Unhandled Rejection", "unhandledRejection");
+	process.on("uncaughtException", uncaughtException);
+	process.on("unhandledRejection", unhandledRejection);
+	dispose.push(() => {
+		process.off("uncaughtException", uncaughtException);
+		process.off("unhandledRejection", unhandledRejection);
+	});
+}
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -53,7 +124,7 @@ const join = function(...segments) {
 	}
 	return normalize(path);
 };
-function cwd() {
+function cwd$1() {
 	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
 	return "/";
 }
@@ -62,7 +133,7 @@ const resolve = function(...arguments_) {
 	let resolvedPath = "";
 	let resolvedAbsolute = false;
 	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-		const path = index >= 0 ? arguments_[index] : cwd();
+		const path = index >= 0 ? arguments_[index] : cwd$1();
 		if (!path || path.length === 0) continue;
 		resolvedPath = `${path}/${resolvedPath}`;
 		resolvedAbsolute = isAbsolute(path);
@@ -198,7 +269,7 @@ const builtins = new Set([
 	"wasi"
 ]);
 // https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
-const prefixedBuiltins = new Set([
+const prefixedBuiltins$1 = new Set([
 	"node:sea",
 	"node:sqlite",
 	"node:test",
@@ -206,7 +277,7 @@ const prefixedBuiltins = new Set([
 ]);
 const NODE_BUILTIN_NAMESPACE = "node:";
 function isNodeBuiltin(id) {
-	if (prefixedBuiltins.has(id)) return true;
+	if (prefixedBuiltins$1.has(id)) return true;
 	return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
 }
 
@@ -218,9 +289,10 @@ class VitestMocker {
 	filterPublicKeys;
 	registries = /* @__PURE__ */ new Map();
 	mockContext = { callstack: null };
-	constructor(executor) {
-		this.executor = executor;
-		const context = this.executor.options.context;
+	constructor(moduleRunner, options) {
+		this.moduleRunner = moduleRunner;
+		this.options = options;
+		const context = this.options.context;
 		if (context) this.primitives = vm.runInContext("({ Object, Error, Function, RegExp, Symbol, Array, Map })", context);
 		else this.primitives = {
 			Object,
@@ -250,16 +322,17 @@ class VitestMocker {
 		];
 	}
 	get root() {
-		return this.executor.options.root;
+		return this.options.root;
 	}
-	get moduleCache() {
-		return this.executor.moduleCache;
+	get evaluatedModules() {
+		return this.moduleRunner.evaluatedModules;
 	}
 	get moduleDirectories() {
-		return this.executor.options.moduleDirectories || [];
+		return this.options.moduleDirectories || [];
 	}
 	async initializeSpyModule() {
-		this.spyModule = await this.executor.executeId(spyModulePath);
+		if (this.spyModule) return;
+		this.spyModule = await this.moduleRunner.import(spyModulePath);
 	}
 	getMockerRegistry() {
 		const suite = this.getSuiteFilepath();
@@ -269,15 +342,19 @@ class VitestMocker {
 	reset() {
 		this.registries.clear();
 	}
-	deleteCachedItem(id) {
+	invalidateModuleById(id) {
 		const mockId = this.getMockPath(id);
-		if (this.moduleCache.has(mockId)) this.moduleCache.delete(mockId);
+		const node = this.evaluatedModules.getModuleById(mockId);
+		if (node) {
+			this.evaluatedModules.invalidateModule(node);
+			node.mockedExports = void 0;
+		}
 	}
 	isModuleDirectory(path) {
 		return this.moduleDirectories.some((dir) => path.includes(dir));
 	}
 	getSuiteFilepath() {
-		return this.executor.state.filepath || "global";
+		return this.options.getCurrentTestFilepath() || "global";
 	}
 	createError(message, codeFrame) {
 		const Error = this.primitives.Error;
@@ -285,40 +362,49 @@ class VitestMocker {
 		Object.assign(error, { codeFrame });
 		return error;
 	}
-	async resolvePath(rawId, importer) {
-		let id;
-		let fsPath;
-		try {
-			[id, fsPath] = await this.executor.originalResolveUrl(rawId, importer);
-		} catch (error) {
-			// it's allowed to mock unresolved modules
-			if (error.code === "ERR_MODULE_NOT_FOUND") {
-				const { id: unresolvedId } = error[Symbol.for("vitest.error.not_found.data")];
-				id = unresolvedId;
-				fsPath = unresolvedId;
-			} else throw error;
+	async resolveId(rawId, importer) {
+		const result = await this.options.resolveId(rawId, importer);
+		if (!result) {
+			const id = normalizeModuleId(rawId);
+			return {
+				id,
+				url: rawId,
+				external: id
+			};
 		}
 		// external is node_module or unresolved module
 		// for example, some people mock "vscode" and don't have it installed
-		const external = !isAbsolute$1(fsPath) || this.isModuleDirectory(fsPath) ? rawId : null;
+		const external = !isAbsolute$1(result.file) || this.isModuleDirectory(result.file) ? normalizeModuleId(rawId) : null;
 		return {
-			id,
-			fsPath,
-			external: external ? this.normalizePath(external) : external
+			...result,
+			id: normalizeModuleId(result.id),
+			external
 		};
 	}
 	async resolveMocks() {
 		if (!VitestMocker.pendingIds.length) return;
 		await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
-			const { fsPath, external } = await this.resolvePath(mock.id, mock.importer);
-			if (mock.action === "unmock") this.unmockPath(fsPath);
-			if (mock.action === "mock") this.mockPath(mock.id, fsPath, external, mock.type, mock.factory);
+			const { id, url, external } = await this.resolveId(mock.id, mock.importer);
+			if (mock.action === "unmock") this.unmockPath(id);
+			if (mock.action === "mock") this.mockPath(mock.id, id, url, external, mock.type, mock.factory);
 		}));
 		VitestMocker.pendingIds = [];
 	}
-	async callFunctionMock(dep, mock) {
-		const cached = this.moduleCache.get(dep)?.exports;
-		if (cached) return cached;
+	ensureModule(id, url) {
+		const node = this.evaluatedModules.ensureModule(id, url);
+		// TODO
+		node.meta = {
+			id,
+			url,
+			code: "",
+			file: null,
+			invalidate: false
+		};
+		return node;
+	}
+	async callFunctionMock(id, url, mock) {
+		const node = this.ensureModule(id, url);
+		if (node.exports) return node.exports;
 		const exports = await mock.resolve();
 		const moduleExports = new Proxy(exports, { get: (target, prop) => {
 			const val = target[prop];
@@ -339,7 +425,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			}
 			return val;
 		} });
-		this.moduleCache.set(dep, { exports: moduleExports });
+		node.exports = moduleExports;
 		return moduleExports;
 	}
 	// public method to avoid circular dependency
@@ -352,12 +438,9 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 	}
 	getDependencyMock(id) {
 		const registry = this.getMockerRegistry();
-		return registry.get(id);
-	}
-	normalizePath(path) {
-		return this.moduleCache.normalizePath(path);
+		return registry.getById(fixLeadingSlashes(id));
 	}
-	resolveMockPath(mockPath, external) {
+	findMockRedirect(mockPath, external) {
 		return findMockRedirect(this.root, mockPath, external);
 	}
 	mockObject(object, mockExports = {}, behavior = "automock") {
@@ -369,75 +452,88 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			type: behavior
 		}, object, mockExports);
 	}
-	unmockPath(path) {
+	unmockPath(id) {
 		const registry = this.getMockerRegistry();
-		const id = this.normalizePath(path);
-		registry.delete(id);
-		this.deleteCachedItem(id);
+		registry.deleteById(id);
+		this.invalidateModuleById(id);
 	}
-	mockPath(originalId, path, external, mockType, factory) {
+	mockPath(originalId, id, url, external, mockType, factory) {
 		const registry = this.getMockerRegistry();
-		const id = this.normalizePath(path);
-		if (mockType === "manual") registry.register("manual", originalId, id, id, factory);
-		else if (mockType === "autospy") registry.register("autospy", originalId, id, id);
+		if (mockType === "manual") registry.register("manual", originalId, id, url, factory);
+		else if (mockType === "autospy") registry.register("autospy", originalId, id, url);
 		else {
-			const redirect = this.resolveMockPath(id, external);
-			if (redirect) registry.register("redirect", originalId, id, id, redirect);
-			else registry.register("automock", originalId, id, id);
+			const redirect = this.findMockRedirect(id, external);
+			if (redirect) registry.register("redirect", originalId, id, url, redirect);
+			else registry.register("automock", originalId, id, url);
 		}
 		// every time the mock is registered, we remove the previous one from the cache
-		this.deleteCachedItem(id);
+		this.invalidateModuleById(id);
 	}
 	async importActual(rawId, importer, callstack) {
-		const { id, fsPath } = await this.resolvePath(rawId, importer);
-		const result = await this.executor.cachedRequest(id, fsPath, callstack || [importer]);
+		const { url } = await this.resolveId(rawId, importer);
+		const node = await this.moduleRunner.fetchModule(url, importer);
+		const result = await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
 		return result;
 	}
-	async importMock(rawId, importee) {
-		const { id, fsPath, external } = await this.resolvePath(rawId, importee);
-		const normalizedId = this.normalizePath(fsPath);
-		let mock = this.getDependencyMock(normalizedId);
+	async importMock(rawId, importer) {
+		const { id, url, external } = await this.resolveId(rawId, importer);
+		let mock = this.getDependencyMock(id);
 		if (!mock) {
-			const redirect = this.resolveMockPath(normalizedId, external);
-			if (redirect) mock = new RedirectedModule(rawId, normalizedId, normalizedId, redirect);
-			else mock = new AutomockedModule(rawId, normalizedId, normalizedId);
+			const redirect = this.findMockRedirect(id, external);
+			if (redirect) mock = new RedirectedModule(rawId, id, rawId, redirect);
+			else mock = new AutomockedModule(rawId, id, rawId);
 		}
 		if (mock.type === "automock" || mock.type === "autospy") {
-			const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
-			return this.mockObject(mod, {}, mock.type);
+			const node = await this.moduleRunner.fetchModule(url, importer);
+			const mod = await this.moduleRunner.cachedRequest(url, node, [importer], void 0, true);
+			const Object = this.primitives.Object;
+			return this.mockObject(mod, Object.create(Object.prototype), mock.type);
 		}
-		if (mock.type === "manual") return this.callFunctionMock(fsPath, mock);
-		return this.executor.dependencyRequest(mock.redirect, mock.redirect, [importee]);
+		if (mock.type === "manual") return this.callFunctionMock(id, url, mock);
+		const node = await this.moduleRunner.fetchModule(mock.redirect);
+		return this.moduleRunner.cachedRequest(mock.redirect, node, [importer], void 0, true);
 	}
-	async requestWithMock(url, callstack) {
-		const id = this.normalizePath(url);
-		const mock = this.getDependencyMock(id);
-		if (!mock) return;
-		const mockPath = this.getMockPath(id);
+	async requestWithMockedModule(url, evaluatedNode, callstack, mock) {
+		const mockId = this.getMockPath(evaluatedNode.id);
 		if (mock.type === "automock" || mock.type === "autospy") {
-			const cache = this.moduleCache.get(mockPath);
-			if (cache.exports) return cache.exports;
-			const exports = {};
-			// Assign the empty exports object early to allow for cycles to work. The object will be filled by mockObject()
-			this.moduleCache.set(mockPath, { exports });
-			const mod = await this.executor.directRequest(url, url, callstack);
+			const cache = this.evaluatedModules.getModuleById(mockId);
+			if (cache && cache.mockedExports) return cache.mockedExports;
+			const Object = this.primitives.Object;
+			// we have to define a separate object that will copy all properties into itself
+			// and can't just use the same `exports` define automatically by Vite before the evaluator
+			const exports = Object.create(null);
+			Object.defineProperty(exports, Symbol.toStringTag, {
+				value: "Module",
+				configurable: true,
+				writable: true
+			});
+			const node = this.ensureModule(mockId, this.getMockPath(evaluatedNode.url));
+			node.meta = evaluatedNode.meta;
+			node.file = evaluatedNode.file;
+			node.mockedExports = exports;
+			const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
 			this.mockObject(mod, exports, mock.type);
 			return exports;
 		}
-		if (mock.type === "manual" && !callstack.includes(mockPath) && !callstack.includes(url)) try {
-			callstack.push(mockPath);
+		if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url)) try {
+			callstack.push(mockId);
 			// this will not work if user does Promise.all(import(), import())
 			// we can also use AsyncLocalStorage to store callstack, but this won't work in the browser
 			// maybe we should improve mock API in the future?
 			this.mockContext.callstack = callstack;
-			return await this.callFunctionMock(mockPath, mock);
+			return await this.callFunctionMock(mockId, this.getMockPath(url), mock);
 		} finally {
 			this.mockContext.callstack = null;
-			const indexMock = callstack.indexOf(mockPath);
+			const indexMock = callstack.indexOf(mockId);
 			callstack.splice(indexMock, 1);
 		}
 		else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) return mock.redirect;
 	}
+	async mockedRequest(url, evaluatedNode, callstack) {
+		const mock = this.getDependencyMock(evaluatedNode.id);
+		if (!mock) return;
+		return this.requestWithMockedModule(url, evaluatedNode, callstack, mock);
+	}
 	queueMock(id, importer, factoryOrOptions) {
 		const mockType = getMockType(factoryOrOptions);
 		VitestMocker.pendingIds.push({
@@ -461,248 +557,221 @@ function getMockType(factoryOrOptions) {
 	if (typeof factoryOrOptions === "function") return "manual";
 	return factoryOrOptions.spy ? "autospy" : "automock";
 }
-
-const normalizedDistDir = normalize$1(distDir);
-const { readFileSync } = fs;
-async function createVitestExecutor(options) {
-	const runner = new VitestExecutor(options);
-	await runner.executeId("/@vite/env");
-	await runner.mocker.initializeSpyModule();
-	return runner;
+// unique id that is not available as "$bare_import" like "test"
+// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
+const prefixedBuiltins = new Set([
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters"
+]);
+const isWindows$1 = process.platform === "win32";
+// transform file url to id
+// virtual:custom -> virtual:custom
+// \0custom -> \0custom
+// /root/id -> /id
+// /root/id.js -> /id.js
+// C:/root/id.js -> /id.js
+// C:\root\id.js -> /id.js
+// TODO: expose this in vite/module-runner
+function normalizeModuleId(file) {
+	if (prefixedBuiltins.has(file)) return file;
+	// unix style, but Windows path still starts with the drive letter to check the root
+	const unixFile = slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
+	// if it's not in the root, keep it as a path, not a URL
+	return unixFile.replace(/^file:\//, "/");
 }
-const externalizeMap = /* @__PURE__ */ new Map();
-const bareVitestRegexp = /^@?vitest(?:\/|$)/;
-const dispose = [];
-function listenForErrors(state) {
-	dispose.forEach((fn) => fn());
-	dispose.length = 0;
-	function catchError(err, type, event) {
-		const worker = state();
-		const listeners = process.listeners(event);
-		// if there is another listener, assume that it's handled by user code
-		// one is Vitest's own listener
-		if (listeners.length > 1) return;
-		const error = processError(err);
-		if (!isPrimitive(error)) {
-			error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0;
-			if (worker.filepath) error.VITEST_TEST_PATH = worker.filepath;
-			error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
-		}
-		state().rpc.onUnhandledError(error, type);
-	}
-	const uncaughtException = (e) => catchError(e, "Uncaught Exception", "uncaughtException");
-	const unhandledRejection = (e) => catchError(e, "Unhandled Rejection", "unhandledRejection");
-	process.on("uncaughtException", uncaughtException);
-	process.on("unhandledRejection", unhandledRejection);
-	dispose.push(() => {
-		process.off("uncaughtException", uncaughtException);
-		process.off("unhandledRejection", unhandledRejection);
-	});
+const windowsSlashRE = /\\/g;
+function slash(p) {
+	return p.replace(windowsSlashRE, "/");
 }
-const relativeIds = {};
-function getVitestImport(id, state) {
-	if (externalizeMap.has(id)) return { externalize: externalizeMap.get(id) };
-	// always externalize Vitest because we import from there before running tests
-	// so we already have it cached by Node.js
-	const root = state().config.root;
-	const relativeRoot = relativeIds[root] ?? (relativeIds[root] = normalizedDistDir.slice(root.length));
-	if (id.includes(distDir) || id.includes(normalizedDistDir) || relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
-		const { path } = toFilePath(id, root);
-		const externalize = pathToFileURL(path).toString();
-		externalizeMap.set(id, externalize);
-		return { externalize };
+const multipleSlashRe = /^\/+/;
+// module-runner incorrectly replaces file:///path with `///path`
+function fixLeadingSlashes(id) {
+	if (id.startsWith("//")) return id.replace(multipleSlashRe, "/");
+	return id;
+}
+
+// @ts-expect-error overriding private method
+class VitestModuleRunner extends ModuleRunner {
+	mocker;
+	moduleExecutionInfo;
+	constructor(options) {
+		const transport = new VitestTransport(options.transport);
+		const evaluatedModules = options.evaluatedModules;
+		super({
+			transport,
+			hmr: false,
+			evaluatedModules,
+			sourcemapInterceptor: "prepareStackTrace"
+		}, options.evaluator);
+		this.options = options;
+		this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo;
+		this.mocker = options.mocker || new VitestMocker(this, {
+			context: options.vm?.context,
+			resolveId: options.transport.resolveId,
+			get root() {
+				return options.getWorkerState().config.root;
+			},
+			get moduleDirectories() {
+				return options.getWorkerState().config.deps.moduleDirectories || [];
+			},
+			getCurrentTestFilepath() {
+				return options.getWorkerState().filepath;
+			}
+		});
+		if (options.vm) options.vm.context.__vitest_mocker__ = this.mocker;
+		else Object.defineProperty(globalThis, "__vitest_mocker__", {
+			configurable: true,
+			writable: true,
+			value: this.mocker
+		});
 	}
-	if (bareVitestRegexp.test(id)) {
-		externalizeMap.set(id, id);
-		return { externalize: id };
+	async import(rawId) {
+		const resolved = await this.options.transport.resolveId(rawId);
+		if (!resolved) return super.import(rawId);
+		return super.import(resolved.url);
+	}
+	async fetchModule(url, importer) {
+		const module = await this.cachedModule(url, importer);
+		return module;
+	}
+	_cachedRequest(url, module, callstack = [], metadata) {
+		// @ts-expect-error "cachedRequest" is private
+		return super.cachedRequest(url, module, callstack, metadata);
+	}
+	/**
+	* @internal
+	*/
+	async cachedRequest(url, mod, callstack = [], metadata, ignoreMock = false) {
+		if (ignoreMock) return this._cachedRequest(url, mod, callstack, metadata);
+		let mocked;
+		if (mod.meta && "mockedModule" in mod.meta) mocked = await this.mocker.requestWithMockedModule(url, mod, callstack, mod.meta.mockedModule);
+		else mocked = await this.mocker.mockedRequest(url, mod, callstack);
+		if (typeof mocked === "string") {
+			const node = await this.fetchModule(mocked);
+			return this._cachedRequest(mocked, node, callstack, metadata);
+		}
+		if (mocked != null && typeof mocked === "object") return mocked;
+		return this._cachedRequest(url, mod, callstack, metadata);
+	}
+	/** @internal */
+	_invalidateSubTreeById(ids, invalidated = /* @__PURE__ */ new Set()) {
+		for (const id of ids) {
+			if (invalidated.has(id)) continue;
+			const node = this.evaluatedModules.getModuleById(id);
+			if (!node) continue;
+			invalidated.add(id);
+			const subIds = Array.from(this.evaluatedModules.idToModuleMap).filter(([, mod]) => mod.importers.has(id)).map(([key]) => key);
+			if (subIds.length) this._invalidateSubTreeById(subIds, invalidated);
+			this.evaluatedModules.invalidateModule(node);
+		}
 	}
-	return null;
 }
-async function startVitestExecutor(options) {
+
+const { readFileSync } = fs;
+const browserExternalId = "__vite-browser-external";
+const browserExternalLength = 24;
+const VITEST_VM_CONTEXT_SYMBOL = "__vitest_vm_context__";
+const cwd = process.cwd();
+const isWindows = process.platform === "win32";
+async function startVitestModuleRunner(options) {
 	const state = () => globalThis.__vitest_worker__ || options.state;
 	const rpc = () => state().rpc;
 	process.exit = (code = process.exitCode || 0) => {
 		throw new Error(`process.exit unexpectedly called with "${code}"`);
 	};
 	listenForErrors(state);
-	const getTransformMode = () => {
-		return state().environment.transformMode ?? "ssr";
+	const environment = () => {
+		const environment = state().environment;
+		return environment.viteEnvironment || environment.name;
 	};
-	return await createVitestExecutor({
-		async fetchModule(id) {
-			const vitest = getVitestImport(id, state);
-			if (vitest) return vitest;
-			const result = await rpc().fetch(id, getTransformMode());
-			if (result.id && !result.externalize) {
-				const code = readFileSync(result.id, "utf-8");
-				return { code };
-			}
-			return result;
-		},
-		resolveId(id, importer) {
-			return rpc().resolveId(id, importer, getTransformMode());
-		},
-		get moduleCache() {
-			return state().moduleCache;
-		},
+	const vm = options.context && options.externalModulesExecutor ? {
+		context: options.context,
+		externalModulesExecutor: options.externalModulesExecutor
+	} : void 0;
+	const evaluator = options.evaluator || new VitestModuleEvaluator(vm, {
 		get moduleExecutionInfo() {
 			return state().moduleExecutionInfo;
 		},
 		get interopDefault() {
 			return state().config.deps.interopDefault;
 		},
-		get moduleDirectories() {
-			return state().config.deps.moduleDirectories;
-		},
-		get root() {
-			return state().config.root;
-		},
-		get base() {
-			return state().config.base;
+		getCurrentTestFilepath: () => state().filepath
+	});
+	const moduleRunner = new VitestModuleRunner({
+		evaluatedModules: options.evaluatedModules,
+		evaluator,
+		mocker: options.mocker,
+		transport: {
+			async fetchModule(id, importer, options) {
+				const resolvingModules = state().resolvingModules;
+				if (isWindows) {
+					if (id[1] === ":") {
+						// The drive letter is different for whatever reason, we need to normalize it to CWD
+						if (id[0] !== cwd[0] && id[0].toUpperCase() === cwd[0].toUpperCase()) {
+							const isUpperCase = cwd[0].toUpperCase() === cwd[0];
+							id = (isUpperCase ? id[0].toUpperCase() : id[0].toLowerCase()) + id.slice(1);
+						}
+						// always mark absolute windows paths, otherwise Vite will externalize it
+						id = `/@id/${id}`;
+					}
+				}
+				const vitest = getCachedVitestImport(id, state);
+				if (vitest) return vitest;
+				const rawId = unwrapId(id);
+				resolvingModules.add(rawId);
+				try {
+					if (VitestMocker.pendingIds.length) await moduleRunner.mocker.resolveMocks();
+					const resolvedMock = moduleRunner.mocker.getDependencyMock(rawId);
+					if (resolvedMock?.type === "manual" || resolvedMock?.type === "redirect") return {
+						code: "",
+						file: null,
+						id,
+						url: id,
+						invalidate: false,
+						mockedModule: resolvedMock
+					};
+					if (isBuiltin(rawId) || rawId.startsWith(browserExternalId)) return {
+						externalize: toBuiltin(rawId),
+						type: "builtin"
+					};
+					const result = await rpc().fetch(id, importer, environment(), options);
+					if ("cached" in result) {
+						const code = readFileSync(result.tmp, "utf-8");
+						return {
+							code,
+							...result
+						};
+					}
+					return result;
+				} catch (cause) {
+					// rethrow vite error if it cannot load the module because it's not resolved
+					if (typeof cause === "object" && cause != null && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url") || typeof cause?.message === "string" && cause.message.startsWith("Cannot find module '")) {
+						const error = new Error(`Cannot find ${isBareImport(id) ? "package" : "module"} '${id}'${importer ? ` imported from '${importer}'` : ""}`, { cause });
+						error.code = "ERR_MODULE_NOT_FOUND";
+						throw error;
+					}
+					throw cause;
+				} finally {
+					resolvingModules.delete(rawId);
+				}
+			},
+			resolveId(id, importer) {
+				return rpc().resolve(id, importer, environment());
+			}
 		},
-		...options
+		getWorkerState: state,
+		vm
 	});
+	await moduleRunner.import("/@vite/env");
+	await moduleRunner.mocker.initializeSpyModule();
+	return moduleRunner;
 }
-function updateStyle(id, css) {
-	if (typeof document === "undefined") return;
-	const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
-	if (element) {
-		element.textContent = css;
-		return;
-	}
-	const head = document.querySelector("head");
-	const style = document.createElement("style");
-	style.setAttribute("type", "text/css");
-	style.setAttribute("data-vite-dev-id", id);
-	style.textContent = css;
-	head?.appendChild(style);
-}
-function removeStyle(id) {
-	if (typeof document === "undefined") return;
-	const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
-	if (sheet) document.head.removeChild(sheet);
-}
-function getDefaultRequestStubs(context) {
-	if (!context) {
-		const clientStub = {
-			...DEFAULT_REQUEST_STUBS["@vite/client"],
-			updateStyle,
-			removeStyle
-		};
-		return {
-			"/@vite/client": clientStub,
-			"@vite/client": clientStub
-		};
-	}
-	const clientStub = vm.runInContext(`(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`, context)(DEFAULT_REQUEST_STUBS["@vite/client"]);
-	return {
-		"/@vite/client": clientStub,
-		"@vite/client": clientStub
-	};
-}
-class VitestExecutor extends ViteNodeRunner {
-	mocker;
-	externalModules;
-	primitives;
-	constructor(options) {
-		super({
-			...options,
-			interopDefault: options.context ? false : options.interopDefault
-		});
-		this.options = options;
-		this.mocker = new VitestMocker(this);
-		if (!options.context) {
-			Object.defineProperty(globalThis, "__vitest_mocker__", {
-				value: this.mocker,
-				writable: true,
-				configurable: true
-			});
-			this.primitives = {
-				Object,
-				Reflect,
-				Symbol
-			};
-		} else if (options.externalModulesExecutor) {
-			this.primitives = vm.runInContext("({ Object, Reflect, Symbol })", options.context);
-			this.externalModules = options.externalModulesExecutor;
-		} else throw new Error("When context is provided, externalModulesExecutor must be provided as well.");
-	}
-	getContextPrimitives() {
-		return this.primitives;
-	}
-	get state() {
-		// @ts-expect-error injected untyped global
-		return globalThis.__vitest_worker__ || this.options.state;
-	}
-	get moduleExecutionInfo() {
-		return this.options.moduleExecutionInfo;
-	}
-	shouldResolveId(id, _importee) {
-		if (isInternalRequest(id) || id.startsWith("data:")) return false;
-		const transformMode = this.state.environment?.transformMode ?? "ssr";
-		// do not try and resolve node builtins in Node
-		// import('url') returns Node internal even if 'url' package is installed
-		return transformMode === "ssr" ? !isNodeBuiltin$1(id) : !id.startsWith("node:");
-	}
-	async originalResolveUrl(id, importer) {
-		return super.resolveUrl(id, importer);
-	}
-	async resolveUrl(id, importer) {
-		if (VitestMocker.pendingIds.length) await this.mocker.resolveMocks();
-		if (importer && importer.startsWith("mock:")) importer = importer.slice(5);
-		try {
-			return await super.resolveUrl(id, importer);
-		} catch (error) {
-			if (error.code === "ERR_MODULE_NOT_FOUND") {
-				const { id } = error[Symbol.for("vitest.error.not_found.data")];
-				const path = this.mocker.normalizePath(id);
-				const mock = this.mocker.getDependencyMock(path);
-				if (mock !== void 0) return [id, id];
-			}
-			throw error;
-		}
-	}
-	async runModule(context, transformed) {
-		const vmContext = this.options.context;
-		if (!vmContext || !this.externalModules) return super.runModule(context, transformed);
-		// add 'use strict' since ESM enables it by default
-		const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
-		const code = `${codeDefinition}${transformed}\n}}`;
-		const options = {
-			filename: context.__filename,
-			lineOffset: 0,
-			columnOffset: -codeDefinition.length
-		};
-		const finishModuleExecutionInfo = this.startCalculateModuleExecutionInfo(options.filename, codeDefinition.length);
-		try {
-			const fn = vm.runInContext(code, vmContext, {
-				...options,
-				importModuleDynamically: this.externalModules.importModuleDynamically
-			});
-			await fn(...Object.values(context));
-		} finally {
-			this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
-		}
-	}
-	async importExternalModule(path) {
-		if (this.externalModules) return this.externalModules.import(path);
-		return super.importExternalModule(path);
-	}
-	async dependencyRequest(id, fsPath, callstack) {
-		const mocked = await this.mocker.requestWithMock(fsPath, callstack);
-		if (typeof mocked === "string") return super.dependencyRequest(mocked, mocked, callstack);
-		if (mocked && typeof mocked === "object") return mocked;
-		return super.dependencyRequest(id, fsPath, callstack);
-	}
-	prepareContext(context) {
-		// support `import.meta.vitest` for test entry
-		if (this.state.filepath && normalize$1(this.state.filepath) === normalize$1(context.__filename)) {
-			const globalNamespace = this.options.context || globalThis;
-			Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalNamespace.__vitest_index__ });
-		}
-		if (this.options.context && this.externalModules) context.require = this.externalModules.createRequire(context.__filename);
-		return context;
-	}
+function toBuiltin(id) {
+	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);
+	if (!id.startsWith("node:")) id = `node:${id}`;
+	return id;
 }
 
-export { VitestExecutor as V, getDefaultRequestStubs as g, startVitestExecutor as s };
+export { VitestModuleRunner as V, VITEST_VM_CONTEXT_SYMBOL as a, startVitestModuleRunner as s };