vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/{chunks/vm.BThCzidc.js → worker-vm.js}

@@ -1,15 +1,32 @@
+import { c as createForksRpcOptions, u as unwrapSerializableConfig, a as createThreadsRpcOptions, e as execute, t as teardown$1 } from './chunks/worker.rPGLlbkW.js';
+import v8 from 'node:v8';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import vm, { isContext } from 'node:vm';
-import { dirname, basename, extname, normalize, join, resolve } from 'pathe';
-import { distDir } from '../path.js';
-import { createCustomConsole } from './console.CtFJOzRO.js';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.B7h3T_Hc.js';
+import vm, { isContext, runInContext } from 'node:vm';
+import { dirname, basename, extname, normalize, resolve } from 'pathe';
+import { distDir } from './path.js';
+import { createCustomConsole } from './chunks/console.CiTi59Jy.js';
 import fs from 'node:fs';
+import { createRequire, Module, isBuiltin } from 'node:module';
+import { toArray, isBareImport } from '@vitest/utils/helpers';
+import { findNearestPackageData } from '@vitest/utils/resolver';
 import { dirname as dirname$1 } from 'node:path';
-import { isPrimitive, isNodeBuiltin, toArray, getCachedData, setCacheData, isBareImport } from 'vite-node/utils';
-import { createRequire, Module } from 'node:module';
-import { CSS_LANGS_RE, KNOWN_ASSET_RE } from 'vite-node/constants';
-import { p as provideWorkerState } from './utils.XdZDrNZV.js';
+import { CSS_LANGS_RE, KNOWN_ASSET_RE } from '@vitest/utils/constants';
+import { getDefaultRequestStubs } from './module-evaluator.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './chunks/startModuleRunner.oAuCu1yL.js';
+import { p as provideWorkerState } from './chunks/utils.DGKhod2J.js';
+import '@vitest/utils/source-map';
+import 'vite/module-runner';
+import './chunks/index.DIWhzsUh.js';
+import 'node:console';
+import './chunks/inspector.CvQD-Nie.js';
+import './chunks/rpc.jKGRSXIH.js';
+import '@vitest/utils/timers';
+import './chunks/index.Bgo3tNWt.js';
+import 'node:stream';
+import 'tinyrainbow';
+import './chunks/date.-jtEtIeV.js';
+import '@vitest/utils/serialize';
+import '@vitest/mocker';
 
 function interopCommonJsModule(interopDefault, mod) {
 	if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) return {
@@ -18,11 +35,8 @@ function interopCommonJsModule(interopDefault, mod) {
 		defaultExport: mod
 	};
 	if (interopDefault !== false && "__esModule" in mod && !isPrimitive(mod.default)) {
-		const defaultKets = Object.keys(mod.default);
-		const moduleKeys = Object.keys(mod);
-		const allKeys = new Set([...defaultKets, ...moduleKeys]);
-		allKeys.delete("default");
-		return {
+		const defaultKets = Object.keys(mod.default), moduleKeys = Object.keys(mod), allKeys = new Set([...defaultKets, ...moduleKeys]);
+		return allKeys.delete("default"), {
 			keys: Array.from(allKeys),
 			moduleExports: new Proxy(mod, { get(mod, prop) {
 				return mod[prop] ?? mod.default?.[prop];
@@ -36,11 +50,14 @@ function interopCommonJsModule(interopDefault, mod) {
 		defaultExport: mod
 	};
 }
+function isPrimitive(obj) {
+	const isObject = obj != null && (typeof obj === "object" || typeof obj === "function");
+	return !isObject;
+}
 const SyntheticModule = vm.SyntheticModule;
 const SourceTextModule = vm.SourceTextModule;
 
-const _require = createRequire(import.meta.url);
-const requiresCache = /* @__PURE__ */ new WeakMap();
+const _require = createRequire(import.meta.url), requiresCache = /* @__PURE__ */ new WeakMap();
 class CommonjsExecutor {
 	context;
 	requireCache = /* @__PURE__ */ new Map();
@@ -52,12 +69,8 @@ class CommonjsExecutor {
 	Module;
 	interopDefault;
 	constructor(options) {
-		this.context = options.context;
-		this.fs = options.fileMap;
-		this.interopDefault = options.interopDefault;
-		const primitives = vm.runInContext("({ Object, Array, Error })", this.context);
-		// eslint-disable-next-line ts/no-this-alias
-		const executor = this;
+		this.context = options.context, this.fs = options.fileMap, this.interopDefault = options.interopDefault;
+		const primitives = vm.runInContext("({ Object, Array, Error })", this.context), executor = this;
 		this.Module = class Module$1 {
 			exports;
 			isPreloading = false;
@@ -69,21 +82,22 @@ class CommonjsExecutor {
 			path;
 			paths = [];
 			constructor(id = "", parent) {
-				this.exports = primitives.Object.create(Object.prototype);
-				// in our case the path should always be resolved already
-				this.path = dirname(id);
-				this.id = id;
-				this.filename = id;
-				this.loaded = false;
-				this.parent = parent;
+				this.exports = primitives.Object.create(Object.prototype), this.path = dirname(id), this.id = id, this.filename = id, this.loaded = false, this.parent = parent;
 			}
 			get require() {
 				const require = requiresCache.get(this);
 				if (require) return require;
 				const _require = Module$1.createRequire(this.id);
-				requiresCache.set(this, _require);
-				return _require;
+				return requiresCache.set(this, _require), _require;
 			}
+			static getSourceMapsSupport = () => ({
+				enabled: false,
+				nodeModules: false,
+				generatedCode: false
+			});
+			static setSourceMapsSupport = () => {
+				// noop
+			};
 			static register = () => {
 				throw new Error(`[vitest] "register" is not available when running in Vitest.`);
 			};
@@ -91,19 +105,16 @@ class CommonjsExecutor {
 				throw new Error(`[vitest] "registerHooks" is not available when running in Vitest.`);
 			};
 			_compile(code, filename) {
-				const cjsModule = Module$1.wrap(code);
-				const script = new vm.Script(cjsModule, {
+				const cjsModule = Module$1.wrap(code), script = new vm.Script(cjsModule, {
 					filename,
 					importModuleDynamically: options.importModuleDynamically
 				});
 				// @ts-expect-error mark script with current identifier
 				script.identifier = filename;
-				const fn = script.runInContext(executor.context);
-				const __dirname = dirname(filename);
+				const fn = script.runInContext(executor.context), __dirname = dirname(filename);
 				executor.requireCache.set(filename, this);
 				try {
-					fn(this.exports, this.require, this, filename, __dirname);
-					return this.exports;
+					return fn(this.exports, this.require, this, filename, __dirname), this.exports;
 				} finally {
 					this.loaded = true;
 				}
@@ -149,9 +160,7 @@ class CommonjsExecutor {
 			static stripTypeScriptTypes = Module.stripTypeScriptTypes;
 			static findPackageJSON = Module.findPackageJSON;
 			static Module = Module$1;
-		};
-		this.extensions[".js"] = this.requireJs;
-		this.extensions[".json"] = this.requireJson;
+		}, this.extensions[".js"] = this.requireJs, this.extensions[".json"] = this.requireJson;
 	}
 	requireJs = (m, filename) => {
 		const content = this.fs.readFile(filename);
@@ -162,23 +171,17 @@ class CommonjsExecutor {
 		m.exports = JSON.parse(code);
 	};
 	createRequire = (filename) => {
-		const _require = createRequire(filename);
-		const require = (id) => {
-			const resolved = _require.resolve(id);
-			const ext = extname(resolved);
-			if (ext === ".node" || isNodeBuiltin(resolved)) return this.requireCoreModule(resolved);
+		const _require = createRequire(filename), require = ((id) => {
+			const resolved = _require.resolve(id), ext = extname(resolved);
+			if (ext === ".node" || isBuiltin(resolved)) return this.requireCoreModule(resolved);
 			const module = new this.Module(resolved);
 			return this.loadCommonJSModule(module, resolved);
-		};
-		require.resolve = _require.resolve;
-		Object.defineProperty(require, "extensions", {
+		});
+		return require.resolve = _require.resolve, Object.defineProperty(require, "extensions", {
 			get: () => this.extensions,
 			set: () => {},
 			configurable: true
-		});
-		require.main = void 0;
-		require.cache = this.publicRequireCache;
-		return require;
+		}), require.main = void 0, require.cache = this.publicRequireCache, require;
 	};
 	createProxyCache() {
 		return new Proxy(Object.create(null), {
@@ -200,53 +203,40 @@ class CommonjsExecutor {
 	loadCommonJSModule(module, filename) {
 		const cached = this.requireCache.get(filename);
 		if (cached) return cached.exports;
-		const extension = this.findLongestRegisteredExtension(filename);
-		const loader = this.extensions[extension] || this.extensions[".js"];
-		loader(module, filename);
-		return module.exports;
+		const extension = this.findLongestRegisteredExtension(filename), loader = this.extensions[extension] || this.extensions[".js"];
+		return loader(module, filename), module.exports;
 	}
 	findLongestRegisteredExtension(filename) {
 		const name = basename(filename);
-		let currentExtension;
-		let index;
-		let startIndex = 0;
+		let currentExtension, index, startIndex = 0;
 		// eslint-disable-next-line no-cond-assign
 		while ((index = name.indexOf(".", startIndex)) !== -1) {
-			startIndex = index + 1;
-			if (index === 0) continue;
-			currentExtension = name.slice(index);
-			if (this.extensions[currentExtension]) return currentExtension;
+			if (startIndex = index + 1, index === 0) continue;
+			if (currentExtension = name.slice(index), this.extensions[currentExtension]) return currentExtension;
 		}
 		return ".js";
 	}
 	getCoreSyntheticModule(identifier) {
 		if (this.moduleCache.has(identifier)) return this.moduleCache.get(identifier);
-		const exports = this.require(identifier);
-		const keys = Object.keys(exports);
-		const module = new SyntheticModule([...keys, "default"], () => {
+		const exports = this.require(identifier), keys = Object.keys(exports), module = new SyntheticModule([...keys, "default"], () => {
 			for (const key of keys) module.setExport(key, exports[key]);
 			module.setExport("default", exports);
 		}, {
 			context: this.context,
 			identifier
 		});
-		this.moduleCache.set(identifier, module);
-		return module;
+		return this.moduleCache.set(identifier, module), module;
 	}
 	getCjsSyntheticModule(path, identifier) {
 		if (this.moduleCache.has(identifier)) return this.moduleCache.get(identifier);
-		const exports = this.require(path);
-		// TODO: technically module should be parsed to find static exports, implement for strict mode in #2854
-		const { keys, moduleExports, defaultExport } = interopCommonJsModule(this.interopDefault, exports);
-		const module = new SyntheticModule([...keys, "default"], function() {
+		const exports = this.require(path), { keys, moduleExports, defaultExport } = interopCommonJsModule(this.interopDefault, exports), module = new SyntheticModule([...keys, "default"], function() {
 			for (const key of keys) this.setExport(key, moduleExports[key]);
 			this.setExport("default", defaultExport);
 		}, {
 			context: this.context,
 			identifier
 		});
-		this.moduleCache.set(identifier, module);
-		return module;
+		return this.moduleCache.set(identifier, module), module;
 	}
 	// TODO: use this in strict mode, when available in #2854
 	// private _getNamedCjsExports(path: string): Set<string> {
@@ -286,7 +276,7 @@ class CommonjsExecutor {
 	// }
 	require(identifier) {
 		const ext = extname(identifier);
-		if (ext === ".node" || isNodeBuiltin(identifier)) return this.requireCoreModule(identifier);
+		if (ext === ".node" || isBuiltin(identifier)) return this.requireCoreModule(identifier);
 		const module = new this.Module(identifier);
 		return this.loadCommonJSModule(module, identifier);
 	}
@@ -296,13 +286,10 @@ class CommonjsExecutor {
 		const moduleExports = _require(identifier);
 		if (identifier === "node:module" || identifier === "module") {
 			const module = new this.Module("/module.js");
-			module.exports = this.Module;
-			this.builtinCache[normalized] = module;
-			return module.exports;
+			return module.exports = this.Module, this.builtinCache[normalized] = module, module.exports;
 		}
-		this.builtinCache[normalized] = _require.cache[normalized];
 		// TODO: should we wrap module to rethrow context errors?
-		return moduleExports;
+		return this.builtinCache[normalized] = _require.cache[normalized], moduleExports;
 	}
 }
 
@@ -313,21 +300,18 @@ class EsmExecutor {
 	context;
 	#httpIp = IPnumber("127.0.0.0");
 	constructor(executor, options) {
-		this.executor = executor;
-		this.context = options.context;
+		this.executor = executor, this.context = options.context;
 	}
 	async evaluateModule(m) {
 		if (m.status === "unlinked") this.esmLinkMap.set(m, m.link((identifier, referencer) => this.executor.resolveModule(identifier, referencer.identifier)));
-		await this.esmLinkMap.get(m);
-		if (m.status === "linked") await m.evaluate();
+		if (await this.esmLinkMap.get(m), m.status === "linked") await m.evaluate();
 		return m;
 	}
 	async createEsModule(fileURL, getCode) {
 		const cached = this.moduleCache.get(fileURL);
 		if (cached) return cached;
 		const promise = this.loadEsModule(fileURL, getCode);
-		this.moduleCache.set(fileURL, promise);
-		return promise;
+		return this.moduleCache.set(fileURL, promise), promise;
 	}
 	async loadEsModule(fileURL, getCode) {
 		const code = await getCode();
@@ -337,34 +321,29 @@ class EsmExecutor {
 				const result = JSON.parse(code);
 				this.setExport("default", result);
 			});
-			this.moduleCache.set(fileURL, m);
-			return m;
+			return this.moduleCache.set(fileURL, m), m;
 		}
 		const m = new SourceTextModule(code, {
 			identifier: fileURL,
 			context: this.context,
 			importModuleDynamically: this.executor.importModuleDynamically,
 			initializeImportMeta: (meta, mod) => {
-				meta.url = mod.identifier;
-				if (mod.identifier.startsWith("file:")) {
+				if (meta.url = mod.identifier, mod.identifier.startsWith("file:")) {
 					const filename = fileURLToPath(mod.identifier);
-					meta.filename = filename;
-					meta.dirname = dirname$1(filename);
+					meta.filename = filename, meta.dirname = dirname$1(filename);
 				}
 				meta.resolve = (specifier, importer) => {
 					return this.executor.resolve(specifier, importer != null ? importer.toString() : mod.identifier);
 				};
 			}
 		});
-		this.moduleCache.set(fileURL, m);
-		return m;
+		return this.moduleCache.set(fileURL, m), m;
 	}
 	async createWebAssemblyModule(fileUrl, getCode) {
 		const cached = this.moduleCache.get(fileUrl);
 		if (cached) return cached;
 		const m = this.loadWebAssemblyModule(getCode(), fileUrl);
-		this.moduleCache.set(fileUrl, m);
-		return m;
+		return this.moduleCache.set(fileUrl, m), m;
 	}
 	async createNetworkModule(fileUrl) {
 		// https://nodejs.org/api/esm.html#https-and-http-imports
@@ -380,18 +359,13 @@ class EsmExecutor {
 	async loadWebAssemblyModule(source, identifier) {
 		const cached = this.moduleCache.get(identifier);
 		if (cached) return cached;
-		const wasmModule = await WebAssembly.compile(source);
-		const exports = WebAssembly.Module.exports(wasmModule);
-		const imports = WebAssembly.Module.imports(wasmModule);
-		const moduleLookup = {};
+		const wasmModule = await WebAssembly.compile(source), exports = WebAssembly.Module.exports(wasmModule), imports = WebAssembly.Module.imports(wasmModule), moduleLookup = {};
 		for (const { module } of imports) if (moduleLookup[module] === void 0) moduleLookup[module] = await this.executor.resolveModule(module, identifier);
-		const evaluateModule = (module) => this.evaluateModule(module);
-		const syntheticModule = new SyntheticModule(exports.map(({ name }) => name), async function() {
+		const evaluateModule = (module) => this.evaluateModule(module), syntheticModule = new SyntheticModule(exports.map(({ name }) => name), async function() {
 			const importsObject = {};
 			for (const { module, name } of imports) {
 				if (!importsObject[module]) importsObject[module] = {};
-				await evaluateModule(moduleLookup[module]);
-				importsObject[module][name] = moduleLookup[module].namespace[name];
+				await evaluateModule(moduleLookup[module]), importsObject[module][name] = moduleLookup[module].namespace[name];
 			}
 			const wasmInstance = new WebAssembly.Instance(wasmModule, importsObject);
 			for (const { name } of exports) this.setExport(name, wasmInstance.exports[name]);
@@ -412,14 +386,12 @@ class EsmExecutor {
 		if (cached) return cached;
 		const match = identifier.match(dataURIRegex);
 		if (!match || !match.groups) throw new Error("Invalid data URI");
-		const mime = match.groups.mime;
-		const encoding = match.groups.encoding;
+		const mime = match.groups.mime, encoding = match.groups.encoding;
 		if (mime === "application/wasm") {
 			if (!encoding) throw new Error("Missing data URI encoding");
 			if (encoding !== "base64") throw new Error(`Invalid data URI encoding: ${encoding}`);
 			const module = this.loadWebAssemblyModule(Buffer.from(match.groups.code, "base64"), identifier);
-			this.moduleCache.set(identifier, module);
-			return module;
+			return this.moduleCache.set(identifier, module), module;
 		}
 		let code = match.groups.code;
 		if (!encoding || encoding === "charset=utf-8") code = decodeURIComponent(code);
@@ -433,8 +405,7 @@ class EsmExecutor {
 				context: this.context,
 				identifier
 			});
-			this.moduleCache.set(identifier, module);
-			return module;
+			return this.moduleCache.set(identifier, module), module;
 		}
 		return this.createEsModule(identifier, () => code);
 	}
@@ -448,57 +419,39 @@ function IPmask(maskSize) {
 	return -1 << 32 - maskSize;
 }
 
-const CLIENT_ID = "/@vite/client";
-const CLIENT_FILE = pathToFileURL(CLIENT_ID).href;
+const CLIENT_ID = "/@vite/client", CLIENT_FILE = pathToFileURL(CLIENT_ID).href;
 class ViteExecutor {
 	esm;
 	constructor(options) {
-		this.options = options;
-		this.esm = options.esmExecutor;
-	}
-	resolve = (identifier, parent) => {
-		if (identifier === CLIENT_ID) {
-			if (this.workerState.environment.transformMode === "web") return identifier;
-			const packageName = this.getPackageName(parent);
-			throw new Error(`[vitest] Vitest cannot handle ${CLIENT_ID} imported in ${parent} when running in SSR environment. Add "${packageName}" to "ssr.noExternal" if you are using Vite SSR, or to "server.deps.inline" if you are using Vite Node.`);
-		}
+		this.options = options, this.esm = options.esmExecutor;
+	}
+	resolve = (identifier) => {
+		if (identifier === CLIENT_ID) return identifier;
 	};
 	get workerState() {
 		return this.options.context.__vitest_worker__;
 	}
-	getPackageName(modulePath) {
-		const path = normalize(modulePath);
-		let name = path.split("/node_modules/").pop() || "";
-		if (name?.startsWith("@")) name = name.split("/").slice(0, 2).join("/");
-		else name = name.split("/")[0];
-		return name;
-	}
 	async createViteModule(fileUrl) {
-		if (fileUrl === CLIENT_FILE) return this.createViteClientModule();
+		if (fileUrl === CLIENT_FILE || fileUrl === CLIENT_ID) return this.createViteClientModule();
 		const cached = this.esm.resolveCachedModule(fileUrl);
-		if (cached) return cached;
-		return this.esm.createEsModule(fileUrl, async () => {
+		return cached || this.esm.createEsModule(fileUrl, async () => {
 			try {
-				const result = await this.options.transform(fileUrl, "web");
+				const result = await this.options.transform(fileUrl);
 				if (result.code) return result.code;
 			} catch (cause) {
 				// rethrow vite error if it cannot load the module because it's not resolved
 				if (typeof cause === "object" && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url")) {
 					const error = new Error(`Cannot find module '${fileUrl}'`, { cause });
-					error.code = "ERR_MODULE_NOT_FOUND";
-					throw error;
+					throw error.code = "ERR_MODULE_NOT_FOUND", error;
 				}
 			}
 			throw new Error(`[vitest] Failed to transform ${fileUrl}. Does the file exist?`);
 		});
 	}
 	createViteClientModule() {
-		const identifier = CLIENT_ID;
-		const cached = this.esm.resolveCachedModule(identifier);
+		const identifier = CLIENT_ID, cached = this.esm.resolveCachedModule(identifier);
 		if (cached) return cached;
-		const stub = this.options.viteClientModule;
-		const moduleKeys = Object.keys(stub);
-		const module = new SyntheticModule(moduleKeys, function() {
+		const stub = this.options.viteClientModule, moduleKeys = Object.keys(stub), module = new SyntheticModule(moduleKeys, function() {
 			moduleKeys.forEach((key) => {
 				this.setExport(key, stub[key]);
 			});
@@ -506,25 +459,16 @@ class ViteExecutor {
 			context: this.options.context,
 			identifier
 		});
-		this.esm.cacheModule(identifier, module);
-		return module;
+		return this.esm.cacheModule(identifier, module), module;
 	}
 	canResolve = (fileUrl) => {
-		const transformMode = this.workerState.environment.transformMode;
-		if (transformMode !== "web") return false;
 		if (fileUrl === CLIENT_FILE) return true;
-		const config = this.workerState.config.deps?.web || {};
-		const [modulePath] = fileUrl.split("?");
-		if (config.transformCss && CSS_LANGS_RE.test(modulePath)) return true;
-		if (config.transformAssets && KNOWN_ASSET_RE.test(modulePath)) return true;
-		if (toArray(config.transformGlobPattern).some((pattern) => pattern.test(modulePath))) return true;
-		return false;
+		const config = this.workerState.config.deps?.web || {}, [modulePath] = fileUrl.split("?");
+		return !!(config.transformCss && CSS_LANGS_RE.test(modulePath) || config.transformAssets && KNOWN_ASSET_RE.test(modulePath) || toArray(config.transformGlobPattern).some((pattern) => pattern.test(modulePath)));
 	};
 }
 
-const { existsSync, statSync } = fs;
-// always defined when we use vm pool
-const nativeResolve = import.meta.resolve;
+const { existsSync } = fs, nativeResolve = import.meta.resolve;
 // TODO: improve Node.js strict mode support in #2854
 class ExternalModulesExecutor {
 	cjs;
@@ -535,28 +479,21 @@ class ExternalModulesExecutor {
 	resolvers = [];
 	#networkSupported = null;
 	constructor(options) {
-		this.options = options;
-		this.context = options.context;
-		this.fs = options.fileMap;
-		this.esm = new EsmExecutor(this, { context: this.context });
-		this.cjs = new CommonjsExecutor({
+		this.options = options, this.context = options.context, this.fs = options.fileMap, this.esm = new EsmExecutor(this, { context: this.context }), this.cjs = new CommonjsExecutor({
 			context: this.context,
 			importModuleDynamically: this.importModuleDynamically,
 			fileMap: options.fileMap,
 			interopDefault: options.interopDefault
-		});
-		this.vite = new ViteExecutor({
+		}), this.vite = new ViteExecutor({
 			esmExecutor: this.esm,
 			context: this.context,
 			transform: options.transform,
 			viteClientModule: options.viteClientModule
-		});
-		this.resolvers = [this.vite.resolve];
+		}), this.resolvers = [this.vite.resolve];
 	}
 	async import(identifier) {
 		const module = await this.createModule(identifier);
-		await this.esm.evaluateModule(module);
-		return module.namespace;
+		return await this.esm.evaluateModule(module), module.namespace;
 	}
 	require(identifier) {
 		return this.cjs.require(identifier);
@@ -582,26 +519,6 @@ class ExternalModulesExecutor {
 		// import.meta.resolve can be asynchronous in older +18 Node versions
 		return nativeResolve(specifier, parent);
 	}
-	findNearestPackageData(basedir) {
-		const originalBasedir = basedir;
-		const packageCache = this.options.packageCache;
-		while (basedir) {
-			const cached = getCachedData(packageCache, basedir, originalBasedir);
-			if (cached) return cached;
-			const pkgPath = join(basedir, "package.json");
-			try {
-				if (statSync(pkgPath, { throwIfNoEntry: false })?.isFile()) {
-					const pkgData = JSON.parse(this.fs.readFile(pkgPath));
-					if (packageCache) setCacheData(packageCache, pkgData, basedir, originalBasedir);
-					return pkgData;
-				}
-			} catch {}
-			const nextBasedir = dirname$1(basedir);
-			if (nextBasedir === basedir) break;
-			basedir = nextBasedir;
-		}
-		return {};
-	}
 	getModuleInformation(identifier) {
 		if (identifier.startsWith("data:")) return {
 			type: "data",
@@ -609,7 +526,7 @@ class ExternalModulesExecutor {
 			path: identifier
 		};
 		const extension = extname(identifier);
-		if (extension === ".node" || isNodeBuiltin(identifier)) return {
+		if (extension === ".node" || isBuiltin(identifier)) return {
 			type: "builtin",
 			url: identifier,
 			path: identifier
@@ -619,9 +536,7 @@ class ExternalModulesExecutor {
 			url: identifier,
 			path: identifier
 		};
-		const isFileUrl = identifier.startsWith("file://");
-		const pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier;
-		const fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
+		const isFileUrl = identifier.startsWith("file://"), pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier, fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
 		let type;
 		if (this.vite.canResolve(fileUrl)) type = "vite";
 		else if (extension === ".mjs") type = "module";
@@ -631,7 +546,7 @@ class ExternalModulesExecutor {
 		// cf. ESM_FILE_FORMAT(url) in https://nodejs.org/docs/latest-v20.x/api/esm.html#resolution-algorithm
 		type = "wasm";
 		else {
-			const pkgData = this.findNearestPackageData(normalize(pathUrl));
+			const pkgData = findNearestPackageData(normalize(pathUrl));
 			type = pkgData.type === "module" ? "module" : "commonjs";
 		}
 		return {
@@ -645,9 +560,8 @@ class ExternalModulesExecutor {
 		// create ERR_MODULE_NOT_FOUND on our own since latest NodeJS's import.meta.resolve doesn't throw on non-existing namespace or path
 		// https://github.com/nodejs/node/pull/49038
 		if ((type === "module" || type === "commonjs" || type === "wasm") && !existsSync(path)) {
-			const error = new Error(`Cannot find ${isBareImport(path) ? "package" : "module"} '${path}'`);
-			error.code = "ERR_MODULE_NOT_FOUND";
-			throw error;
+			const error = /* @__PURE__ */ new Error(`Cannot find ${isBareImport(path) ? "package" : "module"} '${path}'`);
+			throw error.code = "ERR_MODULE_NOT_FOUND", error;
 		}
 		switch (type) {
 			case "data": return this.esm.createDataModule(identifier);
@@ -679,78 +593,115 @@ class FileMap {
 		const cached = this.fsCache.get(path);
 		if (cached != null) return cached;
 		const source = await promises.readFile(path, "utf-8");
-		this.fsCache.set(path, source);
-		return source;
+		return this.fsCache.set(path, source), source;
 	}
 	readFile(path) {
 		const cached = this.fsCache.get(path);
 		if (cached != null) return cached;
 		const source = readFileSync(path, "utf-8");
-		this.fsCache.set(path, source);
-		return source;
+		return this.fsCache.set(path, source), source;
 	}
 	readBuffer(path) {
 		const cached = this.fsBufferCache.get(path);
 		if (cached != null) return cached;
 		const buffer = readFileSync(path);
-		this.fsBufferCache.set(path, buffer);
-		return buffer;
+		return this.fsBufferCache.set(path, buffer), buffer;
 	}
 }
 
-const entryFile = pathToFileURL(resolve(distDir, "workers/runVmTests.js")).href;
-const fileMap = new FileMap();
-const packageCache = /* @__PURE__ */ new Map();
+const entryFile = pathToFileURL(resolve(distDir, "workers/runVmTests.js")).href, fileMap = new FileMap(), packageCache = /* @__PURE__ */ new Map();
 async function runVmTests(method, state) {
 	const { environment, ctx, rpc } = state;
 	if (!environment.setupVM) {
-		const envName = ctx.environment.name;
-		const packageId = envName[0] === "." ? envName : `vitest-environment-${envName}`;
+		const envName = ctx.environment.name, packageId = envName[0] === "." ? envName : `vitest-environment-${envName}`;
 		throw new TypeError(`Environment "${ctx.environment.name}" is not a valid environment. Path "${packageId}" doesn't support vm environment because it doesn't provide "setupVM" method.`);
 	}
 	const vm = await environment.setupVM(ctx.environment.options || ctx.config.environmentOptions || {});
-	state.durations.environment = performance.now() - state.durations.environment;
-	process.env.VITEST_VM_POOL = "1";
-	if (!vm.getVmContext) throw new TypeError(`Environment ${environment.name} doesn't provide "getVmContext" method. It should return a context created by "vm.createContext" method.`);
+	if (state.durations.environment = performance.now() - state.durations.environment, process.env.VITEST_VM_POOL = "1", !vm.getVmContext) throw new TypeError(`Environment ${environment.name} doesn't provide "getVmContext" method. It should return a context created by "vm.createContext" method.`);
 	const context = vm.getVmContext();
 	if (!isContext(context)) throw new TypeError(`Environment ${environment.name} doesn't provide a valid context. It should be created by "vm.createContext" method.`);
-	provideWorkerState(context, state);
-	// this is unfortunately needed for our own dependencies
-	// we need to find a way to not rely on this by default
-	// because browser doesn't provide these globals
-	context.process = process;
-	context.global = context;
-	context.console = state.config.disableConsoleIntercept ? console : createCustomConsole(state);
-	// TODO: don't hardcode setImmediate in fake timers defaults
-	context.setImmediate = setImmediate;
-	context.clearImmediate = clearImmediate;
-	const stubs = getDefaultRequestStubs(context);
-	const externalModulesExecutor = new ExternalModulesExecutor({
+	provideWorkerState(context, state), context.process = process, context.global = context, context.console = state.config.disableConsoleIntercept ? console : createCustomConsole(state), context.setImmediate = setImmediate, context.clearImmediate = clearImmediate;
+	const stubs = getDefaultRequestStubs(context), externalModulesExecutor = new ExternalModulesExecutor({
 		context,
 		fileMap,
 		packageCache,
 		transform: rpc.transform,
 		viteClientModule: stubs["/@vite/client"]
-	});
-	const executor = await startVitestExecutor({
+	}), moduleRunner = startVitestModuleRunner({
 		context,
-		moduleCache: state.moduleCache,
+		evaluatedModules: state.evaluatedModules,
 		state,
 		externalModulesExecutor,
-		requestStubs: stubs
+		createImportMeta: createNodeImportMeta
 	});
-	context.__vitest_mocker__ = executor.mocker;
-	const { run } = await executor.importExternalModule(entryFile);
-	const fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
+	if (Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
+		value: {
+			context,
+			externalModulesExecutor
+		},
+		configurable: true,
+		enumerable: false,
+		writable: false
+	}), context.__vitest_mocker__ = moduleRunner.mocker, ctx.config.serializedDefines) try {
+		runInContext(ctx.config.serializedDefines, context, { filename: "virtual:load-defines.js" });
+	} catch (error) {
+		throw new Error(`Failed to load custom "defines": ${error.message}`);
+	}
+	await moduleRunner.mocker.initializeSpyModule();
+	const { run } = await moduleRunner.import(entryFile), fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
 		filepath: f,
 		testLocations: void 0
 	} : f);
 	try {
-		await run(method, fileSpecs, ctx.config, executor);
+		await run(method, fileSpecs, ctx.config, moduleRunner);
 	} finally {
-		await vm.teardown?.();
-		state.environmentTeardownRun = true;
+		await vm.teardown?.(), state.environmentTeardownRun = true;
+	}
+}
+
+class ForksVmWorker {
+	getRpcOptions() {
+		return createForksRpcOptions(v8);
+	}
+	async executeTests(method, state) {
+		const exit = process.exit;
+		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
+		try {
+			await runVmTests(method, state);
+		} finally {
+			process.exit = exit;
+		}
+	}
+	runTests(state) {
+		return this.executeTests("run", state);
+	}
+	collectTests(state) {
+		return this.executeTests("collect", state);
 	}
 }
+const worker$1 = new ForksVmWorker();
+
+class ThreadsVmWorker {
+	getRpcOptions(ctx) {
+		return createThreadsRpcOptions(ctx);
+	}
+	runTests(state) {
+		return runVmTests("run", state);
+	}
+	collectTests(state) {
+		return runVmTests("collect", state);
+	}
+}
+const worker = new ThreadsVmWorker();
+
+async function run(ctx) {
+	await execute("run", ctx, ctx.pool === "vmForks" ? worker$1 : worker);
+}
+async function collect(ctx) {
+	await execute("collect", ctx, ctx.pool === "vmForks" ? worker$1 : worker);
+}
+async function teardown() {
+	await teardown$1();
+}
 
-export { runVmTests as r };
+export { collect, run, teardown };