vitest 4.0.7 → 4.0.9

package/dist/chunks/{vm.BL7_zzOr.js → vm.DXN8eCh2.js}

@@ -1,9 +1,9 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import vm, { isContext, runInContext } from 'node:vm';
 import { dirname, basename, extname, normalize, resolve } from 'pathe';
-import { l as loadEnvironment } from './init.fmH9J833.js';
+import { l as loadEnvironment } from './init.BQhNfT0h.js';
 import { distDir } from '../path.js';
-import { createCustomConsole } from './console.CTJL2nuH.js';
+import { createCustomConsole } from './console.Cf-YriPC.js';
 import fs from 'node:fs';
 import { createRequire, Module, isBuiltin } from 'node:module';
 import { toArray, isBareImport } from '@vitest/utils/helpers';
@@ -11,8 +11,8 @@ import { findNearestPackageData } from '@vitest/utils/resolver';
 import { dirname as dirname$1 } from 'node:path';
 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 './startModuleRunner.Cn7hCL7D.js';
-import { p as provideWorkerState } from './utils.CG9h5ccR.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.DLjmA_wU.js';
+import { p as provideWorkerState } from './utils.DvEY5TfP.js';
 
 function interopCommonJsModule(interopDefault, mod) {
 	if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) return {
@@ -21,8 +21,11 @@ function interopCommonJsModule(interopDefault, mod) {
 		defaultExport: mod
 	};
 	if (interopDefault !== false && "__esModule" in mod && !isPrimitive(mod.default)) {
-		const defaultKets = Object.keys(mod.default), moduleKeys = Object.keys(mod), allKeys = new Set([...defaultKets, ...moduleKeys]);
-		return allKeys.delete("default"), {
+		const defaultKets = Object.keys(mod.default);
+		const moduleKeys = Object.keys(mod);
+		const allKeys = new Set([...defaultKets, ...moduleKeys]);
+		allKeys.delete("default");
+		return {
 			keys: Array.from(allKeys),
 			moduleExports: new Proxy(mod, { get(mod, prop) {
 				return mod[prop] ?? mod.default?.[prop];
@@ -42,7 +45,8 @@ function isPrimitive(obj) {
 const SyntheticModule = vm.SyntheticModule;
 const SourceTextModule = vm.SourceTextModule;
 
-const _require = createRequire(import.meta.url), requiresCache = /* @__PURE__ */ new WeakMap();
+const _require = createRequire(import.meta.url);
+const requiresCache = /* @__PURE__ */ new WeakMap();
 class CommonjsExecutor {
 	context;
 	requireCache = /* @__PURE__ */ new Map();
@@ -54,8 +58,12 @@ 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), executor = this;
+		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.Module = class Module$1 {
 			exports;
 			isPreloading = false;
@@ -67,13 +75,20 @@ class CommonjsExecutor {
 			path;
 			paths = [];
 			constructor(id = "", parent) {
-				this.exports = primitives.Object.create(Object.prototype), this.path = dirname(id), this.id = id, this.filename = id, this.loaded = false, this.parent = 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;
 			}
 			get require() {
 				const require = requiresCache.get(this);
 				if (require) return require;
 				const _require = Module$1.createRequire(this.id);
-				return requiresCache.set(this, _require), _require;
+				requiresCache.set(this, _require);
+				return _require;
 			}
 			static getSourceMapsSupport = () => ({
 				enabled: false,
@@ -90,16 +105,19 @@ class CommonjsExecutor {
 				throw new Error(`[vitest] "registerHooks" is not available when running in Vitest.`);
 			};
 			_compile(code, filename) {
-				const cjsModule = Module$1.wrap(code), script = new vm.Script(cjsModule, {
+				const cjsModule = Module$1.wrap(code);
+				const 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), __dirname = dirname(filename);
+				const fn = script.runInContext(executor.context);
+				const __dirname = dirname(filename);
 				executor.requireCache.set(filename, this);
 				try {
-					return fn(this.exports, this.require, this, filename, __dirname), this.exports;
+					fn(this.exports, this.require, this, filename, __dirname);
+					return this.exports;
 				} finally {
 					this.loaded = true;
 				}
@@ -144,7 +162,9 @@ 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);
@@ -155,17 +175,22 @@ class CommonjsExecutor {
 		m.exports = JSON.parse(code);
 	};
 	createRequire = (filename) => {
-		const _require = createRequire(filename), require = ((id) => {
+		const _require = createRequire(filename);
+		const require = ((id) => {
 			const resolved = _require.resolve(id);
 			if (extname(resolved) === ".node" || isBuiltin(resolved)) return this.requireCoreModule(resolved);
 			const module = new this.Module(resolved);
 			return this.loadCommonJSModule(module, resolved);
 		});
-		return require.resolve = _require.resolve, Object.defineProperty(require, "extensions", {
+		require.resolve = _require.resolve;
+		Object.defineProperty(require, "extensions", {
 			get: () => this.extensions,
 			set: () => {},
 			configurable: true
-		}), require.main = void 0, require.cache = this.publicRequireCache, require;
+		});
+		require.main = void 0;
+		require.cache = this.publicRequireCache;
+		return require;
 	};
 	createProxyCache() {
 		return new Proxy(Object.create(null), {
@@ -188,39 +213,51 @@ class CommonjsExecutor {
 		const cached = this.requireCache.get(filename);
 		if (cached) return cached.exports;
 		const extension = this.findLongestRegisteredExtension(filename);
-		return (this.extensions[extension] || this.extensions[".js"])(module, filename), module.exports;
+		(this.extensions[extension] || this.extensions[".js"])(module, filename);
+		return module.exports;
 	}
 	findLongestRegisteredExtension(filename) {
 		const name = basename(filename);
-		let currentExtension, index, startIndex = 0;
+		let currentExtension;
+		let index;
+		let startIndex = 0;
 		// eslint-disable-next-line no-cond-assign
 		while ((index = name.indexOf(".", startIndex)) !== -1) {
-			if (startIndex = index + 1, index === 0) continue;
-			if (currentExtension = name.slice(index), this.extensions[currentExtension]) return currentExtension;
+			startIndex = index + 1;
+			if (index === 0) continue;
+			currentExtension = name.slice(index);
+			if (this.extensions[currentExtension]) return currentExtension;
 		}
 		return ".js";
 	}
 	getCoreSyntheticModule(identifier) {
 		if (this.moduleCache.has(identifier)) return this.moduleCache.get(identifier);
-		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);
+		const exports$1 = this.require(identifier);
+		const keys = Object.keys(exports$1);
+		const module = new SyntheticModule([...keys, "default"], () => {
+			for (const key of keys) module.setExport(key, exports$1[key]);
+			module.setExport("default", exports$1);
 		}, {
 			context: this.context,
 			identifier
 		});
-		return this.moduleCache.set(identifier, module), module;
+		this.moduleCache.set(identifier, module);
+		return module;
 	}
 	getCjsSyntheticModule(path, identifier) {
 		if (this.moduleCache.has(identifier)) return this.moduleCache.get(identifier);
-		const exports = this.require(path), { keys, moduleExports, defaultExport } = interopCommonJsModule(this.interopDefault, exports), module = new SyntheticModule([...keys, "default"], function() {
+		const exports$1 = 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$1);
+		const module = new SyntheticModule([...keys, "default"], function() {
 			for (const key of keys) this.setExport(key, moduleExports[key]);
 			this.setExport("default", defaultExport);
 		}, {
 			context: this.context,
 			identifier
 		});
-		return this.moduleCache.set(identifier, module), module;
+		this.moduleCache.set(identifier, module);
+		return module;
 	}
 	// TODO: use this in strict mode, when available in #2854
 	// private _getNamedCjsExports(path: string): Set<string> {
@@ -269,10 +306,13 @@ class CommonjsExecutor {
 		const moduleExports = _require(identifier);
 		if (identifier === "node:module" || identifier === "module") {
 			const module = new this.Module("/module.js");
-			return module.exports = this.Module, this.builtinCache[normalized] = module, module.exports;
+			module.exports = this.Module;
+			this.builtinCache[normalized] = module;
+			return module.exports;
 		}
+		this.builtinCache[normalized] = _require.cache[normalized];
 		// TODO: should we wrap module to rethrow context errors?
-		return this.builtinCache[normalized] = _require.cache[normalized], moduleExports;
+		return moduleExports;
 	}
 }
 
@@ -283,18 +323,21 @@ 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)));
-		if (await this.esmLinkMap.get(m), m.status === "linked") await m.evaluate();
+		await this.esmLinkMap.get(m);
+		if (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);
-		return this.moduleCache.set(fileURL, promise), promise;
+		this.moduleCache.set(fileURL, promise);
+		return promise;
 	}
 	async loadEsModule(fileURL, getCode) {
 		const code = await getCode();
@@ -304,29 +347,34 @@ class EsmExecutor {
 				const result = JSON.parse(code);
 				this.setExport("default", result);
 			});
-			return this.moduleCache.set(fileURL, m), m;
+			this.moduleCache.set(fileURL, m);
+			return m;
 		}
 		const m = new SourceTextModule(code, {
 			identifier: fileURL,
 			context: this.context,
 			importModuleDynamically: this.executor.importModuleDynamically,
 			initializeImportMeta: (meta, mod) => {
-				if (meta.url = mod.identifier, mod.identifier.startsWith("file:")) {
+				meta.url = mod.identifier;
+				if (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);
 				};
 			}
 		});
-		return this.moduleCache.set(fileURL, m), m;
+		this.moduleCache.set(fileURL, m);
+		return m;
 	}
 	async createWebAssemblyModule(fileUrl, getCode) {
 		const cached = this.moduleCache.get(fileUrl);
 		if (cached) return cached;
 		const m = this.loadWebAssemblyModule(getCode(), fileUrl);
-		return this.moduleCache.set(fileUrl, m), m;
+		this.moduleCache.set(fileUrl, m);
+		return m;
 	}
 	async createNetworkModule(fileUrl) {
 		// https://nodejs.org/api/esm.html#https-and-http-imports
@@ -342,17 +390,21 @@ class EsmExecutor {
 	async loadWebAssemblyModule(source, identifier) {
 		const cached = this.moduleCache.get(identifier);
 		if (cached) return cached;
-		const wasmModule = await WebAssembly.compile(source), exports = WebAssembly.Module.exports(wasmModule), imports = WebAssembly.Module.imports(wasmModule), moduleLookup = {};
+		const wasmModule = await WebAssembly.compile(source);
+		const exports$1 = WebAssembly.Module.exports(wasmModule);
+		const imports = WebAssembly.Module.imports(wasmModule);
+		const 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);
-		return new SyntheticModule(exports.map(({ name }) => name), async function() {
+		return new SyntheticModule(exports$1.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]);
+			for (const { name } of exports$1) this.setExport(name, wasmInstance.exports[name]);
 		}, {
 			context: this.context,
 			identifier
@@ -369,12 +421,14 @@ 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, encoding = match.groups.encoding;
+		const mime = match.groups.mime;
+		const 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);
-			return this.moduleCache.set(identifier, module), module;
+			this.moduleCache.set(identifier, module);
+			return module;
 		}
 		let code = match.groups.code;
 		if (!encoding || encoding === "charset=utf-8") code = decodeURIComponent(code);
@@ -388,7 +442,8 @@ class EsmExecutor {
 				context: this.context,
 				identifier
 			});
-			return this.moduleCache.set(identifier, module), module;
+			this.moduleCache.set(identifier, module);
+			return module;
 		}
 		return this.createEsModule(identifier, () => code);
 	}
@@ -402,11 +457,13 @@ function IPmask(maskSize) {
 	return -1 << 32 - maskSize;
 }
 
-const CLIENT_ID = "/@vite/client", CLIENT_FILE = pathToFileURL(CLIENT_ID).href;
+const CLIENT_ID = "/@vite/client";
+const CLIENT_FILE = pathToFileURL(CLIENT_ID).href;
 class ViteExecutor {
 	esm;
 	constructor(options) {
-		this.options = options, this.esm = options.esmExecutor;
+		this.options = options;
+		this.esm = options.esmExecutor;
 	}
 	resolve = (identifier) => {
 		if (identifier === CLIENT_ID) return identifier;
@@ -415,7 +472,10 @@ class ViteExecutor {
 		return this.options.context.__vitest_worker__;
 	}
 	async createViteModule(fileUrl) {
-		return fileUrl === CLIENT_FILE || fileUrl === CLIENT_ID ? this.createViteClientModule() : this.esm.resolveCachedModule(fileUrl) || this.esm.createEsModule(fileUrl, async () => {
+		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 () => {
 			try {
 				const result = await this.options.transform(fileUrl);
 				if (result.code) return result.code;
@@ -423,16 +483,20 @@ class ViteExecutor {
 				// 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 });
-					throw error.code = "ERR_MODULE_NOT_FOUND", error;
+					error.code = "ERR_MODULE_NOT_FOUND";
+					throw error;
 				}
 			}
 			throw new Error(`[vitest] Failed to transform ${fileUrl}. Does the file exist?`);
 		});
 	}
 	createViteClientModule() {
-		const identifier = CLIENT_ID, cached = this.esm.resolveCachedModule(identifier);
+		const identifier = CLIENT_ID;
+		const cached = this.esm.resolveCachedModule(identifier);
 		if (cached) return cached;
-		const stub = this.options.viteClientModule, moduleKeys = Object.keys(stub), module = new SyntheticModule(moduleKeys, function() {
+		const stub = this.options.viteClientModule;
+		const moduleKeys = Object.keys(stub);
+		const module = new SyntheticModule(moduleKeys, function() {
 			moduleKeys.forEach((key) => {
 				this.setExport(key, stub[key]);
 			});
@@ -440,16 +504,23 @@ class ViteExecutor {
 			context: this.options.context,
 			identifier
 		});
-		return this.esm.cacheModule(identifier, module), module;
+		this.esm.cacheModule(identifier, module);
+		return module;
 	}
 	canResolve = (fileUrl) => {
 		if (fileUrl === CLIENT_FILE) return true;
-		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 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 { existsSync } = fs, nativeResolve = import.meta.resolve;
+const { existsSync } = fs;
+// always defined when we use vm pool
+const nativeResolve = import.meta.resolve;
 // TODO: improve Node.js strict mode support in #2854
 class ExternalModulesExecutor {
 	cjs;
@@ -460,21 +531,28 @@ 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);
-		return await this.esm.evaluateModule(module), module.namespace;
+		await this.esm.evaluateModule(module);
+		return module.namespace;
 	}
 	require(identifier) {
 		return this.cjs.require(identifier);
@@ -517,7 +595,9 @@ class ExternalModulesExecutor {
 			url: identifier,
 			path: identifier
 		};
-		const isFileUrl = identifier.startsWith("file://"), pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier, fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
+		const isFileUrl = identifier.startsWith("file://");
+		const pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier;
+		const fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
 		let type;
 		if (this.vite.canResolve(fileUrl)) type = "vite";
 		else if (extension === ".mjs") type = "module";
@@ -539,7 +619,8 @@ class ExternalModulesExecutor {
 		// https://github.com/nodejs/node/pull/49038
 		if ((type === "module" || type === "commonjs" || type === "wasm") && !existsSync(path)) {
 			const error = /* @__PURE__ */ new Error(`Cannot find ${isBareImport(path) ? "package" : "module"} '${path}'`);
-			throw error.code = "ERR_MODULE_NOT_FOUND", error;
+			error.code = "ERR_MODULE_NOT_FOUND";
+			throw error;
 		}
 		switch (type) {
 			case "data": return this.esm.createDataModule(identifier);
@@ -568,48 +649,70 @@ class FileMap {
 		const cached = this.fsCache.get(path);
 		if (cached != null) return cached;
 		const source = await promises.readFile(path, "utf-8");
-		return this.fsCache.set(path, source), source;
+		this.fsCache.set(path, source);
+		return source;
 	}
 	readFile(path) {
 		const cached = this.fsCache.get(path);
 		if (cached != null) return cached;
 		const source = readFileSync(path, "utf-8");
-		return this.fsCache.set(path, source), source;
+		this.fsCache.set(path, source);
+		return source;
 	}
 	readBuffer(path) {
 		const cached = this.fsBufferCache.get(path);
 		if (cached != null) return cached;
 		const buffer = readFileSync(path);
-		return this.fsBufferCache.set(path, buffer), buffer;
+		this.fsBufferCache.set(path, buffer);
+		return buffer;
 	}
 }
 
-const entryFile = pathToFileURL(resolve(distDir, "workers/runVmTests.js")).href, fileMap = new FileMap(), packageCache = /* @__PURE__ */ new Map();
+const entryFile = pathToFileURL(resolve(distDir, "workers/runVmTests.js")).href;
+const fileMap = new FileMap();
+const packageCache = /* @__PURE__ */ new Map();
 async function runVmTests(method, state) {
-	const { ctx, rpc } = state, beforeEnvironmentTime = performance.now(), { environment } = await loadEnvironment(ctx.environment.name, ctx.config.root, rpc);
-	if (state.environment = environment, !environment.setupVM) {
-		const envName = ctx.environment.name, packageId = envName[0] === "." ? envName : `vitest-environment-${envName}`;
+	const { ctx, rpc } = state;
+	const beforeEnvironmentTime = performance.now();
+	const { environment } = await loadEnvironment(ctx.environment.name, ctx.config.root, rpc);
+	state.environment = environment;
+	if (!environment.setupVM) {
+		const envName = ctx.environment.name;
+		const 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 || {});
-	if (state.durations.environment = performance.now() - beforeEnvironmentTime, 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.`);
+	state.durations.environment = performance.now() - beforeEnvironmentTime;
+	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.`);
 	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), 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({
+	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({
 		context,
 		fileMap,
 		packageCache,
 		transform: rpc.transform,
 		viteClientModule: stubs["/@vite/client"]
-	}), moduleRunner = startVitestModuleRunner({
+	});
+	const moduleRunner = startVitestModuleRunner({
 		context,
 		evaluatedModules: state.evaluatedModules,
 		state,
 		externalModulesExecutor,
 		createImportMeta: createNodeImportMeta
 	});
-	if (Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
+	Object.defineProperty(context, VITEST_VM_CONTEXT_SYMBOL, {
 		value: {
 			context,
 			externalModulesExecutor
@@ -617,13 +720,16 @@ async function runVmTests(method, state) {
 		configurable: true,
 		enumerable: false,
 		writable: false
-	}), context.__vitest_mocker__ = moduleRunner.mocker, ctx.config.serializedDefines) try {
+	});
+	context.__vitest_mocker__ = moduleRunner.mocker;
+	if (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" ? {
+	const { run } = await moduleRunner.import(entryFile);
+	const fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
 		filepath: f,
 		testLocations: void 0
 	} : f);