vitest 4.0.6 → 4.0.8

package/dist/chunks/{startModuleRunner.Di-EZqh0.js → startModuleRunner.BOmUtLIO.js}

@@ -11,24 +11,62 @@ import vm from 'node:vm';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
 import * as viteModuleRunner from 'vite/module-runner';
 
+class VitestTransport {
+	constructor(options) {
+		this.options = options;
+	}
+	async invoke(event) {
+		if (event.type !== "custom") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support Vite HMR events.`) };
+		if (event.event !== "vite:invoke") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support ${event.event} event.`) };
+		const { name, data } = event.data;
+		if (name === "getBuiltins")
+ // we return an empty array here to avoid client-side builtin check,
+		// as we need builtins to go through `fetchModule`
+		return { result: [] };
+		if (name !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
+		try {
+			return { result: await this.options.fetchModule(...data) };
+		} catch (error) {
+			return { error };
+		}
+	}
+}
+
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
-	return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
-const _UNC_REGEX = /^[/\\]{2}/, _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, _DRIVE_LETTER_RE = /^[A-Za-z]:$/, _EXTNAME_RE = /.(\.[^./]+|\.)$/, normalize = function(path) {
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const normalize = function(path) {
 	if (path.length === 0) return ".";
 	path = normalizeWindowsPath(path);
-	const isUNCPath = path.match(_UNC_REGEX), isPathAbsolute = isAbsolute(path), trailingSeparator = path[path.length - 1] === "/";
-	if (path = normalizeString(path, !isPathAbsolute), path.length === 0) return isPathAbsolute ? "/" : trailingSeparator ? "./" : ".";
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
 	if (trailingSeparator) path += "/";
 	if (_DRIVE_LETTER_RE.test(path)) path += "/";
-	return isUNCPath ? isPathAbsolute ? `//${path}` : `//./${path}` : isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-}, join = function(...segments) {
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
 	let path = "";
 	for (const seg of segments) {
 		if (!seg) continue;
 		if (path.length > 0) {
-			const pathTrailing = path[path.length - 1] === "/", segLeading = seg[0] === "/";
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
 			if (pathTrailing && segLeading) path += seg.slice(1);
 			else path += pathTrailing || segLeading ? seg : `/${seg}`;
 		} else path += seg;
@@ -36,19 +74,29 @@ const _UNC_REGEX = /^[/\\]{2}/, _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\
 	return normalize(path);
 };
 function cwd$1() {
-	return typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd().replace(/\\/g, "/") : "/";
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
 }
 const resolve = function(...arguments_) {
 	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-	let resolvedPath = "", resolvedAbsolute = false;
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
 	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
 		const path = index >= 0 ? arguments_[index] : cwd$1();
-		!path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute(path));
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
 	}
-	return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
 };
 function normalizeString(path, allowAboveRoot) {
-	let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
 	for (let index = 0; index <= path.length; ++index) {
 		if (index < path.length) char = path[index];
 		else if (char === "/") break;
@@ -59,22 +107,35 @@ function normalizeString(path, allowAboveRoot) {
 				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
 					if (res.length > 2) {
 						const lastSlashIndex = res.lastIndexOf("/");
-						if (lastSlashIndex === -1) res = "", lastSegmentLength = 0;
-						else res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-						lastSlash = index, dots = 0;
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
 						continue;
 					} else if (res.length > 0) {
-						res = "", lastSegmentLength = 0, lastSlash = index, dots = 0;
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
 						continue;
 					}
 				}
-				if (allowAboveRoot) res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2;
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
 			} else {
 				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
 				else res = path.slice(lastSlash + 1, index);
 				lastSegmentLength = index - lastSlash - 1;
 			}
-			lastSlash = index, dots = 0;
+			lastSlash = index;
+			dots = 0;
 		} else if (char === "." && dots !== -1) ++dots;
 		else dots = -1;
 	}
@@ -82,15 +143,18 @@ function normalizeString(path, allowAboveRoot) {
 }
 const isAbsolute = function(p) {
 	return _IS_ABSOLUTE_RE.test(p);
-}, extname = function(p) {
+};
+const extname = function(p) {
 	if (p === "..") return "";
 	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
 	return match && match[1] || "";
-}, dirname = function(p) {
+};
+const dirname = function(p) {
 	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
 	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
 	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
-}, basename = function(p, extension) {
+};
+const basename = function(p, extension) {
 	const segments = normalizeWindowsPath(p).split("/");
 	let lastSegment = "";
 	for (let i = segments.length - 1; i >= 0; i--) {
@@ -109,7 +173,7 @@ function findMockRedirect(root, mockPath, external) {
 	// it's a node_module alias
 	// all mocks should be inside <root>/__mocks__
 	if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
-		const mockDirname = dirname(path), mockFolder = join(root, "__mocks__", mockDirname);
+		const mockFolder = join(root, "__mocks__", dirname(path));
 		if (!existsSync(mockFolder)) return null;
 		const baseOriginal = basename(path);
 		function findFile(mockFolder, baseOriginal) {
@@ -118,7 +182,7 @@ function findMockRedirect(root, mockPath, external) {
 				const path = resolve(mockFolder, file);
 				// if the same name, return the file
 				if (statSync(path).isFile()) return path;
-				{
+				else {
 					// find folder/index.{js,ts}
 					const indexFile = findFile(path, "index");
 					if (indexFile) return indexFile;
@@ -128,7 +192,7 @@ function findMockRedirect(root, mockPath, external) {
 		}
 		return findFile(mockFolder, baseOriginal);
 	}
-	const dir = dirname(path), baseId = basename(path), fullPath = resolve(dir, "__mocks__", baseId);
+	const fullPath = resolve(dirname(path), "__mocks__", basename(path));
 	return existsSync(fullPath) ? fullPath : null;
 }
 const builtins = new Set([
@@ -146,14 +210,20 @@ const builtins = new Set([
 	"timers/promises",
 	"util/types",
 	"wasi"
-]), prefixedBuiltins$1 = new Set([
+]);
+// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
+const prefixedBuiltins$1 = new Set([
 	"node:sea",
 	"node:sqlite",
 	"node:test",
 	"node:test/reporters"
-]), NODE_BUILTIN_NAMESPACE = "node:";
+]);
+const NODE_BUILTIN_NAMESPACE = "node:";
 function isNodeBuiltin(id) {
-	return nodeModule.isBuiltin ? nodeModule.isBuiltin(id) : prefixedBuiltins$1.has(id) ? true : builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
+	// Added in v18.6.0
+	if (nodeModule.isBuiltin) return nodeModule.isBuiltin(id);
+	if (prefixedBuiltins$1.has(id)) return true;
+	return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
 }
 
 const spyModulePath = resolve$1(distDir, "spy.js");
@@ -165,7 +235,8 @@ class VitestMocker {
 	registries = /* @__PURE__ */ new Map();
 	mockContext = { callstack: null };
 	constructor(moduleRunner, options) {
-		this.moduleRunner = moduleRunner, this.options = 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 = {
@@ -206,7 +277,8 @@ class VitestMocker {
 		return this.options.moduleDirectories || [];
 	}
 	async initializeSpyModule() {
-		this.spyModule ||= await this.moduleRunner.import(spyModulePath);
+		if (this.spyModule) return;
+		this.spyModule = await this.moduleRunner.import(spyModulePath);
 	}
 	getMockerRegistry() {
 		const suite = this.getSuiteFilepath();
@@ -217,8 +289,12 @@ class VitestMocker {
 		this.registries.clear();
 	}
 	invalidateModuleById(id) {
-		const mockId = this.getMockPath(id), node = this.evaluatedModules.getModuleById(mockId);
-		if (node) this.evaluatedModules.invalidateModule(node), node.mockedExports = void 0;
+		const mockId = this.getMockPath(id);
+		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));
@@ -227,8 +303,10 @@ class VitestMocker {
 		return this.options.getCurrentTestFilepath() || "global";
 	}
 	createError(message, codeFrame) {
-		const Error = this.primitives.Error, error = new Error(message);
-		return Object.assign(error, { codeFrame }), error;
+		const Error = this.primitives.Error;
+		const error = new Error(message);
+		Object.assign(error, { codeFrame });
+		return error;
 	}
 	async resolveId(rawId, importer) {
 		const result = await this.options.resolveId(rawId, importer);
@@ -250,26 +328,31 @@ class VitestMocker {
 		};
 	}
 	async resolveMocks() {
-		VitestMocker.pendingIds.length && (await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
+		if (!VitestMocker.pendingIds.length) return;
+		await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
 			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 = []);
+		}));
+		VitestMocker.pendingIds = [];
 	}
 	ensureModule(id, url) {
 		const node = this.evaluatedModules.ensureModule(id, url);
-		return node.meta = {
+		// TODO
+		node.meta = {
 			id,
 			url,
 			code: "",
 			file: null,
 			invalidate: false
-		}, node;
+		};
+		return node;
 	}
 	async callFunctionMock(id, url, mock) {
 		const node = this.ensureModule(id, url);
 		if (node.exports) return node.exports;
-		const exports = await mock.resolve(), moduleExports = new Proxy(exports, { get: (target, prop) => {
+		const exports = await mock.resolve();
+		const moduleExports = new Proxy(exports, { get: (target, prop) => {
 			const val = target[prop];
 			// 'then' can exist on non-Promise objects, need nested instanceof check for logic to work
 			if (prop === "then") {
@@ -288,7 +371,8 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			}
 			return val;
 		} });
-		return node.exports = moduleExports, moduleExports;
+		node.exports = moduleExports;
+		return moduleExports;
 	}
 	// public method to avoid circular dependency
 	getMockContext() {
@@ -314,7 +398,8 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		}, object, mockExports);
 	}
 	unmockPath(id) {
-		this.getMockerRegistry().deleteById(id), this.invalidateModuleById(id);
+		this.getMockerRegistry().deleteById(id);
+		this.invalidateModuleById(id);
 	}
 	mockPath(originalId, id, url, external, mockType, factory) {
 		const registry = this.getMockerRegistry();
@@ -329,7 +414,8 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		this.invalidateModuleById(id);
 	}
 	async importActual(rawId, importer, callstack) {
-		const { url } = await this.resolveId(rawId, importer), node = await this.moduleRunner.fetchModule(url, importer);
+		const { url } = await this.resolveId(rawId, importer);
+		const node = await this.moduleRunner.fetchModule(url, importer);
 		return await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
 	}
 	async importMock(rawId, importer) {
@@ -341,7 +427,9 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			else mock = new AutomockedModule(rawId, id, rawId);
 		}
 		if (mock.type === "automock" || mock.type === "autospy") {
-			const node = await this.moduleRunner.fetchModule(url, importer), mod = await this.moduleRunner.cachedRequest(url, node, [importer], void 0, true), Object = this.primitives.Object;
+			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(id, url, mock);
@@ -353,19 +441,30 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		if (mock.type === "automock" || mock.type === "autospy") {
 			const cache = this.evaluatedModules.getModuleById(mockId);
 			if (cache && cache.mockedExports) return cache.mockedExports;
-			const Object = this.primitives.Object, exports = Object.create(null);
+			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;
+			node.meta = evaluatedNode.meta;
+			node.file = evaluatedNode.file;
+			node.mockedExports = exports;
 			const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
-			return this.mockObject(mod, exports, mock.type), exports;
+			this.mockObject(mod, exports, mock.type);
+			return exports;
 		}
 		if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url)) try {
-			return callstack.push(mockId), this.mockContext.callstack = callstack, await this.callFunctionMock(mockId, this.getMockPath(url), mock);
+			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(mockId, this.getMockPath(url), mock);
 		} finally {
 			this.mockContext.callstack = null;
 			const indexMock = callstack.indexOf(mockId);
@@ -375,7 +474,8 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 	}
 	async mockedRequest(url, evaluatedNode, callstack) {
 		const mock = this.getDependencyMock(evaluatedNode.id);
-		if (mock) return this.requestWithMockedModule(url, evaluatedNode, callstack, mock);
+		if (!mock) return;
+		return this.requestWithMockedModule(url, evaluatedNode, callstack, mock);
 	}
 	queueMock(id, importer, factoryOrOptions) {
 		const mockType = getMockType(factoryOrOptions);
@@ -396,7 +496,9 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 	}
 }
 function getMockType(factoryOrOptions) {
-	return factoryOrOptions ? typeof factoryOrOptions === "function" ? "manual" : factoryOrOptions.spy ? "autospy" : "automock" : "automock";
+	if (!factoryOrOptions) return "automock";
+	if (typeof factoryOrOptions === "function") return "manual";
+	return factoryOrOptions.spy ? "autospy" : "automock";
 }
 // unique id that is not available as "$bare_import" like "test"
 // https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
@@ -405,7 +507,8 @@ const prefixedBuiltins = new Set([
 	"node:sqlite",
 	"node:test",
 	"node:test/reporters"
-]), isWindows$1 = process.platform === "win32";
+]);
+const isWindows$1 = process.platform === "win32";
 // transform file url to id
 // virtual:custom -> virtual:custom
 // \0custom -> \0custom
@@ -415,8 +518,9 @@ const prefixedBuiltins = new Set([
 // C:\root\id.js -> /id.js
 // TODO: expose this in vite/module-runner
 function normalizeModuleId(file) {
+	if (prefixedBuiltins.has(file)) return file;
 	// if it's not in the root, keep it as a path, not a URL
-	return prefixedBuiltins.has(file) ? file : slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
+	return slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
 }
 const windowsSlashRE = /\\/g;
 function slash(p) {
@@ -425,33 +529,15 @@ function slash(p) {
 const multipleSlashRe = /^\/+/;
 // module-runner incorrectly replaces file:///path with `///path`
 function fixLeadingSlashes(id) {
-	return id.startsWith("//") ? id.replace(multipleSlashRe, "/") : id;
-}
-
-class VitestTransport {
-	constructor(options) {
-		this.options = options;
-	}
-	async invoke(event) {
-		if (event.type !== "custom") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support Vite HMR events.`) };
-		if (event.event !== "vite:invoke") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support ${event.event} event.`) };
-		const { name, data } = event.data;
-		if (name === "getBuiltins")
- // we return an empty array here to avoid client-side builtin check,
-		// as we need builtins to go through `fetchModule`
-		return { result: [] };
-		if (name !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
-		try {
-			return { result: await this.options.fetchModule(...data) };
-		} catch (error) {
-			return { error };
-		}
-	}
+	if (id.startsWith("//")) return id.replace(multipleSlashRe, "/");
+	return id;
 }
 
 const createNodeImportMeta = (modulePath) => {
 	if (!viteModuleRunner.createDefaultImportMeta) throw new Error(`createNodeImportMeta is not supported in this version of Vite.`);
-	const defaultMeta = viteModuleRunner.createDefaultImportMeta(modulePath), href = defaultMeta.url, importMetaResolver = createImportMetaResolver();
+	const defaultMeta = viteModuleRunner.createDefaultImportMeta(modulePath);
+	const href = defaultMeta.url;
+	const importMetaResolver = createImportMetaResolver();
 	return {
 		...defaultMeta,
 		main: false,
@@ -461,21 +547,27 @@ const createNodeImportMeta = (modulePath) => {
 	};
 };
 function createImportMetaResolver() {
-	if (import.meta.resolve) return (specifier, importer) => import.meta.resolve(specifier, importer);
+	if (!import.meta.resolve) return;
+	return (specifier, importer) => import.meta.resolve(specifier, importer);
 }
 // @ts-expect-error overriding private method
 class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	mocker;
 	moduleExecutionInfo;
 	constructor(vitestOptions) {
-		const options = vitestOptions, transport = new VitestTransport(options.transport), evaluatedModules = options.evaluatedModules;
-		if (super({
+		const options = vitestOptions;
+		const transport = new VitestTransport(options.transport);
+		const evaluatedModules = options.evaluatedModules;
+		super({
 			transport,
 			hmr: false,
 			evaluatedModules,
 			sourcemapInterceptor: "prepareStackTrace",
 			createImportMeta: vitestOptions.createImportMeta
-		}, options.evaluator), this.vitestOptions = vitestOptions, this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo, this.mocker = options.mocker || new VitestMocker(this, {
+		}, options.evaluator);
+		this.vitestOptions = vitestOptions;
+		this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo;
+		this.mocker = options.mocker || new VitestMocker(this, {
 			spyModule: options.spyModule,
 			context: options.vm?.context,
 			resolveId: options.transport.resolveId,
@@ -488,7 +580,8 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 			getCurrentTestFilepath() {
 				return options.getWorkerState().filepath;
 			}
-		}), options.vm) options.vm.context.__vitest_mocker__ = this.mocker;
+		});
+		if (options.vm) options.vm.context.__vitest_mocker__ = this.mocker;
 		else Object.defineProperty(globalThis, "__vitest_mocker__", {
 			configurable: true,
 			writable: true,
@@ -528,7 +621,8 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 			const node = await this.fetchModule(mocked);
 			return this._cachedRequest(mocked, node, callstack, metadata);
 		}
-		return mocked != null && typeof mocked === "object" ? mocked : this._cachedRequest(url, mod, callstack, metadata);
+		if (mocked != null && typeof mocked === "object") return mocked;
+		return this._cachedRequest(url, mod, callstack, metadata);
 	}
 	/** @internal */
 	_invalidateSubTreeById(ids, invalidated = /* @__PURE__ */ new Set()) {
@@ -544,7 +638,10 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	}
 }
 
-const bareVitestRegexp = /^@?vitest(?:\/|$)/, normalizedDistDir = normalize$1(distDir), relativeIds = {}, externalizeMap = /* @__PURE__ */ new Map();
+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);
@@ -554,63 +651,86 @@ function getCachedVitestImport(id, state) {
 	};
 	// 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, relativeRoot = relativeIds[root] ?? (relativeIds[root] = normalizedDistDir.slice(root.length));
+	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();
-		return externalizeMap.set(id, externalize), {
+		externalizeMap.set(id, externalize);
+		return {
 			externalize,
 			type: "module"
 		};
 	}
 	if (relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
-		const path = join$1(root, id), externalize = pathToFileURL(path).toString();
-		return externalizeMap.set(id, externalize), {
+		const externalize = pathToFileURL(join$1(root, id)).toString();
+		externalizeMap.set(id, externalize);
+		return {
 			externalize,
 			type: "module"
 		};
 	}
-	return bareVitestRegexp.test(id) ? (externalizeMap.set(id, id), {
-		externalize: id,
-		type: "module"
-	}) : null;
+	if (bareVitestRegexp.test(id)) {
+		externalizeMap.set(id, id);
+		return {
+			externalize: id,
+			type: "module"
+		};
+	}
+	return null;
 }
 
+// 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;
+	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 (process.listeners(event).length > 1) return;
+		if (processListeners(event).length > 1) return;
 		const error = serializeValue(err);
 		if (typeof error === "object" && error != null) {
-			if (error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0, worker.filepath) error.VITEST_TEST_PATH = worker.filepath;
-			error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
+			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"), 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 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 { readFileSync } = fs, browserExternalId = "__vite-browser-external", browserExternalLength = 24;
+const { readFileSync } = fs;
+const browserExternalId = "__vite-browser-external";
+const browserExternalLength = 24;
 const VITEST_VM_CONTEXT_SYMBOL = "__vitest_vm_context__";
-const cwd = process.cwd(), isWindows = process.platform === "win32";
+const cwd = process.cwd();
+const isWindows = process.platform === "win32";
 function startVitestModuleRunner(options) {
-	const state = () => globalThis.__vitest_worker__ || options.state, rpc = () => state().rpc;
+	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);
+	};
+	listenForErrors(state);
 	const environment = () => {
 		const environment = state().environment;
 		return environment.viteEnvironment || environment.name;
-	}, vm = options.context && options.externalModulesExecutor ? {
+	};
+	const vm = options.context && options.externalModulesExecutor ? {
 		context: options.context,
 		externalModulesExecutor: options.externalModulesExecutor
-	} : void 0, evaluator = options.evaluator || new VitestModuleEvaluator(vm, {
+	} : void 0;
+	const evaluator = options.evaluator || new VitestModuleEvaluator(vm, {
 		get moduleExecutionInfo() {
 			return state().moduleExecutionInfo;
 		},
@@ -618,7 +738,8 @@ function startVitestModuleRunner(options) {
 			return state().config.deps.interopDefault;
 		},
 		getCurrentTestFilepath: () => state().filepath
-	}), moduleRunner = new VitestModuleRunner({
+	});
+	const moduleRunner = new VitestModuleRunner({
 		spyModule: options.spyModule,
 		evaluatedModules: options.evaluatedModules,
 		evaluator,
@@ -654,15 +775,17 @@ function startVitestModuleRunner(options) {
 						type: "builtin"
 					};
 					const result = await rpc().fetch(id, importer, environment(), options);
-					return "cached" in result ? {
+					if ("cached" in result) return {
 						code: readFileSync(result.tmp, "utf-8"),
 						...result
-					} : 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 });
-						throw error.code = "ERR_MODULE_NOT_FOUND", error;
+						error.code = "ERR_MODULE_NOT_FOUND";
+						throw error;
 					}
 					throw cause;
 				} finally {