vitest 4.0.6 → 4.0.7

package/dist/chunks/{resolveSnapshotEnvironment.BZzLjzkh.js → index.DEPqWSIZ.js}

@@ -1,13 +1,23 @@
 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.Dv1Jt3i2.js';
+import { r as rpc } from './rpc.D38ahn14.js';
 import { g as getWorkerState } from './utils.CG9h5ccR.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.CnspO-X4.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.B6aJd6T3.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
 }
 
+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;
+}
+
 async function getTestRunnerConstructor(config, moduleRunner) {
 	if (!config.runner) return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
 	const mod = await moduleRunner.import(config.runner);
@@ -67,14 +77,4 @@ async function resolveTestRunner(config, moduleRunner) {
 	}, 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/{index.CpdwpN7L.js → index.jMQYiEWE.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.BL8Hg4Uk.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.CVpyv-Zg.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils/helpers';
 

package/dist/chunks/{init-forks.CSGFj9zN.js → init-forks.IU-xQ2_X.js}

@@ -1,5 +1,5 @@
 import v8 from 'node:v8';
-import { i as init } from './init.DUeOfNO9.js';
+import { i as init } from './init.fmH9J833.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them
@@ -16,7 +16,8 @@ function workerInit(options) {
 		serialize: v8.serialize,
 		deserialize: (v) => v8.deserialize(Buffer.from(v)),
 		runTests: (state) => executeTests("run", state),
-		collectTests: (state) => executeTests("collect", state)
+		collectTests: (state) => executeTests("collect", state),
+		setup: options.setup
 	});
 	async function executeTests(method, state) {
 		state.ctx.config = unwrapSerializableConfig(state.ctx.config);

package/dist/chunks/{init-threads.CIJLeFO8.js → init-threads.C_NWvZkU.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.DUeOfNO9.js';
+import { i as init } from './init.fmH9J833.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {
@@ -10,7 +10,8 @@ function workerInit(options) {
 		off: (callback) => parentPort.off("message", callback),
 		teardown: () => parentPort.removeAllListeners("message"),
 		runTests: async (state) => runTests("run", state),
-		collectTests: async (state) => runTests("collect", state)
+		collectTests: async (state) => runTests("collect", state),
+		setup: options.setup
 	});
 }
 

package/dist/chunks/{init.DUeOfNO9.js → init.fmH9J833.js}

@@ -1,15 +1,15 @@
-import { serializeError } from '@vitest/utils/error';
-import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { readFileSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
 import { ModuleRunner } from 'vite/module-runner';
-import { b as VitestTransport } from './startModuleRunner.Di-EZqh0.js';
-import { e as environments } from './index.DV0mQLEO.js';
+import { b as VitestTransport } from './startModuleRunner.Cn7hCL7D.js';
+import { e as environments } from './index.CWIFvlX5.js';
+import { serializeError } from '@vitest/utils/error';
+import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.D38ahn14.js';
+import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { s as setupInspect } from './inspector.DLZxSeU3.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
-import { c as createRuntimeRpc, a as rpcDone } from './rpc.Dv1Jt3i2.js';
 
 function isBuiltinEnvironment(env) {
 	return env in environments;
@@ -44,10 +44,9 @@ async function createEnvironmentLoader(root, rpc) {
 	}
 	return _loaders.get(root);
 }
-async function loadEnvironment(ctx, rpc) {
-	const name = ctx.environment.name;
+async function loadEnvironment(name, root, rpc) {
 	if (isBuiltinEnvironment(name)) return { environment: environments[name] };
-	const root = ctx.config.root, loader = await createEnvironmentLoader(root, rpc), packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__"))?.id ?? resolve(root, name), pkg = await loader.import(packageId);
+	const loader = await createEnvironmentLoader(root, rpc), packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__"))?.id ?? resolve(root, name), pkg = await loader.import(packageId);
 	if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
 	const environment = pkg.default;
 	if (environment.transformMode != null && environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web", received "${environment.transformMode}".`);
@@ -62,10 +61,7 @@ async function loadEnvironment(ctx, rpc) {
 
 const resolvingModules = /* @__PURE__ */ new Set(), globalListeners = /* @__PURE__ */ new Set();
 async function execute(method, ctx, worker) {
-	const prepareStart = performance.now(), cleanups = [setupInspect(ctx)];
-	let environmentLoader;
-	// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
-	const { rpc, onCancel } = createRuntimeRpc(worker);
+	const prepareStart = performance.now(), cleanups = [setupInspect(ctx)], rpc = ctx.rpc;
 	try {
 		// do not close the RPC channel so that we can get the error messages sent to the main thread
 		cleanups.push(async () => {
@@ -73,21 +69,19 @@ async function execute(method, ctx, worker) {
 				reject(/* @__PURE__ */ new Error(`[vitest-worker]: Closing rpc while "${method}" was pending`));
 			}));
 		});
-		const beforeEnvironmentTime = performance.now(), { environment, loader } = await loadEnvironment(ctx, rpc);
-		environmentLoader = loader;
 		const state = {
 			ctx,
 			evaluatedModules: new VitestEvaluatedModules(),
 			resolvingModules,
 			moduleExecutionInfo: /* @__PURE__ */ new Map(),
 			config: ctx.config,
-			onCancel,
-			environment,
+			environment: null,
 			durations: {
-				environment: beforeEnvironmentTime,
+				environment: 0,
 				prepare: prepareStart
 			},
 			rpc,
+			onCancel,
 			onCleanup: (listener) => globalListeners.add(listener),
 			providedContext: ctx.providedContext,
 			onFilterStackTrace(stack) {
@@ -98,7 +92,7 @@ async function execute(method, ctx, worker) {
 		if (!worker[methodName] || typeof worker[methodName] !== "function") throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
 		await worker[methodName](state);
 	} finally {
-		await rpcDone().catch(() => {}), await Promise.all(cleanups.map((fn) => fn())).catch(() => {}), await environmentLoader?.close();
+		await rpcDone().catch(() => {}), await Promise.all(cleanups.map((fn) => fn())).catch(() => {});
 	}
 }
 function run(ctx, worker) {
@@ -110,6 +104,7 @@ function collect(ctx, worker) {
 async function teardown() {
 	await Promise.all([...globalListeners].map((l) => l()));
 }
+const env = process.env;
 function createImportMetaEnvProxy() {
 	// packages/vitest/src/node/plugins/index.ts:146
 	const booleanKeys = [
@@ -117,7 +112,7 @@ function createImportMetaEnvProxy() {
 		"PROD",
 		"SSR"
 	];
-	return new Proxy(process.env, {
+	return new Proxy(env, {
 		get(_, key) {
 			if (typeof key === "string") return booleanKeys.includes(key) ? !!process.env[key] : process.env[key];
 		},
@@ -135,19 +130,37 @@ let reportMemory = false;
 /** @experimental */
 function init(worker) {
 	worker.on(onMessage);
-	let runPromise, isRunning = false;
+	let runPromise, isRunning = false, workerTeardown, setupContext;
 	function send(response) {
 		worker.post(worker.serialize ? worker.serialize(response) : response);
 	}
 	async function onMessage(rawMessage) {
 		const message = worker.deserialize ? worker.deserialize(rawMessage) : rawMessage;
 		if (message?.__vitest_worker_request__ === true) switch (message.type) {
-			case "start":
-				reportMemory = message.options.reportMemory, send({
-					type: "started",
-					__vitest_worker_response__
-				});
+			case "start": {
+				reportMemory = message.options.reportMemory;
+				const { environment, config, pool } = message.context;
+				try {
+					const rpc = createRuntimeRpc(worker);
+					setupContext = {
+						environment,
+						config,
+						pool,
+						rpc,
+						projectName: config.name || ""
+					}, workerTeardown = await worker.setup?.(setupContext), send({
+						type: "started",
+						__vitest_worker_response__
+					});
+				} catch (error) {
+					send({
+						type: "started",
+						__vitest_worker_response__,
+						error: serializeError(error)
+					});
+				}
 				break;
+			}
 			case "run":
 				// Prevent concurrent execution if worker is already running
 				if (isRunning) {
@@ -158,9 +171,22 @@ function init(worker) {
 					});
 					return;
 				}
-				isRunning = true, process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
 				try {
-					runPromise = run(message.context, worker).catch((error) => serializeError(error));
+					process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
+				} catch (error) {
+					return send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error: serializeError(error),
+						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+					});
+				}
+				isRunning = true;
+				try {
+					runPromise = run({
+						...setupContext,
+						...message.context
+					}, worker).catch((error) => serializeError(error));
 					const error = await runPromise;
 					send({
 						type: "testfileFinished",
@@ -182,9 +208,22 @@ function init(worker) {
 					});
 					return;
 				}
-				isRunning = true, process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
 				try {
-					runPromise = collect(message.context, worker).catch((error) => serializeError(error));
+					process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
+				} catch (error) {
+					return send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error: serializeError(error),
+						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+					});
+				}
+				isRunning = true;
+				try {
+					runPromise = collect({
+						...setupContext,
+						...message.context
+					}, worker).catch((error) => serializeError(error));
 					const error = await runPromise;
 					send({
 						type: "testfileFinished",
@@ -196,18 +235,26 @@ function init(worker) {
 					runPromise = void 0, isRunning = false;
 				}
 				break;
-			case "stop": {
+			case "stop":
 				await runPromise;
-				const error = await teardown().catch((error) => serializeError(error));
-				send({
-					type: "stopped",
-					error,
-					__vitest_worker_response__
-				}), worker.teardown?.();
+				try {
+					const error = await teardown().catch((error) => serializeError(error));
+					await workerTeardown?.(), send({
+						type: "stopped",
+						error,
+						__vitest_worker_response__
+					});
+				} catch (error) {
+					send({
+						type: "stopped",
+						error: serializeError(error),
+						__vitest_worker_response__
+					});
+				}
+				worker.teardown?.();
 				break;
-			}
 		}
 	}
 }
 
-export { init as i };
+export { init as i, loadEnvironment as l };

package/dist/chunks/{moduleRunner.d.TP-w6tIQ.d.ts → moduleRunner.d.DEkTotCv.d.ts}

@@ -2,7 +2,7 @@ import * as _vitest_spy from '@vitest/spy';
 import vm from 'node:vm';
 import * as viteModuleRunner from 'vite/module-runner';
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, EvaluatedModules } from 'vite/module-runner';
-import { R as RuntimeRPC, d as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.B4Hthdvt.js';
+import { R as RuntimeRPC, e as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.D25zYZ7N.js';
 import { MockedModule, MockedModuleType } from '@vitest/mocker';
 import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './mocker.d.BE_2ls6u.js';
 

package/dist/chunks/{plugin.d.lctzD3Wk.d.ts → plugin.d.Cpes8Bt6.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.PEs0tXod.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.CSNcMDxF.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;

package/dist/chunks/{reporters.d.PEs0tXod.d.ts → reporters.d.CSNcMDxF.d.ts}

@@ -1,13 +1,13 @@
 import { TaskMeta, Suite, File, TestAnnotation, ImportDuration, Test, Task, TaskResultPack, FileSpecification, CancelReason, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
 import { TestError, SerializedError, Arrayable, ParsedStack, Awaitable } from '@vitest/utils';
-import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, C as ContextRPC, L as LabelColor } from './worker.d.B4Hthdvt.js';
+import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, d as ContextTestEnvironment, f as WorkerTestEnvironment, g as WorkerExecuteContext, L as LabelColor } from './worker.d.D25zYZ7N.js';
 import { Writable } from 'node:stream';
 import { TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { BrowserCommands } from 'vitest/browser';
 import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.BTfZNUu9.js';
-import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.ScGeWTou.js';
+import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.-LKfRopd.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -1445,6 +1445,7 @@ interface BrowserConfigOptions {
 	* Isolate test environment after each test
 	*
 	* @default true
+	* @deprecated use top-level `isolate` instead
 	*/
 	isolate?: boolean;
 	/**
@@ -1452,6 +1453,7 @@ interface BrowserConfigOptions {
 	* This option only has effect in headless mode (enabled in CI by default)
 	*
 	* @default // Same as "test.fileParallelism"
+	* @deprecated use top-level `fileParallelism` instead
 	*/
 	fileParallelism?: boolean;
 	/**
@@ -1866,7 +1868,7 @@ interface PoolOptions {
 	project: TestProject;
 	method: "run" | "collect";
 	cacheFs?: boolean;
-	environment: string;
+	environment: ContextTestEnvironment;
 	execArgv: string[];
 	env: Partial<NodeJS.ProcessEnv>;
 }
@@ -1901,7 +1903,8 @@ interface PoolTask {
 	* so modifying it once will modify it for every task.
 	*/
 	execArgv: string[];
-	context: ContextRPC;
+	context: WorkerExecuteContext;
+	environment: ContextTestEnvironment;
 	memoryLimit: number | null;
 }
 type WorkerRequest = {
@@ -1911,15 +1914,20 @@ type WorkerRequest = {
 	options: {
 		reportMemory: boolean;
 	};
+	context: {
+		environment: WorkerTestEnvironment;
+		config: SerializedConfig;
+		pool: string;
+	};
 } | {
 	type: "stop";
 } | {
 	type: "run";
-	context: ContextRPC;
+	context: WorkerExecuteContext;
 	poolId: number;
 } | {
 	type: "collect";
-	context: ContextRPC;
+	context: WorkerExecuteContext;
 	poolId: number;
 } | {
 	type: "cancel";
@@ -1928,6 +1936,7 @@ type WorkerResponse = {
 	__vitest_worker_response__: true;
 } & ({
 	type: "started";
+	error?: unknown;
 } | {
 	type: "stopped";
 	error?: unknown;

package/dist/chunks/{rpc.Dv1Jt3i2.js → rpc.D38ahn14.js}

@@ -22,13 +22,14 @@ async function rpcDone() {
 	const awaitable = Array.from(promises);
 	return Promise.all(awaitable);
 }
-let previousRpc;
+const onCancelCallbacks = [];
+function onCancel(callback) {
+	onCancelCallbacks.push(callback);
+}
 function createRuntimeRpc(options) {
-	if (previousRpc) previousRpc.$close(), previousRpc = void 0;
-	let setCancel = (_reason) => {};
-	const onCancel = new Promise((resolve) => {
-		setCancel = resolve;
-	}), rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
+	return createSafeRpc(createBirpc({ async onCancel(reason) {
+		await Promise.all(onCancelCallbacks.map((fn) => fn(reason)));
+	} }, {
 		eventNames: [
 			"onUserConsoleLog",
 			"onCollected",
@@ -37,10 +38,6 @@ function createRuntimeRpc(options) {
 		timeout: -1,
 		...options
 	}));
-	return previousRpc = rpc, {
-		rpc,
-		onCancel
-	};
 }
 function createSafeRpc(rpc) {
 	return new Proxy(rpc, { get(target, p, handler) {
@@ -63,4 +60,4 @@ function rpc() {
 	return rpc;
 }
 
-export { rpcDone as a, createRuntimeRpc as c, rpc as r };
+export { rpcDone as a, createRuntimeRpc as c, onCancel as o, rpc as r };

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

@@ -11,6 +11,27 @@ 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());
@@ -428,27 +449,6 @@ 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 };
-		}
-	}
-}
-
 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();
@@ -575,24 +575,24 @@ function getCachedVitestImport(id, state) {
 	}) : null;
 }
 
-const dispose = [];
+// Store globals in case tests overwrite them
+const processListeners = process.listeners.bind(process), processOn = process.on.bind(process), processOff = process.off.bind(process), 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;
+		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;
 		}
 		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);
+	processOn("uncaughtException", uncaughtException), processOn("unhandledRejection", unhandledRejection), dispose.push(() => {
+		processOff("uncaughtException", uncaughtException), processOff("unhandledRejection", unhandledRejection);
 	});
 }
 

package/dist/chunks/{test.CnspO-X4.js → test.B6aJd6T3.js}

@@ -8,7 +8,7 @@ import { getTests, getNames, getTestName } from '@vitest/runner/utils';
 import { processError } from '@vitest/utils/error';
 import { normalize } from 'pathe';
 import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.BZvkKVkM.js';
-import { r as rpc } from './rpc.Dv1Jt3i2.js';
+import { r as rpc } from './rpc.D38ahn14.js';
 
 function createBenchmarkResult(name) {
 	return {

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

@@ -1,6 +1,7 @@
 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 { distDir } from '../path.js';
 import { createCustomConsole } from './console.CTJL2nuH.js';
 import fs from 'node:fs';
@@ -10,7 +11,7 @@ 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.Di-EZqh0.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';
 
 function interopCommonJsModule(interopDefault, mod) {
@@ -585,13 +586,13 @@ class FileMap {
 
 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 { 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}`;
 		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() - 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.`);
+	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.`);
 	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;
@@ -629,7 +630,7 @@ async function runVmTests(method, state) {
 	try {
 		await run(method, fileSpecs, ctx.config, moduleRunner);
 	} finally {
-		await vm.teardown?.(), state.environmentTeardownRun = true;
+		await vm.teardown?.();
 	}
 }
 

package/dist/chunks/{worker.d.B4Hthdvt.d.ts → worker.d.D25zYZ7N.d.ts}

@@ -167,18 +167,37 @@ interface ContextTestEnvironment {
 	name: string;
 	options: Record<string, any> | null;
 }
+interface WorkerTestEnvironment {
+	name: string;
+	options: Record<string, any> | null;
+}
 type TestExecutionMethod = "run" | "collect";
+interface WorkerExecuteContext {
+	files: FileSpecification[];
+	providedContext: Record<string, any>;
+	invalidates?: string[];
+	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
+	workerId: number;
+}
 interface ContextRPC {
 	pool: string;
 	config: SerializedConfig;
 	projectName: string;
+	environment: WorkerTestEnvironment;
+	rpc: WorkerRPC;
 	files: FileSpecification[];
-	environment: ContextTestEnvironment;
 	providedContext: Record<string, any>;
 	invalidates?: string[];
 	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
 	workerId: number;
 }
+interface WorkerSetupContext {
+	environment: WorkerTestEnvironment;
+	pool: string;
+	config: SerializedConfig;
+	projectName: string;
+	rpc: WorkerRPC;
+}
 interface WorkerGlobalState {
 	ctx: ContextRPC;
 	config: SerializedConfig;
@@ -194,11 +213,10 @@ interface WorkerGlobalState {
 		SSR: boolean;
 	};
 	environment: Environment;
-	environmentTeardownRun?: boolean;
-	onCancel: Promise<CancelReason>;
 	evaluatedModules: EvaluatedModules;
 	resolvingModules: Set<string>;
 	moduleExecutionInfo: Map<string, any>;
+	onCancel: (listener: (reason: CancelReason) => unknown) => void;
 	onCleanup: (listener: () => unknown) => void;
 	providedContext: Record<string, any>;
 	durations: {
@@ -208,4 +226,4 @@ interface WorkerGlobalState {
 	onFilterStackTrace?: (trace: string) => string;
 }
 
-export type { AfterSuiteRunMeta as A, BirpcOptions as B, ContextRPC as C, LabelColor as L, ModuleGraphData as M, ProvidedContext as P, RuntimeRPC as R, TestExecutionMethod as T, UserConsoleLog as U, WorkerGlobalState as W, BirpcReturn as a, RunnerRPC as b, ContextTestEnvironment as c, ResolveFunctionResult as d };
+export type { AfterSuiteRunMeta as A, BirpcOptions as B, ContextRPC as C, LabelColor as L, ModuleGraphData as M, ProvidedContext as P, RuntimeRPC as R, TestExecutionMethod as T, UserConsoleLog as U, WorkerGlobalState as W, WorkerSetupContext as a, BirpcReturn as b, RunnerRPC as c, ContextTestEnvironment as d, ResolveFunctionResult as e, WorkerTestEnvironment as f, WorkerExecuteContext as g };

package/dist/cli.js

@@ -1,10 +1,10 @@
-import { c as createCLI } from './chunks/cac.BBqWH4nd.js';
+import { c as createCLI } from './chunks/cac.G9DAn-c7.js';
 import '@vitest/utils/helpers';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
 import './chunks/constants.D_Q9UYh-.js';
-import './chunks/index.BL8Hg4Uk.js';
+import './chunks/index.CVpyv-Zg.js';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:perf_hooks';