vitest 4.0.0-beta.8 → 4.0.0

package/dist/chunks/{index.CsFXYRkW.js → resolveSnapshotEnvironment.DJJKMKxb.js}

@@ -1,36 +1,21 @@
-import * as chai from 'chai';
-import { resolve, join } from 'node:path';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.hLGRxhC8.js';
-import { distDir } from '../path.js';
-import { r as rpc } from './rpc.RpPylpp0.js';
-import { g as getWorkerState } from './utils.C7__0Iv5.js';
+import { chai } from '@vitest/expect';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.DR1sucx6.js';
+import { r as rpc } from './rpc.cD77ENhU.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.C3RPt8JR.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
 }
 
-async function resolveSnapshotEnvironment(config, executor) {
-	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.BOqcT2jW.js');
-		return new VitestNodeSnapshotEnvironment();
-	}
-	const mod = await executor.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;
-}
-
-const runnersFile = resolve(distDir, "runners.js");
 async function getTestRunnerConstructor(config, moduleRunner) {
-	if (!config.runner) {
-		const { VitestTestRunner, NodeBenchmarkRunner } = await moduleRunner.import(join("/@fs/", runnersFile));
-		return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
-	}
+	if (!config.runner) return config.mode === "test" ? VitestTestRunner : 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;
 }
 async function resolveTestRunner(config, moduleRunner) {
-	const TestRunner = await getTestRunnerConstructor(config, moduleRunner), testRunner = new TestRunner(config);
+	const testRunner = new (await (getTestRunnerConstructor(config, moduleRunner)))(config);
 	if (Object.defineProperty(testRunner, "moduleRunner", {
 		value: moduleRunner,
 		enumerable: false,
@@ -76,11 +61,20 @@ async function resolveTestRunner(config, moduleRunner) {
 	const originalOnAfterRunTask = testRunner.onAfterRunTask;
 	return testRunner.onAfterRunTask = async (test) => {
 		if (config.bail && test.result?.state === "fail") {
-			const previousFailures = await rpc().getCountOfFailedTests(), currentFailures = 1 + previousFailures;
-			if (currentFailures >= config.bail) rpc().onCancel("test-failure"), testRunner.cancel?.("test-failure");
+			if (1 + await rpc().getCountOfFailedTests() >= config.bail) rpc().onCancel("test-failure"), testRunner.cancel?.("test-failure");
 		}
 		await originalOnAfterRunTask?.call(testRunner, test);
 	}, testRunner;
 }
 
+async function resolveSnapshotEnvironment(config, executor) {
+	if (!config.snapshotEnvironment) {
+		const { VitestNodeSnapshotEnvironment } = await import('./node.BwAWWjHZ.js');
+		return new VitestNodeSnapshotEnvironment();
+	}
+	const mod = await executor.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;
+}
+
 export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };

package/dist/chunks/{rpc.RpPylpp0.js → rpc.cD77ENhU.js}

@@ -1,6 +1,6 @@
-import { getSafeTimers } from '@vitest/utils';
+import { getSafeTimers } from '@vitest/utils/timers';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { g as getWorkerState } from './utils.C7__0Iv5.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {
@@ -9,8 +9,7 @@ function withSafeTimers(fn) {
 		if (globalThis.setTimeout = setTimeout, globalThis.clearTimeout = clearTimeout, setImmediate) globalThis.setImmediate = setImmediate;
 		if (clearImmediate) globalThis.clearImmediate = clearImmediate;
 		if (globalThis.process && nextTick) globalThis.process.nextTick = nextTick;
-		const result = fn();
-		return result;
+		return fn();
 	} finally {
 		if (globalThis.setTimeout = currentSetTimeout, globalThis.clearTimeout = currentClearTimeout, globalThis.setImmediate = currentSetImmediate, globalThis.clearImmediate = currentClearImmediate, globalThis.process && nextTick) nextTick(() => {
 			globalThis.process.nextTick = currentNextTick;
@@ -27,17 +26,17 @@ function createRuntimeRpc(options) {
 	let setCancel = (_reason) => {};
 	const onCancel = new Promise((resolve) => {
 		setCancel = resolve;
-	}), rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
-		eventNames: [
-			"onUserConsoleLog",
-			"onCollected",
-			"onCancel"
-		],
-		timeout: -1,
-		...options
-	}));
+	});
 	return {
-		rpc,
+		rpc: createSafeRpc(createBirpc({ onCancel: setCancel }, {
+			eventNames: [
+				"onUserConsoleLog",
+				"onCollected",
+				"onCancel"
+			],
+			timeout: -1,
+			...options
+		})),
 		onCancel
 	};
 }

package/dist/chunks/{setup-common.hLGRxhC8.js → setup-common.DR1sucx6.js}

@@ -1,7 +1,7 @@
 import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 import { addSerializer } from '@vitest/snapshot';
-import { setSafeTimers } from '@vitest/utils';
-import { g as getWorkerState } from './utils.C7__0Iv5.js';
+import { setSafeTimers } from '@vitest/utils/timers';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
 
 async function startCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
@@ -18,10 +18,10 @@ async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
-	if (setupDefines(config.defines), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.lgsmH00r.js')).registerApiGlobally();
+	if (setupDefines(config), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.BGT_RUsD.js')).registerApiGlobally();
 }
-function setupDefines(defines) {
-	for (const key in defines) globalThis[key] = defines[key];
+function setupDefines(config) {
+	for (const key in config.defines) globalThis[key] = config.defines[key];
 }
 function setupEnv(env) {
 	const state = getWorkerState(), { PROD, DEV,...restEnvs } = env;
@@ -35,14 +35,14 @@ async function loadDiffConfig(config, moduleRunner) {
 	throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
 }
 async function loadSnapshotSerializers(config, moduleRunner) {
-	const files = config.snapshotSerializers, snapshotSerializers = await Promise.all(files.map(async (file) => {
+	const files = config.snapshotSerializers;
+	(await Promise.all(files.map(async (file) => {
 		const mo = await moduleRunner.import(file);
 		if (!mo || typeof mo.default !== "object" || mo.default === null) throw new Error(`invalid snapshot serializer file ${file}. Must export a default object`);
 		const config = mo.default;
 		if (typeof config.test !== "function" || typeof config.serialize !== "function" && typeof config.print !== "function") throw new TypeError(`invalid snapshot serializer in ${file}. Must have a 'test' method along with either a 'serialize' or 'print' method.`);
 		return config;
-	}));
-	snapshotSerializers.forEach((serializer) => addSerializer(serializer));
+	}))).forEach((serializer) => addSerializer(serializer));
 }
 
 export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };

package/dist/chunks/{startModuleRunner.C8TW8zTN.js → startModuleRunner.C2tTvmF9.js}

@@ -1,68 +1,15 @@
 import fs from 'node:fs';
-import { builtinModules, isBuiltin } from 'node:module';
-import { highlight, isBareImport } from '@vitest/utils';
+import nodeModule, { builtinModules, isBuiltin } from 'node:module';
+import { isBareImport } from '@vitest/utils/helpers';
 import { pathToFileURL } from 'node:url';
 import { normalize as normalize$1, join as join$1 } from 'pathe';
 import { distDir } from '../path.js';
-import { processError } from '@vitest/utils/error';
+import { serializeValue } from '@vitest/utils/serialize';
 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 { ModuleRunner } from 'vite/module-runner';
-import { V as VitestTransport } from './moduleTransport.I-bgQy0S.js';
-
-const bareVitestRegexp = /^@?vitest(?:\/|$)/, normalizedDistDir = normalize$1(distDir), relativeIds = {}, 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, 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), {
-			externalize,
-			type: "module"
-		};
-	}
-	if (relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
-		const path = join$1(root, id), externalize = pathToFileURL(path).toString();
-		return externalizeMap.set(id, externalize), {
-			externalize,
-			type: "module"
-		};
-	}
-	return bareVitestRegexp.test(id) ? (externalizeMap.set(id, id), {
-		externalize: id,
-		type: "module"
-	}) : null;
-}
-
-const dispose = [];
-function listenForErrors(state) {
-	dispose.forEach((fn) => fn()), dispose.length = 0;
-	function catchError(err, type, event) {
-		const worker = state(), 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) {
-			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;
-		}
-		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);
-	});
-}
+import * as viteModuleRunner from 'vite/module-runner';
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -81,8 +28,8 @@ const _UNC_REGEX = /^[/\\]{2}/, _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\
 	for (const seg of segments) {
 		if (!seg) continue;
 		if (path.length > 0) {
-			const pathTrailing = path[path.length - 1] === "/", segLeading = seg[0] === "/", both = pathTrailing && segLeading;
-			if (both) path += seg.slice(1);
+			const pathTrailing = path[path.length - 1] === "/", segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
 			else path += pathTrailing || segLeading ? seg : `/${seg}`;
 		} else path += seg;
 	}
@@ -167,17 +114,14 @@ function findMockRedirect(root, mockPath, external) {
 		const baseOriginal = basename(path);
 		function findFile(mockFolder, baseOriginal) {
 			const files = readdirSync(mockFolder);
-			for (const file of files) {
-				const baseFile = basename(file, extname(file));
-				if (baseFile === baseOriginal) {
-					const path = resolve(mockFolder, file);
-					// if the same name, return the file
-					if (statSync(path).isFile()) return path;
-					{
-						// find folder/index.{js,ts}
-						const indexFile = findFile(path, "index");
-						if (indexFile) return indexFile;
-					}
+			for (const file of files) if (basename(file, extname(file)) === baseOriginal) {
+				const path = resolve(mockFolder, file);
+				// if the same name, return the file
+				if (statSync(path).isFile()) return path;
+				{
+					// find folder/index.{js,ts}
+					const indexFile = findFile(path, "index");
+					if (indexFile) return indexFile;
 				}
 			}
 			return null;
@@ -188,7 +132,7 @@ function findMockRedirect(root, mockPath, external) {
 	return existsSync(fullPath) ? fullPath : null;
 }
 const builtins = new Set([
-	...builtinModules,
+	...nodeModule.builtinModules,
 	"assert/strict",
 	"diagnostics_channel",
 	"dns/promises",
@@ -209,7 +153,7 @@ const builtins = new Set([
 	"node:test/reporters"
 ]), NODE_BUILTIN_NAMESPACE = "node:";
 function isNodeBuiltin(id) {
-	return prefixedBuiltins$1.has(id) ? true : builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
+	return nodeModule.isBuiltin ? nodeModule.isBuiltin(id) : prefixedBuiltins$1.has(id) ? true : builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
 }
 
 const spyModulePath = resolve$1(distDir, "spy.js");
@@ -233,6 +177,7 @@ class VitestMocker {
 			Array,
 			Map
 		};
+		if (options.spyModule) this.spyModule = options.spyModule;
 		const Symbol = this.primitives.Symbol;
 		this.filterPublicKeys = [
 			"__esModule",
@@ -330,16 +275,16 @@ class VitestMocker {
 			if (prop === "then") {
 				if (target instanceof Promise) return target.then.bind(target);
 			} else if (!(prop in target)) {
-				if (this.filterPublicKeys.includes(prop)) return void 0;
+				if (this.filterPublicKeys.includes(prop)) return;
 				throw this.createError(`[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. Did you forget to return it from "vi.mock"?
 If you need to partially mock a module, you can use "importOriginal" helper inside:
-`, highlight(`vi.mock(import("${mock.raw}"), async (importOriginal) => {
+`, `vi.mock(import("${mock.raw}"), async (importOriginal) => {
   const actual = await importOriginal()
   return {
     ...actual,
     // your mocked methods
   }
-})`));
+})`);
 			}
 			return val;
 		} });
@@ -354,8 +299,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		return `mock:${dep}`;
 	}
 	getDependencyMock(id) {
-		const registry = this.getMockerRegistry();
-		return registry.getById(fixLeadingSlashes(id));
+		return this.getMockerRegistry().getById(fixLeadingSlashes(id));
 	}
 	findMockRedirect(mockPath, external) {
 		return findMockRedirect(this.root, mockPath, external);
@@ -370,8 +314,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		}, object, mockExports);
 	}
 	unmockPath(id) {
-		const registry = this.getMockerRegistry();
-		registry.deleteById(id), this.invalidateModuleById(id);
+		this.getMockerRegistry().deleteById(id), this.invalidateModuleById(id);
 	}
 	mockPath(originalId, id, url, external, mockType, factory) {
 		const registry = this.getMockerRegistry();
@@ -386,8 +329,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), result = await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
-		return result;
+		const { url } = await this.resolveId(rawId, importer), node = await this.moduleRunner.fetchModule(url, importer);
+		return await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
 	}
 	async importMock(rawId, importer) {
 		const { id, url, external } = await this.resolveId(rawId, importer);
@@ -472,11 +415,8 @@ 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;
-	// 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:\//, "/");
+	return prefixedBuiltins.has(file) ? file : slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
 }
 const windowsSlashRE = /\\/g;
 function slash(p) {
@@ -488,18 +428,53 @@ function fixLeadingSlashes(id) {
 	return id.startsWith("//") ? id.replace(multipleSlashRe, "/") : id;
 }
 
+const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
+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 !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
+		if (name === "getBuiltins") return { result: [...nodeBuiltins, /^node:/] };
+		try {
+			return { result: await this.options.fetchModule(...data) };
+		} catch (error) {
+			return { error };
+		}
+	}
+}
+
+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();
+	return {
+		...defaultMeta,
+		main: false,
+		resolve(id, parent) {
+			return (importMetaResolver ?? defaultMeta.resolve)(id, parent ?? href);
+		}
+	};
+};
+function createImportMetaResolver() {
+	if (import.meta.resolve) return (specifier, importer) => import.meta.resolve(specifier, importer);
+}
 // @ts-expect-error overriding private method
-class VitestModuleRunner extends ModuleRunner {
+class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	mocker;
 	moduleExecutionInfo;
-	constructor(options) {
-		const transport = new VitestTransport(options.transport), evaluatedModules = options.evaluatedModules;
+	constructor(vitestOptions) {
+		const options = vitestOptions, transport = new VitestTransport(options.transport), evaluatedModules = options.evaluatedModules;
 		if (super({
 			transport,
 			hmr: false,
 			evaluatedModules,
-			sourcemapInterceptor: "prepareStackTrace"
-		}, options.evaluator), this.options = options, this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo, this.mocker = options.mocker || new VitestMocker(this, {
+			sourcemapInterceptor: "prepareStackTrace",
+			createImportMeta: vitestOptions.createImportMeta
+		}, 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,
 			get root() {
@@ -519,12 +494,11 @@ class VitestModuleRunner extends ModuleRunner {
 		});
 	}
 	async import(rawId) {
-		const resolved = await this.options.transport.resolveId(rawId);
-		return resolved ? super.import(resolved.url) : super.import(rawId);
+		const resolved = await this.vitestOptions.transport.resolveId(rawId);
+		return super.import(resolved ? resolved.url : rawId);
 	}
 	async fetchModule(url, importer) {
-		const module = await this.cachedModule(url, importer);
-		return module;
+		return await this.cachedModule(url, importer);
 	}
 	_cachedRequest(url, module, callstack = [], metadata) {
 		// @ts-expect-error "cachedRequest" is private
@@ -558,10 +532,62 @@ class VitestModuleRunner extends ModuleRunner {
 	}
 }
 
+const bareVitestRegexp = /^@?vitest(?:\/|$)/, normalizedDistDir = normalize$1(distDir), relativeIds = {}, 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, 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), {
+			externalize,
+			type: "module"
+		};
+	}
+	if (relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
+		const path = join$1(root, id), externalize = pathToFileURL(path).toString();
+		return externalizeMap.set(id, externalize), {
+			externalize,
+			type: "module"
+		};
+	}
+	return bareVitestRegexp.test(id) ? (externalizeMap.set(id, id), {
+		externalize: id,
+		type: "module"
+	}) : null;
+}
+
+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 (process.listeners(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;
+		}
+		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 { readFileSync } = fs, browserExternalId = "__vite-browser-external", browserExternalLength = 24;
 const VITEST_VM_CONTEXT_SYMBOL = "__vitest_vm_context__";
 const cwd = process.cwd(), isWindows = process.platform === "win32";
-async function startVitestModuleRunner(options) {
+function startVitestModuleRunner(options) {
 	const state = () => globalThis.__vitest_worker__ || options.state, rpc = () => state().rpc;
 	process.exit = (code = process.exitCode || 0) => {
 		throw new Error(`process.exit unexpectedly called with "${code}"`);
@@ -581,6 +607,7 @@ async function startVitestModuleRunner(options) {
 		},
 		getCurrentTestFilepath: () => state().filepath
 	}), moduleRunner = new VitestModuleRunner({
+		spyModule: options.spyModule,
 		evaluatedModules: options.evaluatedModules,
 		evaluator,
 		mocker: options.mocker,
@@ -590,10 +617,7 @@ async function startVitestModuleRunner(options) {
 				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);
-						}
+						if (id[0] !== cwd[0] && id[0].toUpperCase() === cwd[0].toUpperCase()) id = (cwd[0].toUpperCase() === cwd[0] ? id[0].toUpperCase() : id[0].toLowerCase()) + id.slice(1);
 						// always mark absolute windows paths, otherwise Vite will externalize it
 						id = `/@id/${id}`;
 					}
@@ -618,14 +642,10 @@ async function startVitestModuleRunner(options) {
 						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;
+					return "cached" in result ? {
+						code: readFileSync(result.tmp, "utf-8"),
+						...result
+					} : 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 '")) {
@@ -642,9 +662,10 @@ async function startVitestModuleRunner(options) {
 			}
 		},
 		getWorkerState: state,
-		vm
+		vm,
+		createImportMeta: options.createImportMeta
 	});
-	return await moduleRunner.import("/@vite/env"), await moduleRunner.mocker.initializeSpyModule(), moduleRunner;
+	return moduleRunner;
 }
 function toBuiltin(id) {
 	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);
@@ -652,4 +673,4 @@ function toBuiltin(id) {
 	return id;
 }
 
-export { VitestModuleRunner as V, VITEST_VM_CONTEXT_SYMBOL as a, startVitestModuleRunner as s };
+export { VitestModuleRunner as V, VITEST_VM_CONTEXT_SYMBOL as a, VitestTransport as b, createNodeImportMeta as c, startVitestModuleRunner as s };