vitest 3.2.4 → 4.0.0-beta.10

package/dist/chunks/{cli-api.BkDphVBG.js → cli-api.BJJXh9BV.js}

@@ -1,19 +1,18 @@
 import fs, { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { relative, resolve, dirname, extname, normalize, join, basename, isAbsolute } from 'pathe';
-import { C as CoverageProviderMap } from './coverage.DVF1vEu8.js';
+import { C as CoverageProviderMap } from './coverage.D_JHT54q.js';
 import path, { resolve as resolve$1 } from 'node:path';
-import { noop, isPrimitive, createDefer, slash, highlight, toArray, deepMerge, nanoid, deepClone, notNullish } from '@vitest/utils';
+import { noop, createDefer, slash, highlight, toArray, cleanUrl, deepMerge, KNOWN_ASSET_RE, nanoid, deepClone, isPrimitive, notNullish } from '@vitest/utils';
 import { f as findUp, p as prompt } from './index.X0nbfr6-.js';
 import * as vite from 'vite';
-import { searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
-import { A as API_PATH, c as configFiles, d as defaultBrowserPort, w as workspacesFiles, a as defaultPort } from './constants.DnKduX2e.js';
-import { generateFileHash, limitConcurrency, createFileTask, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
+import { parseAst, searchForWorkspaceRoot, version, mergeConfig, createServer } from 'vite';
+import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.D_Q9UYh-.js';
+import nodeos__default, { tmpdir } from 'node:os';
+import { generateHash as generateHash$1, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { ViteNodeRunner } from 'vite-node/client';
-import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.Cb-PYCCB.js';
-import { c as createBirpc } from './index.B521nVV-.js';
-import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, j as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.VByaPkjc.js';
+import { v as version$1 } from './cac.DCxo_nSu.js';
+import { c as createBirpc } from './index.Bgo3tNWt.js';
+import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.BIP7prJq.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -25,27 +24,30 @@ import require$$7 from 'url';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
-import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import crypto, { createHash } from 'node:crypto';
 import { distDir, rootDir } from '../path.js';
-import { h as hash, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, d as isBrowserEnabled, r as resolveConfig, e as groupBy, f as getCoverageProvider, j as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.DL5VHqXY.js';
-import { c as convertTasksToEvents } from './typechecker.DRKU1-1g.js';
+import { h as hash, d as createFetchModuleFunction, n as normalizeResolvedIdToUrl, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, e as isBrowserEnabled, r as resolveConfig, f as groupBy, j as getCoverageProvider, k as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.BCU-r2QL.js';
+import { b as ancestor, c as createDefinesScript, d as convertTasksToEvents } from './typechecker.DB-fIMaH.js';
+import { TraceMap, originalPositionFor, parseErrorStacktrace } from '@vitest/utils/source-map';
+import createDebug from 'debug';
+import { VitestModuleEvaluator } from '#module-evaluator';
+import { ModuleRunner } from 'vite/module-runner';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
-import { createRequire } from 'node:module';
-import url from 'node:url';
+import { createRequire, builtinModules, isBuiltin } from 'node:module';
+import url, { pathToFileURL } from 'node:url';
 import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
 import { rm, mkdir, copyFile } from 'node:fs/promises';
-import nodeos__default, { tmpdir } from 'node:os';
 import pm from 'picomatch';
 import { glob, isDynamicPattern } from 'tinyglobby';
-import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
-import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
-import { c as configDefaults } from './defaults.B7q_naMc.js';
 import MagicString from 'magic-string';
-import { a as BenchmarkReportsMap } from './index.BCWujgDG.js';
+import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
+import { c as configDefaults } from './defaults.CXFFjsi8.js';
+import { f as findNearestPackageData } from './resolver.Bx6lE0iq.js';
+import * as esModuleLexer from 'es-module-lexer';
+import { a as BenchmarkReportsMap } from './index.BjKEiSn0.js';
 import assert$1 from 'node:assert';
-import { serializeError } from '@vitest/utils/error';
+import { serializeError as serializeError$1 } from '@vitest/utils/error';
 import readline from 'node:readline';
 import { stripVTControlCharacters } from 'node:util';
 
@@ -4717,9 +4719,11 @@ function requireWebsocketServer () {
 	      return;
 	    }
 
-	    if (version !== 8 && version !== 13) {
+	    if (version !== 13 && version !== 8) {
 	      const message = 'Missing or invalid Sec-WebSocket-Version header';
-	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+	        'Sec-WebSocket-Version': '13, 8'
+	      });
 	      return;
 	    }
 
@@ -4987,16 +4991,24 @@ function requireWebsocketServer () {
 	 * @param {Duplex} socket The socket of the upgrade request
 	 * @param {Number} code The HTTP response status code
 	 * @param {String} message The HTTP response body
+	 * @param {Object} [headers] The HTTP response headers
 	 * @private
 	 */
-	function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
+	function abortHandshakeOrEmitwsClientError(
+	  server,
+	  req,
+	  socket,
+	  code,
+	  message,
+	  headers
+	) {
 	  if (server.listenerCount('wsClientError')) {
 	    const err = new Error(message);
 	    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
 
 	    server.emit('wsClientError', err, socket, req);
 	  } else {
-	    abortHandshake(socket, code, message);
+	    abortHandshake(socket, code, message, headers);
 	  }
 	}
 	return websocketServer;
@@ -5006,25 +5018,18 @@ var websocketServerExports = requireWebsocketServer();
 var WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServerExports);
 
 async function getModuleGraph(ctx, projectName, id, browser = false) {
-	const graph = {};
-	const externalized = /* @__PURE__ */ new Set();
-	const inlined = /* @__PURE__ */ new Set();
-	const project = ctx.getProjectByName(projectName);
+	const graph = {}, externalized = /* @__PURE__ */ new Set(), inlined = /* @__PURE__ */ new Set(), project = ctx.getProjectByName(projectName);
 	async function get(mod, seen = /* @__PURE__ */ new Map()) {
-		if (!mod || !mod.id) return;
-		if (mod.id === "\0@vitest/browser/context") return;
+		if (!mod || !mod.id || mod.id === "\0@vitest/browser/context") return;
 		if (seen.has(mod)) return seen.get(mod);
 		let id = clearId(mod.id);
 		seen.set(mod, id);
-		const rewrote = browser ? mod.file?.includes(project.browser.vite.config.cacheDir) ? mod.id : false : await project.vitenode.shouldExternalize(id);
-		if (rewrote) {
-			id = rewrote;
-			externalized.add(id);
-			seen.set(mod, id);
-		} else inlined.add(id);
+		// TODO: how to know if it was rewritten(?) - what is rewritten?
+		const rewrote = browser ? mod.file?.includes(project.browser.vite.config.cacheDir) ? mod.id : false : false;
+		if (rewrote) id = rewrote, externalized.add(id), seen.set(mod, id);
+		else inlined.add(id);
 		const mods = Array.from(mod.importedModules).filter((i) => i.id && !i.id.includes("/vitest/dist/"));
-		graph[id] = (await Promise.all(mods.map((m) => get(m, seen)))).filter(Boolean);
-		return id;
+		return graph[id] = (await Promise.all(mods.map((m) => get(m, seen)))).filter(Boolean), id;
 	}
 	if (browser && project.browser) await get(project.browser.vite.moduleGraph.getModuleById(id));
 	else await get(project.vite.moduleGraph.getModuleById(id));
@@ -5076,21 +5081,19 @@ catch {}
 }
 
 function setup(ctx, _server) {
-	const wss = new WebSocketServer({ noServer: true });
-	const clients = /* @__PURE__ */ new Map();
-	const server = _server || ctx.server;
+	const wss = new WebSocketServer({ noServer: true }), clients = /* @__PURE__ */ new Map(), server = _server || ctx.vite;
 	server.httpServer?.on("upgrade", (request, socket, head) => {
 		if (!request.url) return;
 		const { pathname } = new URL(request.url, "http://localhost");
-		if (pathname !== API_PATH) return;
-		if (!isValidApiRequest(ctx.config, request)) {
-			socket.destroy();
-			return;
+		if (pathname === API_PATH) {
+			if (!isValidApiRequest(ctx.config, request)) {
+				socket.destroy();
+				return;
+			}
+			wss.handleUpgrade(request, socket, head, (ws) => {
+				wss.emit("connection", ws, request), setupClient(ws);
+			});
 		}
-		wss.handleUpgrade(request, socket, head, (ws) => {
-			wss.emit("connection", ws, request);
-			setupClient(ws);
-		});
 	});
 	function setupClient(ws) {
 		const rpc = createBirpc({
@@ -5104,8 +5107,7 @@ function setup(ctx, _server) {
 				return ctx.state.getPaths();
 			},
 			async readTestFile(id) {
-				if (!ctx.state.filesMap.has(id) || !existsSync(id)) return null;
-				return promises.readFile(id, "utf-8");
+				return !ctx.state.filesMap.has(id) || !existsSync(id) ? null : promises.readFile(id, "utf-8");
 			},
 			async saveTestFile(id, content) {
 				if (!ctx.state.filesMap.has(id) || !existsSync(id)) throw new Error(`Test file "${id}" was not registered, so it cannot be updated using the API.`);
@@ -5120,9 +5122,6 @@ function setup(ctx, _server) {
 			getConfig() {
 				return ctx.getRootProject().serializedConfig;
 			},
-			getResolvedProjectNames() {
-				return ctx.projects.map((p) => p.name);
-			},
 			getResolvedProjectLabels() {
 				return ctx.projects.map((p) => ({
 					name: p.name,
@@ -5130,8 +5129,7 @@ function setup(ctx, _server) {
 				}));
 			},
 			async getTransformResult(projectName, id, browser = false) {
-				const project = ctx.getProjectByName(projectName);
-				const result = browser ? await project.browser.vite.transformRequest(id) : await project.vitenode.transformRequest(id);
+				const project = ctx.getProjectByName(projectName), result = browser ? await project.browser.vite.transformRequest(id) : await project.vite.transformRequest(id);
 				if (result) {
 					try {
 						result.source = result.source || await promises.readFile(id, "utf-8");
@@ -5172,59 +5170,43 @@ function setup(ctx, _server) {
 			],
 			serialize: (data) => stringify(data, stringifyReplace),
 			deserialize: parse,
-			onTimeoutError(functionName) {
-				throw new Error(`[vitest-api]: Timeout calling "${functionName}"`);
-			}
+			timeout: -1
 		});
-		clients.set(ws, rpc);
-		ws.on("close", () => {
-			clients.delete(ws);
+		clients.set(ws, rpc), ws.on("close", () => {
+			clients.delete(ws), rpc.$close(/* @__PURE__ */ new Error("[vitest-api]: Pending methods while closing rpc"));
 		});
 	}
 	ctx.reporters.push(new WebSocketReporter(ctx, wss, clients));
 }
 class WebSocketReporter {
 	constructor(ctx, wss, clients) {
-		this.ctx = ctx;
-		this.wss = wss;
-		this.clients = clients;
+		this.ctx = ctx, this.wss = wss, this.clients = clients;
 	}
-	onCollected(files) {
-		if (this.clients.size === 0) return;
-		this.clients.forEach((client) => {
-			client.onCollected?.(files)?.catch?.(noop);
+	onTestModuleCollected(testModule) {
+		this.clients.size !== 0 && this.clients.forEach((client) => {
+			client.onCollected?.([testModule.task])?.catch?.(noop);
 		});
 	}
-	onSpecsCollected(specs) {
+	onTestRunStart(specifications) {
 		if (this.clients.size === 0) return;
+		const serializedSpecs = specifications.map((spec) => spec.toJSON());
 		this.clients.forEach((client) => {
-			client.onSpecsCollected?.(specs)?.catch?.(noop);
+			client.onSpecsCollected?.(serializedSpecs)?.catch?.(noop);
 		});
 	}
 	async onTestCaseAnnotate(testCase, annotation) {
-		if (this.clients.size === 0) return;
-		this.clients.forEach((client) => {
+		this.clients.size !== 0 && this.clients.forEach((client) => {
 			client.onTestAnnotate?.(testCase.id, annotation)?.catch?.(noop);
 		});
 	}
 	async onTaskUpdate(packs, events) {
-		if (this.clients.size === 0) return;
-		packs.forEach(([taskId, result]) => {
-			const task = this.ctx.state.idMap.get(taskId);
-			const isBrowser = task && task.file.pool === "browser";
-			result?.errors?.forEach((error) => {
-				if (isPrimitive(error)) return;
-				if (isBrowser) {
-					const project = this.ctx.getProjectByName(task.file.projectName || "");
-					error.stacks = project.browser?.parseErrorStacktrace(error);
-				} else error.stacks = parseErrorStacktrace(error);
-			});
-		});
-		this.clients.forEach((client) => {
+		this.clients.size !== 0 && this.clients.forEach((client) => {
 			client.onTaskUpdate?.(packs, events)?.catch?.(noop);
 		});
 	}
-	onFinished(files, errors) {
+	onTestRunEnd(testModules, unhandledErrors) {
+		if (!this.clients.size) return;
+		const files = testModules.map((testModule) => testModule.task), errors = [...unhandledErrors];
 		this.clients.forEach((client) => {
 			client.onFinished?.(files, errors)?.catch?.(noop);
 		});
@@ -5247,6 +5229,265 @@ var setup$1 = /*#__PURE__*/Object.freeze({
   setup: setup
 });
 
+function createDebugger(namespace) {
+	const debug = createDebug(namespace);
+	if (debug.enabled) return debug;
+}
+
+const debug = createDebugger("vitest:ast-collect-info"), verbose = createDebugger("vitest:ast-collect-verbose");
+function astParseFile(filepath, code) {
+	const ast = parseAst(code);
+	if (verbose) verbose("Collecting", filepath, code);
+	else debug?.("Collecting", filepath);
+	const definitions = [], getName = (callee) => {
+		if (!callee) return null;
+		if (callee.type === "Identifier") return callee.name;
+		if (callee.type === "CallExpression") return getName(callee.callee);
+		if (callee.type === "TaggedTemplateExpression") return getName(callee.tag);
+		if (callee.type === "MemberExpression")
+ // call as `__vite_ssr__.test.skip()`
+		return callee.object?.type === "Identifier" && [
+			"it",
+			"test",
+			"describe",
+			"suite"
+		].includes(callee.object.name) ? callee.object?.name : callee.object?.name?.startsWith("__vite_ssr_") || callee.object?.object?.name?.startsWith("__vite_ssr_") && callee.object?.property?.name === "Vitest" ? getName(callee.property) : getName(callee.object?.property);
+		// unwrap (0, ...)
+		if (callee.type === "SequenceExpression" && callee.expressions.length === 2) {
+			const [e0, e1] = callee.expressions;
+			if (e0.type === "Literal" && e0.value === 0) return getName(e1);
+		}
+		return null;
+	};
+	return ancestor(ast, { CallExpression(node) {
+		const { callee } = node, name = getName(callee);
+		if (!name) return;
+		if (![
+			"it",
+			"test",
+			"describe",
+			"suite"
+		].includes(name)) {
+			verbose?.(`Skipping ${name} (unknown call)`);
+			return;
+		}
+		const property = callee?.property?.name;
+		let mode = !property || property === name ? "run" : property;
+		// they will be picked up in the next iteration
+		if ([
+			"each",
+			"for",
+			"skipIf",
+			"runIf"
+		].includes(mode)) return;
+		let start;
+		const end = node.end;
+		// .each or (0, __vite_ssr_exports_0__.test)()
+		if (callee.type === "CallExpression" || callee.type === "SequenceExpression" || callee.type === "TaggedTemplateExpression") start = callee.end;
+		else start = node.start;
+		const messageNode = node.arguments?.[0];
+		if (messageNode == null) {
+			verbose?.(`Skipping node at ${node.start} because it doesn't have a name`);
+			return;
+		}
+		let message;
+		if (messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral") message = code.slice(messageNode.start + 1, messageNode.end - 1);
+		else message = code.slice(messageNode.start, messageNode.end);
+		if (message.startsWith("0,")) message = message.slice(2);
+		// cannot statically analyze, so we always skip it
+		if (message = message.replace(/__vite_ssr_import_\d+__\./g, "").replace(/__vi_import_\d+__\./g, ""), mode === "skipIf" || mode === "runIf") mode = "skip";
+		const parentCalleeName = typeof callee?.callee === "object" && callee?.callee.type === "MemberExpression" && callee?.callee.property?.name;
+		let isDynamicEach = parentCalleeName === "each" || parentCalleeName === "for";
+		if (!isDynamicEach && callee.type === "TaggedTemplateExpression") {
+			const property = callee.tag?.property?.name;
+			isDynamicEach = property === "each" || property === "for";
+		}
+		debug?.("Found", name, message, `(${mode})`), definitions.push({
+			start,
+			end,
+			name: message,
+			type: name === "it" || name === "test" ? "test" : "suite",
+			mode,
+			task: null,
+			dynamic: isDynamicEach
+		});
+	} }), {
+		ast,
+		definitions
+	};
+}
+function createFailedFileTask(project, filepath, error) {
+	const testFilepath = relative(project.config.root, filepath), file = {
+		filepath,
+		type: "suite",
+		id: /* @__PURE__ */ generateHash$1(`${testFilepath}${project.config.name || ""}`),
+		name: testFilepath,
+		mode: "run",
+		tasks: [],
+		start: 0,
+		end: 0,
+		projectName: project.name,
+		meta: {},
+		pool: project.browser ? "browser" : project.config.pool,
+		file: null,
+		result: {
+			state: "fail",
+			errors: serializeError(project, error)
+		}
+	};
+	return file.file = file, file;
+}
+function serializeError(ctx, error) {
+	if ("errors" in error && "pluginCode" in error) {
+		const errors = error.errors.map((e) => {
+			return {
+				name: error.name,
+				message: e.text,
+				stack: e.location ? `${error.name}: ${e.text}\n  at ${relative(ctx.config.root, e.location.file)}:${e.location.line}:${e.location.column}` : ""
+			};
+		});
+		return errors;
+	}
+	return [{
+		name: error.name,
+		stack: error.stack,
+		message: error.message
+	}];
+}
+function createFileTask(testFilepath, code, requestMap, options) {
+	const { definitions, ast } = astParseFile(testFilepath, code), file = {
+		filepath: options.filepath,
+		type: "suite",
+		id: /* @__PURE__ */ generateHash$1(`${testFilepath}${options.name || ""}`),
+		name: testFilepath,
+		mode: "run",
+		tasks: [],
+		start: ast.start,
+		end: ast.end,
+		projectName: options.name,
+		meta: {},
+		pool: "browser",
+		file: null
+	};
+	file.file = file;
+	const indexMap = createIndexMap(code), map = requestMap && new TraceMap(requestMap);
+	let lastSuite = file;
+	const updateLatestSuite = (index) => {
+		while (lastSuite.suite && lastSuite.end < index) lastSuite = lastSuite.suite;
+		return lastSuite;
+	};
+	definitions.sort((a, b) => a.start - b.start).forEach((definition) => {
+		const latestSuite = updateLatestSuite(definition.start);
+		let mode = definition.mode;
+		if (latestSuite.mode !== "run")
+ // inherit suite mode, if it's set
+		mode = latestSuite.mode;
+		const processedLocation = indexMap.get(definition.start);
+		let location;
+		if (map && processedLocation) {
+			const originalLocation = originalPositionFor(map, {
+				line: processedLocation.line,
+				column: processedLocation.column
+			});
+			if (originalLocation.column != null) verbose?.(`Found location for`, definition.type, definition.name, `${processedLocation.line}:${processedLocation.column}`, "->", `${originalLocation.line}:${originalLocation.column}`), location = originalLocation;
+			else debug?.("Cannot find original location for", definition.type, definition.name, `${processedLocation.column}:${processedLocation.line}`);
+		} else debug?.("Cannot find original location for", definition.type, definition.name, `${definition.start}`);
+		if (definition.type === "suite") {
+			const task = {
+				type: definition.type,
+				id: "",
+				suite: latestSuite,
+				file,
+				tasks: [],
+				mode,
+				name: definition.name,
+				end: definition.end,
+				start: definition.start,
+				location,
+				dynamic: definition.dynamic,
+				meta: {}
+			};
+			definition.task = task, latestSuite.tasks.push(task), lastSuite = task;
+			return;
+		}
+		const task = {
+			type: definition.type,
+			id: "",
+			suite: latestSuite,
+			file,
+			mode,
+			context: {},
+			name: definition.name,
+			end: definition.end,
+			start: definition.start,
+			location,
+			dynamic: definition.dynamic,
+			meta: {},
+			timeout: 0,
+			annotations: []
+		};
+		definition.task = task, latestSuite.tasks.push(task);
+	}), calculateSuiteHash(file);
+	const hasOnly = someTasksAreOnly(file);
+	if (interpretTaskModes(file, options.testNamePattern, void 0, hasOnly, false, options.allowOnly), markDynamicTests(file.tasks), !file.tasks.length) file.result = {
+		state: "fail",
+		errors: [{
+			name: "Error",
+			message: `No test suite found in file ${options.filepath}`
+		}]
+	};
+	return file;
+}
+async function astCollectTests(project, filepath) {
+	const request = await transformSSR(project, filepath), testFilepath = relative(project.config.root, filepath);
+	return request ? createFileTask(testFilepath, request.code, request.map, {
+		name: project.config.name,
+		filepath,
+		allowOnly: project.config.allowOnly,
+		testNamePattern: project.config.testNamePattern,
+		pool: project.browser ? "browser" : project.config.pool
+	}) : (debug?.("Cannot parse", testFilepath, "(vite didn't return anything)"), createFailedFileTask(project, filepath, /* @__PURE__ */ new Error(`Failed to parse ${testFilepath}. Vite didn't return anything.`)));
+}
+async function transformSSR(project, filepath) {
+	const request = await project.vite.transformRequest(filepath, { ssr: false });
+	return request ? await project.vite.ssrTransform(request.code, request.map, filepath) : null;
+}
+function createIndexMap(source) {
+	const map = /* @__PURE__ */ new Map();
+	let index = 0, line = 1, column = 1;
+	for (const char of source) if (map.set(index++, {
+		line,
+		column
+	}), char === "\n" || char === "\r\n") line++, column = 0;
+	else column++;
+	return map;
+}
+function markDynamicTests(tasks) {
+	for (const task of tasks) {
+		if (task.dynamic) task.id += "-dynamic";
+		if ("tasks" in task) markDynamicTests(task.tasks);
+	}
+}
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const kReplacers = new Map([
+	["%i", "\\d+?"],
+	["%#", "\\d+?"],
+	["%d", "[\\d.eE+-]+?"],
+	["%f", "[\\d.eE+-]+?"],
+	["%s", ".+?"],
+	["%j", ".+?"],
+	["%o", ".+?"],
+	["%%", "%"]
+]);
+function escapeTestName(label, dynamic) {
+	if (!dynamic) return escapeRegex(label);
+	// Replace object access patterns ($value, $obj.a) with %s first
+	let pattern = label.replace(/\$[a-z_.]+/gi, "%s");
+	return pattern = escapeRegex(pattern), pattern = pattern.replace(/%[i#dfsjo%]/g, (m) => kReplacers.get(m) || m), pattern;
+}
+
 class BrowserSessions {
 	sessions = /* @__PURE__ */ new Map();
 	sessionIds = /* @__PURE__ */ new Set();
@@ -5258,23 +5499,18 @@ class BrowserSessions {
 	}
 	createSession(sessionId, project, pool) {
 		// this promise only waits for the WS connection with the orhcestrator to be established
-		const defer = createDefer();
-		const timeout = setTimeout(() => {
-			defer.reject(new Error(`Failed to connect to the browser session "${sessionId}" [${project.name}] within the timeout.`));
+		const defer = createDefer(), timeout = setTimeout(() => {
+			defer.reject(/* @__PURE__ */ new Error(`Failed to connect to the browser session "${sessionId}" [${project.name}] within the timeout.`));
 		}, project.vitest.config.browser.connectTimeout ?? 6e4).unref();
-		this.sessions.set(sessionId, {
+		return this.sessions.set(sessionId, {
 			project,
 			connected: () => {
-				defer.resolve();
-				clearTimeout(timeout);
+				defer.resolve(), clearTimeout(timeout);
 			},
 			fail: (error) => {
-				defer.resolve();
-				clearTimeout(timeout);
-				pool.reject(error);
+				defer.resolve(), clearTimeout(timeout), pool.reject(error);
 			}
-		});
-		return defer;
+		}), defer;
 	}
 }
 
@@ -5285,7 +5521,7 @@ class FilesStatsCache {
 	}
 	async populateStats(root, specs) {
 		const promises = specs.map((spec) => {
-			const key = `${spec[0].name}:${relative(root, spec.moduleId)}`;
+			const key = `${spec.project.name}:${relative(root, spec.moduleId)}`;
 			return this.updateStats(spec.moduleId, key);
 		});
 		await Promise.all(promises);
@@ -5315,37 +5551,25 @@ class ResultsCache {
 		return this.cachePath;
 	}
 	setConfig(root, config) {
-		this.root = root;
-		if (config) this.cachePath = resolve(config.dir, "results.json");
+		if (this.root = root, config) this.cachePath = resolve(config.dir, "results.json");
 	}
 	getResults(key) {
 		return this.cache.get(key);
 	}
 	async readFromCache() {
-		if (!this.cachePath) return;
-		if (!fs.existsSync(this.cachePath)) return;
-		const resultsCache = await fs.promises.readFile(this.cachePath, "utf8");
-		const { results, version } = JSON.parse(resultsCache || "[]");
-		const [major, minor] = version.split(".");
+		if (!this.cachePath || !fs.existsSync(this.cachePath)) return;
+		const resultsCache = await fs.promises.readFile(this.cachePath, "utf8"), { results, version } = JSON.parse(resultsCache || "[]"), [major, minor] = version.split(".");
 		// handling changed in 0.30.0
-		if (major > 0 || Number(minor) >= 30) {
-			this.cache = new Map(results);
-			this.version = version;
-			results.forEach(([spec]) => {
-				const [projectName, relativePath] = spec.split(":");
-				const keyMap = this.workspacesKeyMap.get(relativePath) || [];
-				keyMap.push(projectName);
-				this.workspacesKeyMap.set(relativePath, keyMap);
-			});
-		}
+		if (major > 0 || Number(minor) >= 30) this.cache = new Map(results), this.version = version, results.forEach(([spec]) => {
+			const [projectName, relativePath] = spec.split(":"), keyMap = this.workspacesKeyMap.get(relativePath) || [];
+			keyMap.push(projectName), this.workspacesKeyMap.set(relativePath, keyMap);
+		});
 	}
 	updateResults(files) {
 		files.forEach((file) => {
 			const result = file.result;
 			if (!result) return;
-			const duration = result.duration || 0;
-			// store as relative, so cache would be the same in CI and locally
-			const relativePath = relative(this.root, file.filepath);
+			const duration = result.duration || 0, relativePath = relative(this.root, file.filepath);
 			this.cache.set(`${file.projectName || ""}:${relativePath}`, {
 				duration: duration >= 0 ? duration : 0,
 				failed: result.state === "fail"
@@ -5359,8 +5583,7 @@ class ResultsCache {
 	}
 	async writeToCache() {
 		if (!this.cachePath) return;
-		const results = Array.from(this.cache.entries());
-		const cacheDirname = dirname(this.cachePath);
+		const results = Array.from(this.cache.entries()), cacheDirname = dirname(this.cachePath);
 		if (!fs.existsSync(cacheDirname)) await fs.promises.mkdir(cacheDirname, { recursive: true });
 		const cache = JSON.stringify({
 			version: this.version,
@@ -5388,6 +5611,34 @@ class VitestCache {
 	}
 }
 
+class ServerModuleRunner extends ModuleRunner {
+	constructor(environment, resolver, config) {
+		const fetchModule = createFetchModuleFunction(resolver, false);
+		super({
+			hmr: false,
+			sourcemapInterceptor: "node",
+			transport: { async invoke(event) {
+				if (event.type !== "custom") throw new Error(`Vitest Module Runner doesn't support Vite HMR events.`);
+				const { data } = event.data;
+				try {
+					const result = await fetchModule(data[0], data[1], environment, data[2]);
+					return { result };
+				} catch (error) {
+					return { error };
+				}
+			} }
+		}, new VitestModuleEvaluator()), this.environment = environment, this.config = config;
+	}
+	async import(rawId) {
+		const resolved = await this.environment.pluginContainer.resolveId(rawId, this.config.root);
+		if (!resolved) return super.import(rawId);
+		// Vite will make "@vitest/coverage-v8" into "@vitest/coverage-v8.js" url
+		// instead of using an actual file path-like URL, so we resolve it here first
+		const url = normalizeResolvedIdToUrl(this.environment, resolved.id);
+		return super.import(url);
+	}
+}
+
 class FilesNotFoundError extends Error {
 	code = "VITEST_FILES_NOT_FOUND";
 	constructor(mode) {
@@ -5443,43 +5694,26 @@ function highlightCode(id, source, colors) {
 	});
 }
 
-const PAD = "      ";
-const ESC$1 = "\x1B[";
-const ERASE_DOWN = `${ESC$1}J`;
-const ERASE_SCROLLBACK = `${ESC$1}3J`;
-const CURSOR_TO_START = `${ESC$1}1;1H`;
-const HIDE_CURSOR = `${ESC$1}?25l`;
-const SHOW_CURSOR = `${ESC$1}?25h`;
-const CLEAR_SCREEN = "\x1Bc";
+const PAD = "      ", ESC$1 = "\x1B[", ERASE_DOWN = `${ESC$1}J`, ERASE_SCROLLBACK = `${ESC$1}3J`, CURSOR_TO_START = `${ESC$1}1;1H`, HIDE_CURSOR = `${ESC$1}?25l`, SHOW_CURSOR = `${ESC$1}?25h`, CLEAR_SCREEN = "\x1Bc";
 class Logger {
 	_clearScreenPending;
 	_highlights = /* @__PURE__ */ new Map();
 	cleanupListeners = [];
 	console;
 	constructor(ctx, outputStream = process.stdout, errorStream = process.stderr) {
-		this.ctx = ctx;
-		this.outputStream = outputStream;
-		this.errorStream = errorStream;
-		this.console = new Console({
+		if (this.ctx = ctx, this.outputStream = outputStream, this.errorStream = errorStream, this.console = new Console({
 			stdout: outputStream,
 			stderr: errorStream
-		});
-		this._highlights.clear();
-		this.addCleanupListeners();
-		this.registerUnhandledRejection();
-		if (this.outputStream.isTTY) this.outputStream.write(HIDE_CURSOR);
+		}), this._highlights.clear(), this.addCleanupListeners(), this.registerUnhandledRejection(), this.outputStream.isTTY) this.outputStream.write(HIDE_CURSOR);
 	}
 	log(...args) {
-		this._clearScreen();
-		this.console.log(...args);
+		this._clearScreen(), this.console.log(...args);
 	}
 	error(...args) {
-		this._clearScreen();
-		this.console.error(...args);
+		this._clearScreen(), this.console.error(...args);
 	}
 	warn(...args) {
-		this._clearScreen();
-		this.console.warn(...args);
+		this._clearScreen(), this.console.warn(...args);
 	}
 	clearFullScreen(message = "") {
 		if (!this.ctx.config.clearScreen) {
@@ -5494,14 +5728,12 @@ class Logger {
 			this.console.log(message);
 			return;
 		}
-		this._clearScreenPending = message;
-		if (force) this._clearScreen();
+		if (this._clearScreenPending = message, force) this._clearScreen();
 	}
 	_clearScreen() {
 		if (this._clearScreenPending == null) return;
 		const log = this._clearScreenPending;
-		this._clearScreenPending = void 0;
-		this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`);
+		this._clearScreenPending = void 0, this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`);
 	}
 	printError(err, options = {}) {
 		printError(err, this.ctx, this, options);
@@ -5516,8 +5748,7 @@ class Logger {
 	highlight(filename, source) {
 		if (this._highlights.has(filename)) return this._highlights.get(filename);
 		const code = highlightCode(filename, source);
-		this._highlights.set(filename, code);
-		return code;
+		return this._highlights.set(filename, code), code;
 	}
 	printNoTestFound(filters) {
 		const config = this.ctx.config;
@@ -5530,34 +5761,22 @@ class Logger {
 		const projectsFilter = toArray(config.project);
 		if (projectsFilter.length) this.console.error(c.dim("projects: ") + c.yellow(projectsFilter.join(comma)));
 		this.ctx.projects.forEach((project) => {
-			const config = project.config;
-			const printConfig = !project.isRootProject() && project.name;
+			const config = project.config, printConfig = !project.isRootProject() && project.name;
 			if (printConfig) this.console.error(`\n${formatProjectName(project)}\n`);
 			if (config.include) this.console.error(c.dim("include: ") + c.yellow(config.include.join(comma)));
 			if (config.exclude) this.console.error(c.dim("exclude:  ") + c.yellow(config.exclude.join(comma)));
-			if (config.typecheck.enabled) {
-				this.console.error(c.dim("typecheck include: ") + c.yellow(config.typecheck.include.join(comma)));
-				this.console.error(c.dim("typecheck exclude: ") + c.yellow(config.typecheck.exclude.join(comma)));
-			}
-		});
-		this.console.error();
+			if (config.typecheck.enabled) this.console.error(c.dim("typecheck include: ") + c.yellow(config.typecheck.include.join(comma))), this.console.error(c.dim("typecheck exclude: ") + c.yellow(config.typecheck.exclude.join(comma)));
+		}), this.console.error();
 	}
 	printBanner() {
 		this.log();
-		const color = this.ctx.config.watch ? "blue" : "cyan";
-		const mode = this.ctx.config.watch ? "DEV" : "RUN";
-		this.log(withLabel(color, mode, `v${this.ctx.version} `) + c.gray(this.ctx.config.root));
-		if (this.ctx.config.sequence.sequencer === RandomSequencer) this.log(PAD + c.gray(`Running tests with seed "${this.ctx.config.sequence.seed}"`));
+		const color = this.ctx.config.watch ? "blue" : "cyan", mode = this.ctx.config.watch ? "DEV" : "RUN";
+		if (this.log(withLabel(color, mode, `v${this.ctx.version} `) + c.gray(this.ctx.config.root)), this.ctx.config.sequence.sequencer === RandomSequencer) this.log(PAD + c.gray(`Running tests with seed "${this.ctx.config.sequence.seed}"`));
 		if (this.ctx.config.ui) {
-			const host = this.ctx.config.api?.host || "localhost";
-			const port = this.ctx.server.config.server.port;
-			const base = this.ctx.config.uiBase;
+			const host = this.ctx.config.api?.host || "localhost", port = this.ctx.vite.config.server.port, base = this.ctx.config.uiBase;
 			this.log(PAD + c.dim(c.green(`UI started at http://${host}:${c.bold(port)}${base}`)));
 		} else if (this.ctx.config.api?.port) {
-			const resolvedUrls = this.ctx.server.resolvedUrls;
-			// workaround for https://github.com/vitejs/vite/issues/15438, it was fixed in vite 5.1
-			const fallbackUrl = `http://${this.ctx.config.api.host || "localhost"}:${this.ctx.config.api.port}`;
-			const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0] ?? fallbackUrl;
+			const resolvedUrls = this.ctx.vite.resolvedUrls, fallbackUrl = `http://${this.ctx.config.api.host || "localhost"}:${this.ctx.config.api.port}`, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0] ?? fallbackUrl;
 			this.log(PAD + c.dim(c.green(`API started at ${new URL("/", origin)}`)));
 		}
 		if (this.ctx.coverageProvider) this.log(PAD + c.dim("Coverage enabled with ") + c.yellow(this.ctx.coverageProvider.name));
@@ -5566,35 +5785,26 @@ class Logger {
 	}
 	printBrowserBanner(project) {
 		if (!project.browser) return;
-		const resolvedUrls = project.browser.vite.resolvedUrls;
-		const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
+		const resolvedUrls = project.browser.vite.resolvedUrls, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
 		if (!origin) return;
-		const output = project.isRootProject() ? "" : formatProjectName(project);
-		const provider = project.browser.provider.name;
-		const providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
+		const output = project.isRootProject() ? "" : formatProjectName(project), provider = project.browser.provider.name, providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
 		this.log(c.dim(`${output}Browser runner started${providerString} ${c.dim("at")} ${c.blue(new URL("/__vitest_test__/", origin))}\n`));
 	}
 	printUnhandledErrors(errors) {
 		const errorMessage = c.red(c.bold(`\nVitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} during the test run.
 This might cause false positive tests. Resolve unhandled errors to make sure your tests are not affected.`));
-		this.error(errorBanner("Unhandled Errors"));
-		this.error(errorMessage);
-		errors.forEach((err) => {
+		this.error(errorBanner("Unhandled Errors")), this.error(errorMessage), errors.forEach((err) => {
 			this.printError(err, {
 				fullStack: true,
 				type: err.type || "Unhandled Error"
 			});
-		});
-		this.error(c.red(divider()));
+		}), this.error(c.red(divider()));
 	}
 	printSourceTypeErrors(errors) {
 		const errorMessage = c.red(c.bold(`\nVitest found ${errors.length} error${errors.length > 1 ? "s" : ""} not related to your test files.`));
-		this.log(errorBanner("Source Errors"));
-		this.log(errorMessage);
-		errors.forEach((err) => {
+		this.log(errorBanner("Source Errors")), this.log(errorMessage), errors.forEach((err) => {
 			this.printError(err, { fullStack: true });
-		});
-		this.log(c.red(divider()));
+		}), this.log(c.red(divider()));
 	}
 	getColumns() {
 		return "columns" in this.outputStream ? this.outputStream.columns : 80;
@@ -5604,38 +5814,25 @@ This might cause false positive tests. Resolve unhandled errors to make sure you
 	}
 	addCleanupListeners() {
 		const cleanup = () => {
-			this.cleanupListeners.forEach((fn) => fn());
-			if (this.outputStream.isTTY) this.outputStream.write(SHOW_CURSOR);
-		};
-		const onExit = (signal, exitCode) => {
-			cleanup();
+			if (this.cleanupListeners.forEach((fn) => fn()), this.outputStream.isTTY) this.outputStream.write(SHOW_CURSOR);
+		}, onExit = (signal, exitCode) => {
 			// Interrupted signals don't set exit code automatically.
 			// Use same exit code as node: https://nodejs.org/api/process.html#signal-events
-			if (process.exitCode === void 0) process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
+			if (cleanup(), process.exitCode === void 0) process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
 			process.exit();
 		};
-		process.once("SIGINT", onExit);
-		process.once("SIGTERM", onExit);
-		process.once("exit", onExit);
-		this.ctx.onClose(() => {
-			process.off("SIGINT", onExit);
-			process.off("SIGTERM", onExit);
-			process.off("exit", onExit);
-			cleanup();
+		process.once("SIGINT", onExit), process.once("SIGTERM", onExit), process.once("exit", onExit), this.ctx.onClose(() => {
+			process.off("SIGINT", onExit), process.off("SIGTERM", onExit), process.off("exit", onExit), cleanup();
 		});
 	}
 	registerUnhandledRejection() {
 		const onUnhandledRejection = (err) => {
-			process.exitCode = 1;
-			this.printError(err, {
+			process.exitCode = 1, this.printError(err, {
 				fullStack: true,
 				type: "Unhandled Rejection"
-			});
-			this.error("\n\n");
-			process.exit();
+			}), this.error("\n\n"), process.exit();
 		};
-		process.on("unhandledRejection", onUnhandledRejection);
-		this.ctx.onClose(() => {
+		process.on("unhandledRejection", onUnhandledRejection), this.ctx.onClose(() => {
 			process.off("unhandledRejection", onUnhandledRejection);
 		});
 	}
@@ -5651,36 +5848,26 @@ class VitestPackageInstaller {
 		if (process.versions.pnp) {
 			const targetRequire = createRequire(__dirname);
 			try {
-				targetRequire.resolve(dependency, { paths: [root, __dirname] });
-				return true;
+				return targetRequire.resolve(dependency, { paths: [root, __dirname] }), true;
 			} catch {}
 		}
 		if (/* @__PURE__ */ isPackageExists(dependency, { paths: [root, __dirname] })) return true;
-		process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEPENDENCY "))} Cannot find dependency '${dependency}'\n\n`));
-		if (!isTTY) return false;
-		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; });
-		const { install } = await prompts.default({
+		if (process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEPENDENCY "))} Cannot find dependency '${dependency}'\n\n`)), !isTTY) return false;
+		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; }), { install } = await prompts.default({
 			type: "confirm",
 			name: "install",
 			message: c.reset(`Do you want to install ${c.green(dependency)}?`)
 		});
 		if (install) {
 			const packageName = version ? `${dependency}@${version}` : dependency;
-			await (await import('./index.D3XRDfWc.js')).installPackage(packageName, { dev: true });
-			// TODO: somehow it fails to load the package after installation, remove this when it's fixed
-			process.stderr.write(c.yellow(`\nPackage ${packageName} installed, re-run the command to start.\n`));
-			process.exit();
-			return true;
+			return await (await import('./index.D3XRDfWc.js')).installPackage(packageName, { dev: true }), process.stderr.write(c.yellow(`\nPackage ${packageName} installed, re-run the command to start.\n`)), process.exit(), true;
 		}
 		return false;
 	}
 }
 
-function serializeConfig(config, coreConfig, viteConfig) {
-	const optimizer = config.deps?.optimizer;
-	const poolOptions = config.poolOptions;
-	// Resolve from server.config to avoid comparing against default value
-	const isolate = viteConfig?.test?.isolate;
+function serializeConfig(project) {
+	const { config, globalConfig } = project, viteConfig = project._vite?.config, optimizer = config.deps?.optimizer || {}, poolOptions = config.poolOptions, isolate = viteConfig?.test?.isolate;
 	return {
 		environmentOptions: config.environmentOptions,
 		mode: config.mode,
@@ -5714,8 +5901,7 @@ function serializeConfig(config, coreConfig, viteConfig) {
 		snapshotEnvironment: config.snapshotEnvironment,
 		passWithNoTests: config.passWithNoTests,
 		coverage: ((coverage) => {
-			const htmlReporter = coverage.reporter.find(([reporterName]) => reporterName === "html");
-			const subdir = htmlReporter && htmlReporter[1]?.subdir;
+			const htmlReporter = coverage.reporter.find(([reporterName]) => reporterName === "html"), subdir = htmlReporter && htmlReporter[1]?.subdir;
 			return {
 				reportsDirectory: coverage.reportsDirectory,
 				provider: coverage.provider,
@@ -5727,51 +5913,48 @@ function serializeConfig(config, coreConfig, viteConfig) {
 		fakeTimers: config.fakeTimers,
 		poolOptions: {
 			forks: {
-				singleFork: poolOptions?.forks?.singleFork ?? coreConfig.poolOptions?.forks?.singleFork ?? false,
-				isolate: poolOptions?.forks?.isolate ?? isolate ?? coreConfig.poolOptions?.forks?.isolate ?? true
+				singleFork: poolOptions?.forks?.singleFork ?? globalConfig.poolOptions?.forks?.singleFork ?? false,
+				isolate: poolOptions?.forks?.isolate ?? isolate ?? globalConfig.poolOptions?.forks?.isolate ?? true
 			},
 			threads: {
-				singleThread: poolOptions?.threads?.singleThread ?? coreConfig.poolOptions?.threads?.singleThread ?? false,
-				isolate: poolOptions?.threads?.isolate ?? isolate ?? coreConfig.poolOptions?.threads?.isolate ?? true
+				singleThread: poolOptions?.threads?.singleThread ?? globalConfig.poolOptions?.threads?.singleThread ?? false,
+				isolate: poolOptions?.threads?.isolate ?? isolate ?? globalConfig.poolOptions?.threads?.isolate ?? true
 			},
-			vmThreads: { singleThread: poolOptions?.vmThreads?.singleThread ?? coreConfig.poolOptions?.vmThreads?.singleThread ?? false },
-			vmForks: { singleFork: poolOptions?.vmForks?.singleFork ?? coreConfig.poolOptions?.vmForks?.singleFork ?? false }
+			vmThreads: { singleThread: poolOptions?.vmThreads?.singleThread ?? globalConfig.poolOptions?.vmThreads?.singleThread ?? false },
+			vmForks: { singleFork: poolOptions?.vmForks?.singleFork ?? globalConfig.poolOptions?.vmForks?.singleFork ?? false }
 		},
 		deps: {
 			web: config.deps.web || {},
-			optimizer: {
-				web: { enabled: optimizer?.web?.enabled ?? true },
-				ssr: { enabled: optimizer?.ssr?.enabled ?? true }
-			},
+			optimizer: Object.entries(optimizer).reduce((acc, [name, option]) => {
+				return acc[name] = { enabled: option?.enabled ?? false }, acc;
+			}, {}),
 			interopDefault: config.deps.interopDefault,
 			moduleDirectories: config.deps.moduleDirectories
 		},
 		snapshotOptions: {
 			snapshotEnvironment: void 0,
-			updateSnapshot: coreConfig.snapshotOptions.updateSnapshot,
-			snapshotFormat: {
-				...coreConfig.snapshotOptions.snapshotFormat,
-				compareKeys: void 0
-			},
-			expand: config.snapshotOptions.expand ?? coreConfig.snapshotOptions.expand
+			updateSnapshot: globalConfig.snapshotOptions.updateSnapshot,
+			snapshotFormat: { ...globalConfig.snapshotOptions.snapshotFormat },
+			expand: config.snapshotOptions.expand ?? globalConfig.snapshotOptions.expand
 		},
 		sequence: {
-			shuffle: coreConfig.sequence.shuffle,
-			concurrent: coreConfig.sequence.concurrent,
-			seed: coreConfig.sequence.seed,
-			hooks: coreConfig.sequence.hooks,
-			setupFiles: coreConfig.sequence.setupFiles
+			shuffle: globalConfig.sequence.shuffle,
+			concurrent: globalConfig.sequence.concurrent,
+			seed: globalConfig.sequence.seed,
+			hooks: globalConfig.sequence.hooks,
+			setupFiles: globalConfig.sequence.setupFiles
 		},
-		inspect: coreConfig.inspect,
-		inspectBrk: coreConfig.inspectBrk,
-		inspector: coreConfig.inspector,
+		inspect: globalConfig.inspect,
+		inspectBrk: globalConfig.inspectBrk,
+		inspector: globalConfig.inspector,
 		watch: config.watch,
-		includeTaskLocation: config.includeTaskLocation ?? coreConfig.includeTaskLocation,
+		includeTaskLocation: config.includeTaskLocation ?? globalConfig.includeTaskLocation,
 		env: {
 			...viteConfig?.env,
 			...config.env
 		},
 		browser: ((browser) => {
+			const provider = project.browser?.provider;
 			return {
 				name: browser.name,
 				headless: browser.headless,
@@ -5781,12 +5964,14 @@ function serializeConfig(config, coreConfig, viteConfig) {
 				viewport: browser.viewport,
 				screenshotFailures: browser.screenshotFailures,
 				locators: { testIdAttribute: browser.locators.testIdAttribute },
-				providerOptions: browser.provider === "playwright" ? { actionTimeout: browser.providerOptions?.context?.actionTimeout } : {}
+				providerOptions: provider?.name === "playwright" ? { actionTimeout: provider?.options?.actionTimeout } : {},
+				trackUnhandledErrors: browser.trackUnhandledErrors ?? true
 			};
 		})(config.browser),
 		standalone: config.standalone,
-		printConsoleTrace: config.printConsoleTrace ?? coreConfig.printConsoleTrace,
-		benchmark: config.benchmark && { includeSamples: config.benchmark.includeSamples }
+		printConsoleTrace: config.printConsoleTrace ?? globalConfig.printConsoleTrace,
+		benchmark: config.benchmark && { includeSamples: config.benchmark.includeSamples },
+		serializedDefines: config.browser.enabled ? "" : project._serializedDefines || ""
 	};
 }
 
@@ -5795,7 +5980,7 @@ async function loadGlobalSetupFiles(runner, globalSetup) {
 	return Promise.all(globalSetupFiles.map((file) => loadGlobalSetupFile(file, runner)));
 }
 async function loadGlobalSetupFile(file, runner) {
-	const m = await runner.executeFile(file);
+	const m = await runner.import(file);
 	for (const exp of [
 		"default",
 		"setup",
@@ -5805,211 +5990,24 @@ async function loadGlobalSetupFile(file, runner) {
 		file,
 		setup: m.default
 	};
-	else if (m.setup || m.teardown) return {
+	if (m.setup || m.teardown) return {
 		file,
 		setup: m.setup,
 		teardown: m.teardown
 	};
-	else throw new Error(`invalid globalSetup file ${file}. Must export setup, teardown or have a default export`);
+	throw new Error(`invalid globalSetup file ${file}. Must export setup, teardown or have a default export`);
 }
 
 function CoverageTransform(ctx) {
 	return {
 		name: "vitest:coverage-transform",
+		enforce: "post",
 		transform(srcCode, id) {
-			return ctx.coverageProvider?.onFileTransform?.(srcCode, normalizeRequestId(id), this);
-		}
-	};
-}
-
-function MocksPlugins(options = {}) {
-	const normalizedDistDir = normalize(distDir);
-	return [hoistMocksPlugin({
-		filter(id) {
-			if (id.includes(normalizedDistDir)) return false;
-			if (options.filter) return options.filter(id);
-			return true;
-		},
-		codeFrameGenerator(node, id, code) {
-			return generateCodeFrame(code, 4, node.start + 1);
-		}
-	}), automockPlugin()];
-}
-
-function generateCssFilenameHash(filepath) {
-	return hash("sha1", filepath, "hex").slice(0, 6);
-}
-function generateScopedClassName(strategy, name, filename) {
-	// should be configured by Vite defaults
-	if (strategy === "scoped") return null;
-	if (strategy === "non-scoped") return name;
-	const hash = generateCssFilenameHash(filename);
-	return `_${name}_${hash}`;
-}
-
-const LogLevels = {
-	silent: 0,
-	error: 1,
-	warn: 2,
-	info: 3
-};
-function clearScreen(logger) {
-	const repeatCount = process.stdout.rows - 2;
-	const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
-	logger.clearScreen(blank);
-}
-let lastType;
-let lastMsg;
-let sameCount = 0;
-// Only initialize the timeFormatter when the timestamp option is used, and
-// reuse it across all loggers
-let timeFormatter;
-function getTimeFormatter() {
-	timeFormatter ??= new Intl.DateTimeFormat(void 0, {
-		hour: "numeric",
-		minute: "numeric",
-		second: "numeric"
-	});
-	return timeFormatter;
-}
-// This is copy-pasted and needs to be synced from time to time. Ideally, Vite's `createLogger` should accept a custom `console`
-// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/logger.ts?rgh-link-date=2024-10-16T23%3A29%3A19Z
-// When Vitest supports only Vite 6 and above, we can use Vite's `createLogger({ console })`
-// https://github.com/vitejs/vite/pull/18379
-function createViteLogger(console, level = "info", options = {}) {
-	const loggedErrors = /* @__PURE__ */ new WeakSet();
-	const { prefix = "[vite]", allowClearScreen = true } = options;
-	const thresh = LogLevels[level];
-	const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
-	const clear = canClearScreen ? clearScreen : () => {};
-	function format(type, msg, options = {}) {
-		if (options.timestamp) {
-			let tag = "";
-			if (type === "info") tag = c.cyan(c.bold(prefix));
-			else if (type === "warn") tag = c.yellow(c.bold(prefix));
-			else tag = c.red(c.bold(prefix));
-			const environment = options.environment ? `${options.environment} ` : "";
-			return `${c.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
-		} else return msg;
-	}
-	function output(type, msg, options = {}) {
-		if (thresh >= LogLevels[type]) {
-			const method = type === "info" ? "log" : type;
-			if (options.error) loggedErrors.add(options.error);
-			if (canClearScreen) if (type === lastType && msg === lastMsg) {
-				sameCount++;
-				clear(console);
-				console[method](format(type, msg, options), c.yellow(`(x${sameCount + 1})`));
-			} else {
-				sameCount = 0;
-				lastMsg = msg;
-				lastType = type;
-				if (options.clear) clear(console);
-				console[method](format(type, msg, options));
-			}
-			else console[method](format(type, msg, options));
-		}
-	}
-	const warnedMessages = /* @__PURE__ */ new Set();
-	const logger = {
-		hasWarned: false,
-		info(msg, opts) {
-			output("info", msg, opts);
-		},
-		warn(msg, opts) {
-			logger.hasWarned = true;
-			output("warn", msg, opts);
-		},
-		warnOnce(msg, opts) {
-			if (warnedMessages.has(msg)) return;
-			logger.hasWarned = true;
-			output("warn", msg, opts);
-			warnedMessages.add(msg);
-		},
-		error(msg, opts) {
-			logger.hasWarned = true;
-			output("error", msg, opts);
-		},
-		clearScreen(type) {
-			if (thresh >= LogLevels[type]) clear(console);
-		},
-		hasErrorLogged(error) {
-			return loggedErrors.has(error);
-		}
-	};
-	return logger;
-}
-// silence warning by Vite for statically not analyzable dynamic import
-function silenceImportViteIgnoreWarning(logger) {
-	return {
-		...logger,
-		warn(msg, options) {
-			if (msg.includes("The above dynamic import cannot be analyzed by Vite")) return;
-			logger.warn(msg, options);
+			return ctx.coverageProvider?.onFileTransform?.(srcCode, id, this);
 		}
 	};
 }
 
-const cssLangs = "\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)";
-const cssLangRE = new RegExp(cssLangs);
-const cssModuleRE = new RegExp(`\\.module${cssLangs}`);
-const cssInlineRE = /[?&]inline(?:&|$)/;
-function isCSS(id) {
-	return cssLangRE.test(id);
-}
-function isCSSModule(id) {
-	return cssModuleRE.test(id);
-}
-// inline css requests are expected to just return the
-// string content directly and not the proxy module
-function isInline(id) {
-	return cssInlineRE.test(id);
-}
-function getCSSModuleProxyReturn(strategy, filename) {
-	if (strategy === "non-scoped") return "style";
-	const hash = generateCssFilenameHash(filename);
-	return `\`_\${style}_${hash}\``;
-}
-function CSSEnablerPlugin(ctx) {
-	const shouldProcessCSS = (id) => {
-		const { css } = ctx.config;
-		if (typeof css === "boolean") return css;
-		if (toArray(css.exclude).some((re) => re.test(id))) return false;
-		if (toArray(css.include).some((re) => re.test(id))) return true;
-		return false;
-	};
-	return [{
-		name: "vitest:css-disable",
-		enforce: "pre",
-		transform(code, id) {
-			if (!isCSS(id)) return;
-			// css plugin inside Vite won't do anything if the code is empty
-			// but it will put __vite__updateStyle anyway
-			if (!shouldProcessCSS(id)) return { code: "" };
-		}
-	}, {
-		name: "vitest:css-empty-post",
-		enforce: "post",
-		transform(_, id) {
-			if (!isCSS(id) || shouldProcessCSS(id)) return;
-			if (isCSSModule(id) && !isInline(id)) {
-				// return proxy for css modules, so that imported module has names:
-				// styles.foo returns a "foo" instead of "undefined"
-				// we don't use code content to generate hash for "scoped", because it's empty
-				const scopeStrategy = typeof ctx.config.css !== "boolean" && ctx.config.css.modules?.classNameStrategy || "stable";
-				const proxyReturn = getCSSModuleProxyReturn(scopeStrategy, relative(ctx.config.root, id));
-				const code = `export default new Proxy(Object.create(null), {
-            get(_, style) {
-              return ${proxyReturn};
-            },
-          })`;
-				return { code };
-			}
-			return { code: "export default \"\"" };
-		}
-	}];
-}
-
 var jsTokens_1;
 var hasRequiredJsTokens;
 
@@ -6494,66 +6492,244 @@ function stripLiteralDetailed(code, options) {
   return stripLiteralJsTokens(code);
 }
 
-const metaUrlLength = 15;
-const locationString = "self.location".padEnd(metaUrlLength, " ");
-// Vite transforms new URL('./path', import.meta.url) to new URL('/path.js', import.meta.url)
-// This makes "href" equal to "http://localhost:3000/path.js" in the browser, but if we keep it like this,
-// then in tests the URL will become "file:///path.js".
-// To battle this, we replace "import.meta.url" with "self.location" in the code to keep the browser behavior.
-function NormalizeURLPlugin() {
+// so people can reassign envs at runtime
+// import.meta.env.VITE_NAME = 'app' -> process.env.VITE_NAME = 'app'
+function MetaEnvReplacerPlugin() {
 	return {
-		name: "vitest:normalize-url",
-		enforce: "post",
-		transform(code, id, options) {
-			const ssr = options?.ssr === true;
-			if (ssr || !code.includes("new URL") || !code.includes("import.meta.url")) return;
-			const cleanString = stripLiteral(code);
-			const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*(?:'[^']+'|"[^"]+"|`[^`]+`)\s*,\s*(?:'' \+ )?import\.meta\.url\s*(?:,\s*)?\)/g;
-			let updatedCode = code;
-			let match;
-			// eslint-disable-next-line no-cond-assign
-			while (match = assetImportMetaUrlRE.exec(cleanString)) {
-				const { 0: exp, index } = match;
-				const metaUrlIndex = index + exp.indexOf("import.meta.url");
-				updatedCode = updatedCode.slice(0, metaUrlIndex) + locationString + updatedCode.slice(metaUrlIndex + metaUrlLength);
+		name: "vitest:meta-env-replacer",
+		enforce: "pre",
+		transform(code, id) {
+			if (!/\bimport\.meta\.env\b/.test(code)) return null;
+			let s = null;
+			const cleanCode = stripLiteral(code), envs = cleanCode.matchAll(/\bimport\.meta\.env\b/g);
+			for (const env of envs) {
+				s ||= new MagicString(code);
+				const startIndex = env.index, endIndex = startIndex + env[0].length;
+				s.overwrite(startIndex, endIndex, `Object.assign(/* istanbul ignore next */ globalThis.__vitest_worker__?.metaEnv ?? import.meta.env)`);
 			}
-			return {
-				code: updatedCode,
-				map: null
+			if (s) return {
+				code: s.toString(),
+				map: s.generateMap({
+					hires: "boundary",
+					source: cleanUrl(id)
+				})
 			};
 		}
 	};
 }
 
-function resolveOptimizerConfig(_testOptions, viteOptions) {
-	const testOptions = _testOptions || {};
-	const newConfig = {};
-	const [major, minor, fix] = version.split(".").map(Number);
-	const allowed = major >= 5 || major === 4 && minor >= 4 || major === 4 && minor === 3 && fix >= 2;
-	if (!allowed && testOptions?.enabled === true) console.warn(`Vitest: "deps.optimizer" is only available in Vite >= 4.3.2, current Vite version: ${version}`);
-	else testOptions.enabled ??= false;
-	if (!allowed || testOptions?.enabled !== true) {
-		newConfig.cacheDir = void 0;
-		newConfig.optimizeDeps = {
-			disabled: true,
-			entries: []
-		};
-	} else {
-		const currentInclude = testOptions.include || viteOptions?.include || [];
-		const exclude = [
-			"vitest",
-			"react",
-			"vue",
-			...testOptions.exclude || viteOptions?.exclude || []
-		];
-		const runtime = currentInclude.filter((n) => n.endsWith("jsx-dev-runtime") || n.endsWith("jsx-runtime"));
-		exclude.push(...runtime);
-		const include = (testOptions.include || viteOptions?.include || []).filter((n) => !exclude.includes(n));
-		newConfig.optimizeDeps = {
-			...viteOptions,
-			...testOptions,
-			noDiscovery: true,
-			disabled: false,
+function MocksPlugins(options = {}) {
+	const normalizedDistDir = normalize(distDir);
+	return [hoistMocksPlugin({
+		filter(id) {
+			return id.includes(normalizedDistDir) ? false : options.filter ? options.filter(id) : true;
+		},
+		codeFrameGenerator(node, id, code) {
+			return generateCodeFrame(code, 4, node.start + 1);
+		}
+	}), automockPlugin()];
+}
+
+function generateCssFilenameHash(filepath) {
+	return hash("sha1", filepath, "hex").slice(0, 6);
+}
+function generateScopedClassName(strategy, name, filename) {
+	// should be configured by Vite defaults
+	if (strategy === "scoped") return null;
+	if (strategy === "non-scoped") return name;
+	const hash = generateCssFilenameHash(filename);
+	return `_${name}_${hash}`;
+}
+
+const LogLevels = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3
+};
+function clearScreen(logger) {
+	const repeatCount = process.stdout.rows - 2, blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+	logger.clearScreen(blank);
+}
+let lastType, lastMsg, sameCount = 0, timeFormatter;
+function getTimeFormatter() {
+	return timeFormatter ??= new Intl.DateTimeFormat(void 0, {
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	}), timeFormatter;
+}
+// This is copy-pasted and needs to be synced from time to time. Ideally, Vite's `createLogger` should accept a custom `console`
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/logger.ts?rgh-link-date=2024-10-16T23%3A29%3A19Z
+// When Vitest supports only Vite 6 and above, we can use Vite's `createLogger({ console })`
+// https://github.com/vitejs/vite/pull/18379
+function createViteLogger(console, level = "info", options = {}) {
+	const loggedErrors = /* @__PURE__ */ new WeakSet(), { prefix = "[vite]", allowClearScreen = true } = options, thresh = LogLevels[level], canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI, clear = canClearScreen ? clearScreen : () => {};
+	function format(type, msg, options = {}) {
+		if (options.timestamp) {
+			let tag = "";
+			if (type === "info") tag = c.cyan(c.bold(prefix));
+			else if (type === "warn") tag = c.yellow(c.bold(prefix));
+			else tag = c.red(c.bold(prefix));
+			const environment = options.environment ? `${options.environment} ` : "";
+			return `${c.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
+		} else return msg;
+	}
+	function output(type, msg, options = {}) {
+		if (thresh >= LogLevels[type]) {
+			const method = type === "info" ? "log" : type;
+			if (options.error) loggedErrors.add(options.error);
+			if (canClearScreen) if (type === lastType && msg === lastMsg) sameCount++, clear(console), console[method](format(type, msg, options), c.yellow(`(x${sameCount + 1})`));
+			else {
+				if (sameCount = 0, lastMsg = msg, lastType = type, options.clear) clear(console);
+				console[method](format(type, msg, options));
+			}
+			else console[method](format(type, msg, options));
+		}
+	}
+	const warnedMessages = /* @__PURE__ */ new Set(), logger = {
+		hasWarned: false,
+		info(msg, opts) {
+			output("info", msg, opts);
+		},
+		warn(msg, opts) {
+			logger.hasWarned = true, output("warn", msg, opts);
+		},
+		warnOnce(msg, opts) {
+			warnedMessages.has(msg) || (logger.hasWarned = true, output("warn", msg, opts), warnedMessages.add(msg));
+		},
+		error(msg, opts) {
+			logger.hasWarned = true, output("error", msg, opts);
+		},
+		clearScreen(type) {
+			if (thresh >= LogLevels[type]) clear(console);
+		},
+		hasErrorLogged(error) {
+			return loggedErrors.has(error);
+		}
+	};
+	return logger;
+}
+// silence warning by Vite for statically not analyzable dynamic import
+function silenceImportViteIgnoreWarning(logger) {
+	return {
+		...logger,
+		warn(msg, options) {
+			msg.includes("The above dynamic import cannot be analyzed by Vite") || logger.warn(msg, options);
+		}
+	};
+}
+
+const cssLangs = "\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)", cssLangRE = new RegExp(cssLangs), cssModuleRE = /* @__PURE__ */ new RegExp(`\\.module${cssLangs}`), cssInlineRE = /[?&]inline(?:&|$)/;
+function isCSS(id) {
+	return cssLangRE.test(id);
+}
+function isCSSModule(id) {
+	return cssModuleRE.test(id);
+}
+// inline css requests are expected to just return the
+// string content directly and not the proxy module
+function isInline(id) {
+	return cssInlineRE.test(id);
+}
+function getCSSModuleProxyReturn(strategy, filename) {
+	if (strategy === "non-scoped") return "style";
+	const hash = generateCssFilenameHash(filename);
+	return `\`_\${style}_${hash}\``;
+}
+function CSSEnablerPlugin(ctx) {
+	const shouldProcessCSS = (id) => {
+		const { css } = ctx.config;
+		return typeof css === "boolean" ? css : toArray(css.exclude).some((re) => re.test(id)) ? false : !!toArray(css.include).some((re) => re.test(id));
+	};
+	return [{
+		name: "vitest:css-disable",
+		enforce: "pre",
+		transform(code, id) {
+			if (isCSS(id) && !shouldProcessCSS(id)) return { code: "" };
+		}
+	}, {
+		name: "vitest:css-empty-post",
+		enforce: "post",
+		transform(_, id) {
+			if (!(!isCSS(id) || shouldProcessCSS(id))) {
+				if (isCSSModule(id) && !isInline(id)) {
+					// return proxy for css modules, so that imported module has names:
+					// styles.foo returns a "foo" instead of "undefined"
+					// we don't use code content to generate hash for "scoped", because it's empty
+					const scopeStrategy = typeof ctx.config.css !== "boolean" && ctx.config.css.modules?.classNameStrategy || "stable", proxyReturn = getCSSModuleProxyReturn(scopeStrategy, relative(ctx.config.root, id)), code = `export default new Proxy(Object.create(null), {
+            get(_, style) {
+              return ${proxyReturn};
+            },
+          })`;
+					return { code };
+				}
+				return { code: "export default \"\"" };
+			}
+		}
+	}];
+}
+
+const metaUrlLength = 15, locationString = "self.location".padEnd(metaUrlLength, " ");
+// Vite transforms new URL('./path', import.meta.url) to new URL('/path.js', import.meta.url)
+// This makes "href" equal to "http://localhost:3000/path.js" in the browser, but if we keep it like this,
+// then in tests the URL will become "file:///path.js".
+// To battle this, we replace "import.meta.url" with "self.location" in the code to keep the browser behavior.
+function NormalizeURLPlugin() {
+	return {
+		name: "vitest:normalize-url",
+		enforce: "post",
+		transform(code) {
+			if (this.environment.name !== "client" || !code.includes("new URL") || !code.includes("import.meta.url")) return;
+			const cleanString = stripLiteral(code), assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*(?:'[^']+'|"[^"]+"|`[^`]+`)\s*,\s*(?:'' \+ )?import\.meta\.url\s*(?:,\s*)?\)/g;
+			let updatedCode = code, match;
+			// eslint-disable-next-line no-cond-assign
+			while (match = assetImportMetaUrlRE.exec(cleanString)) {
+				const { 0: exp, index } = match, metaUrlIndex = index + exp.indexOf("import.meta.url");
+				updatedCode = updatedCode.slice(0, metaUrlIndex) + locationString + updatedCode.slice(metaUrlIndex + metaUrlLength);
+			}
+			return {
+				code: updatedCode,
+				map: null
+			};
+		}
+	};
+}
+
+function VitestOptimizer() {
+	return {
+		name: "vitest:normalize-optimizer",
+		config: {
+			order: "post",
+			handler(viteConfig) {
+				const testConfig = viteConfig.test || {}, root = resolve(viteConfig.root || process.cwd()), name = viteConfig.test?.name, label = typeof name === "string" ? name : name?.label || "";
+				viteConfig.cacheDir = VitestCache.resolveCacheDir(resolve(root || process.cwd()), testConfig.cache != null && testConfig.cache !== false ? testConfig.cache.dir : viteConfig.cacheDir, label);
+			}
+		}
+	};
+}
+
+function resolveOptimizerConfig(_testOptions, viteOptions) {
+	const testOptions = _testOptions || {};
+	let optimizeDeps;
+	if (testOptions.enabled !== true) testOptions.enabled ??= false, optimizeDeps = {
+		disabled: true,
+		entries: []
+	};
+	else {
+		const currentInclude = testOptions.include || viteOptions?.include || [], exclude = [
+			"vitest",
+			"react",
+			"vue",
+			...testOptions.exclude || viteOptions?.exclude || []
+		], runtime = currentInclude.filter((n) => n.endsWith("jsx-dev-runtime") || n.endsWith("jsx-runtime"));
+		exclude.push(...runtime);
+		const include = (testOptions.include || viteOptions?.include || []).filter((n) => !exclude.includes(n));
+		optimizeDeps = {
+			...viteOptions,
+			...testOptions,
+			noDiscovery: true,
+			disabled: false,
 			entries: [],
 			exclude,
 			include
@@ -6561,23 +6737,12 @@ function resolveOptimizerConfig(_testOptions, viteOptions) {
 	}
 	// `optimizeDeps.disabled` is deprecated since v5.1.0-beta.1
 	// https://github.com/vitejs/vite/pull/15184
-	if (major >= 5 && minor >= 1 || major >= 6) {
-		if (newConfig.optimizeDeps.disabled) {
-			newConfig.optimizeDeps.noDiscovery = true;
-			newConfig.optimizeDeps.include = [];
-		}
-		delete newConfig.optimizeDeps.disabled;
-	}
-	return newConfig;
+	if (optimizeDeps.disabled) optimizeDeps.noDiscovery = true, optimizeDeps.include = [];
+	return delete optimizeDeps.disabled, optimizeDeps;
 }
 function deleteDefineConfig(viteConfig) {
 	const defines = {};
-	if (viteConfig.define) {
-		delete viteConfig.define["import.meta.vitest"];
-		delete viteConfig.define["process.env"];
-		delete viteConfig.define.process;
-		delete viteConfig.define.global;
-	}
+	if (viteConfig.define) delete viteConfig.define["import.meta.vitest"], delete viteConfig.define["process.env"], delete viteConfig.define.process, delete viteConfig.define.global;
 	for (const key in viteConfig.define) {
 		const val = viteConfig.define[key];
 		let replacement;
@@ -6590,26 +6755,20 @@ function deleteDefineConfig(viteConfig) {
 		}
 		if (key.startsWith("import.meta.env.")) {
 			const envKey = key.slice(16);
-			process.env[envKey] = replacement;
-			delete viteConfig.define[key];
+			process.env[envKey] = replacement, delete viteConfig.define[key];
 		} else if (key.startsWith("process.env.")) {
 			const envKey = key.slice(12);
-			process.env[envKey] = replacement;
-			delete viteConfig.define[key];
-		} else if (!key.includes(".")) {
-			defines[key] = replacement;
-			delete viteConfig.define[key];
-		}
+			process.env[envKey] = replacement, delete viteConfig.define[key];
+		} else if (!key.includes(".")) defines[key] = replacement, delete viteConfig.define[key];
 	}
 	return defines;
 }
 function resolveFsAllow(projectRoot, rootConfigFile) {
-	if (!rootConfigFile) return [searchForWorkspaceRoot(projectRoot), rootDir];
-	return [
+	return rootConfigFile ? [
 		dirname(rootConfigFile),
 		searchForWorkspaceRoot(projectRoot),
 		rootDir
-	];
+	] : [searchForWorkspaceRoot(projectRoot), rootDir];
 }
 function getDefaultResolveOptions() {
 	return {
@@ -6626,53 +6785,54 @@ function getDefaultServerConditions() {
 	return ["node"];
 }
 
-function VitestOptimizer() {
+function ModuleRunnerTransform() {
+	// make sure Vite always applies the module runner transform
 	return {
-		name: "vitest:normalize-optimizer",
+		name: "vitest:environments-module-runner",
 		config: {
 			order: "post",
-			handler(viteConfig) {
-				const testConfig = viteConfig.test || {};
-				const webOptimizer = resolveOptimizerConfig(testConfig.deps?.optimizer?.web, viteConfig.optimizeDeps);
-				const ssrOptimizer = resolveOptimizerConfig(testConfig.deps?.optimizer?.ssr, viteConfig.ssr?.optimizeDeps);
-				const root = resolve(viteConfig.root || process.cwd());
-				const name = viteConfig.test?.name;
-				const label = typeof name === "string" ? name : name?.label || "";
-				viteConfig.cacheDir = VitestCache.resolveCacheDir(resolve(root || process.cwd()), testConfig.cache != null && testConfig.cache !== false ? testConfig.cache.dir : viteConfig.cacheDir, label);
-				viteConfig.optimizeDeps = webOptimizer.optimizeDeps;
-				viteConfig.ssr ??= {};
-				viteConfig.ssr.optimizeDeps = ssrOptimizer.optimizeDeps;
+			handler(config) {
+				const testConfig = config.test || {};
+				config.environments ??= {};
+				const names = new Set(Object.keys(config.environments));
+				names.add("client"), names.add("ssr");
+				const pool = config.test?.pool;
+				if (pool === "vmForks" || pool === "vmThreads") names.add("__vitest_vm__");
+				const external = [], noExternal = [];
+				let noExternalAll;
+				for (const name of names) {
+					config.environments[name] ??= {};
+					const environment = config.environments[name];
+					// vm tests run using the native import mechanism
+					if (environment.dev ??= {}, name === "__vitest_vm__") environment.dev.moduleRunnerTransform = false, environment.consumer = "client";
+					else environment.dev.moduleRunnerTransform = true;
+					environment.dev.preTransformRequests = false, environment.keepProcessEnv = true;
+					const resolveExternal = name === "client" ? config.resolve?.external : [], resolveNoExternal = name === "client" ? config.resolve?.noExternal : [], topLevelResolveOptions = {};
+					if (resolveExternal != null) topLevelResolveOptions.external = resolveExternal;
+					if (resolveNoExternal != null) topLevelResolveOptions.noExternal = resolveNoExternal;
+					const currentResolveOptions = mergeConfig(topLevelResolveOptions, environment.resolve || {}), envNoExternal = resolveViteResolveOptions("noExternal", currentResolveOptions);
+					if (envNoExternal === true) noExternalAll = true;
+					else noExternal.push(...envNoExternal);
+					const envExternal = resolveViteResolveOptions("external", currentResolveOptions);
+					if (envExternal !== true) external.push(...envExternal);
+					if (environment.resolve ??= {}, environment.resolve.external = [...builtinModules, ...builtinModules.map((m) => `node:${m}`)], environment.resolve.noExternal = true, name === "__vitest_vm__" || name === "__vitest__") continue;
+					const currentOptimizeDeps = environment.optimizeDeps || (name === "client" ? config.optimizeDeps : name === "ssr" ? config.ssr?.optimizeDeps : void 0), optimizeDeps = resolveOptimizerConfig(testConfig.deps?.optimizer?.[name], currentOptimizeDeps);
+					// Vite respects the root level optimize deps, so we override it instead
+					if (name === "client") config.optimizeDeps = optimizeDeps, environment.optimizeDeps = void 0;
+					else if (name === "ssr") config.ssr ??= {}, config.ssr.optimizeDeps = optimizeDeps, environment.optimizeDeps = void 0;
+					else environment.optimizeDeps = optimizeDeps;
+				}
+				if (testConfig.server ??= {}, testConfig.server.deps ??= {}, testConfig.server.deps.inline !== true) {
+					if (noExternalAll) testConfig.server.deps.inline = true;
+					else if (noExternal.length) testConfig.server.deps.inline ??= [], testConfig.server.deps.inline.push(...noExternal);
+				}
+				if (external.length) testConfig.server.deps.external ??= [], testConfig.server.deps.external.push(...external);
 			}
 		}
 	};
 }
-
-// so people can reassign envs at runtime
-// import.meta.env.VITE_NAME = 'app' -> process.env.VITE_NAME = 'app'
-function SsrReplacerPlugin() {
-	return {
-		name: "vitest:ssr-replacer",
-		enforce: "pre",
-		transform(code, id) {
-			if (!/\bimport\.meta\.env\b/.test(code)) return null;
-			let s = null;
-			const cleanCode = stripLiteral(code);
-			const envs = cleanCode.matchAll(/\bimport\.meta\.env\b/g);
-			for (const env of envs) {
-				s ||= new MagicString(code);
-				const startIndex = env.index;
-				const endIndex = startIndex + env[0].length;
-				s.overwrite(startIndex, endIndex, "__vite_ssr_import_meta__.env");
-			}
-			if (s) return {
-				code: s.toString(),
-				map: s.generateMap({
-					hires: "boundary",
-					source: cleanUrl(id)
-				})
-			};
-		}
-	};
+function resolveViteResolveOptions(key, options) {
+	return Array.isArray(options[key]) ? options[key] : typeof options[key] === "string" || options[key] instanceof RegExp ? [options[key]] : typeof options[key] === "boolean" ? true : [];
 }
 
 function VitestProjectResolver(ctx) {
@@ -6683,7 +6843,7 @@ function VitestProjectResolver(ctx) {
 			if (id === "vitest" || id.startsWith("@vitest/") || id.startsWith("vitest/")) {
 				// always redirect the request to the root vitest plugin since
 				// it will be the one used to run Vitest
-				const resolved = await ctx.server.pluginContainer.resolveId(id, void 0, {
+				const resolved = await ctx.vite.pluginContainer.resolveId(id, void 0, {
 					skip: new Set([plugin]),
 					ssr
 				});
@@ -6719,23 +6879,16 @@ function WorkspaceVitestPlugin(project, options) {
 				};
 				if (!name) if (typeof options.workspacePath === "string") {
 					// if there is a package.json, read the name from it
-					const dir = options.workspacePath.endsWith("/") ? options.workspacePath.slice(0, -1) : dirname(options.workspacePath);
-					const pkgJsonPath = resolve(dir, "package.json");
+					const dir = options.workspacePath.endsWith("/") ? options.workspacePath.slice(0, -1) : dirname(options.workspacePath), pkgJsonPath = resolve(dir, "package.json");
 					if (existsSync(pkgJsonPath)) name = JSON.parse(readFileSync(pkgJsonPath, "utf-8")).name;
 					if (typeof name !== "string" || !name) name = basename(dir);
 				} else name = options.workspacePath.toString();
-				const isUserBrowserEnabled = viteConfig.test?.browser?.enabled;
-				const isBrowserEnabled = isUserBrowserEnabled ?? (viteConfig.test?.browser && project.vitest._cliOptions.browser?.enabled);
-				// keep project names to potentially filter it out
-				const workspaceNames = [name];
-				const browser = viteConfig.test.browser || {};
+				const isUserBrowserEnabled = viteConfig.test?.browser?.enabled, isBrowserEnabled = isUserBrowserEnabled ?? (viteConfig.test?.browser && project.vitest._cliOptions.browser?.enabled), workspaceNames = [name], browser = viteConfig.test.browser || {};
 				if (isBrowserEnabled && browser.name && !browser.instances?.length)
  // vitest injects `instances` in this case later on
 				workspaceNames.push(name ? `${name} (${browser.name})` : browser.name);
 				viteConfig.test?.browser?.instances?.forEach((instance) => {
-					// every instance is a potential project
-					instance.name ??= name ? `${name} (${instance.browser})` : instance.browser;
-					if (isBrowserEnabled) workspaceNames.push(instance.name);
+					if (instance.name ??= name ? `${name} (${instance.browser})` : instance.browser, isBrowserEnabled) workspaceNames.push(instance.name);
 				});
 				const filters = project.vitest.config.project;
 				// if there is `--project=...` filter, check if any of the potential projects match
@@ -6747,10 +6900,13 @@ function WorkspaceVitestPlugin(project, options) {
 					});
 					if (!hasProject) throw new VitestFilteredOutProjectError();
 				}
-				return { test: { name: {
-					label: name,
-					color
-				} } };
+				return {
+					environments: { __vitest__: { dev: {} } },
+					test: { name: {
+						label: name,
+						color
+					} }
+				};
 			}
 		},
 		{
@@ -6760,22 +6916,14 @@ function WorkspaceVitestPlugin(project, options) {
 				this.meta.watchMode = false;
 			},
 			config(viteConfig) {
-				const defines = deleteDefineConfig(viteConfig);
-				const testConfig = viteConfig.test || {};
-				const root = testConfig.root || viteConfig.root || options.root;
-				const resolveOptions = getDefaultResolveOptions();
-				const config = {
+				const defines = deleteDefineConfig(viteConfig), testConfig = viteConfig.test || {}, root = testConfig.root || viteConfig.root || options.root, resolveOptions = getDefaultResolveOptions();
+				let config = {
 					root,
 					define: { "process.env.NODE_ENV": "process.env.NODE_ENV" },
 					resolve: {
 						...resolveOptions,
 						alias: testConfig.alias
 					},
-					esbuild: viteConfig.esbuild === false ? false : {
-						target: viteConfig.esbuild?.target || "node18",
-						sourcemap: "external",
-						legalComments: "inline"
-					},
 					server: {
 						watch: null,
 						open: false,
@@ -6788,19 +6936,27 @@ function WorkspaceVitestPlugin(project, options) {
 					environments: { ssr: { resolve: resolveOptions } },
 					test: {}
 				};
+				if ("rolldownVersion" in vite) config = {
+					...config,
+					oxc: viteConfig.oxc === false ? false : { target: viteConfig.oxc?.target || "node18" }
+				};
+				else config = {
+					...config,
+					esbuild: viteConfig.esbuild === false ? false : {
+						target: viteConfig.esbuild?.target || "node18",
+						sourcemap: "external",
+						legalComments: "inline"
+					}
+				};
 				config.test.defines = defines;
 				const classNameStrategy = typeof testConfig.css !== "boolean" && testConfig.css?.modules?.classNameStrategy || "stable";
 				if (classNameStrategy !== "scoped") {
-					config.css ??= {};
-					config.css.modules ??= {};
-					if (config.css.modules) config.css.modules.generateScopedName = (name, filename) => {
+					if (config.css ??= {}, config.css.modules ??= {}, config.css.modules) config.css.modules.generateScopedName = (name, filename) => {
 						const root = project.config.root;
 						return generateScopedClassName(classNameStrategy, name, relative(root, filename));
 					};
 				}
-				config.customLogger = createViteLogger(project.vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false });
-				config.customLogger = silenceImportViteIgnoreWarning(config.customLogger);
-				return config;
+				return config.customLogger = createViteLogger(project.vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false }), config.customLogger = silenceImportViteIgnoreWarning(config.customLogger), config;
 			}
 		},
 		{
@@ -6808,33 +6964,120 @@ function WorkspaceVitestPlugin(project, options) {
 			enforce: "post",
 			async configureServer(server) {
 				const options = deepMerge({}, configDefaults, server.config.test || {});
-				await project._configureServer(options, server);
-				await server.watcher.close();
+				await project._configureServer(options, server), await server.watcher.close();
 			}
 		},
-		SsrReplacerPlugin(),
+		MetaEnvReplacerPlugin(),
 		...CSSEnablerPlugin(project),
 		CoverageTransform(project.vitest),
 		...MocksPlugins(),
 		VitestProjectResolver(project.vitest),
 		VitestOptimizer(),
-		NormalizeURLPlugin()
+		NormalizeURLPlugin(),
+		ModuleRunnerTransform()
 	];
 }
 
+class VitestResolver {
+	options;
+	externalizeCache = /* @__PURE__ */ new Map();
+	constructor(cacheDir, config) {
+		this.options = {
+			moduleDirectories: config.deps.moduleDirectories,
+			inlineFiles: config.setupFiles.flatMap((file) => {
+				if (file.startsWith("file://")) return file;
+				const resolvedId = resolve(file);
+				return [resolvedId, pathToFileURL(resolvedId).href];
+			}),
+			cacheDir,
+			inline: config.server.deps?.inline,
+			external: config.server.deps?.external
+		};
+	}
+	shouldExternalize(file) {
+		return shouldExternalize(normalizeId(file), this.options, this.externalizeCache);
+	}
+}
+function normalizeId(id) {
+	if (id.startsWith("/@fs/")) id = id.slice(isWindows ? 5 : 4);
+	return id;
+}
+const BUILTIN_EXTENSIONS = new Set([
+	".mjs",
+	".cjs",
+	".node",
+	".wasm"
+]), ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/, ESM_FOLDER_RE = /\/(es|esm)\/(.*\.js)$/, defaultInline = [
+	/virtual:/,
+	/\.[mc]?ts$/,
+	/[?&](init|raw|url|inline)\b/,
+	KNOWN_ASSET_RE,
+	/^(?!.*node_modules).*\.mjs$/,
+	/^(?!.*node_modules).*\.cjs\.js$/,
+	/vite\w*\/dist\/client\/env.mjs/
+], depsExternal = [/\/node_modules\/.*\.cjs\.js$/, /\/node_modules\/.*\.mjs$/];
+function guessCJSversion(id) {
+	if (id.match(ESM_EXT_RE)) {
+		for (const i of [
+			id.replace(ESM_EXT_RE, ".mjs"),
+			id.replace(ESM_EXT_RE, ".umd.js"),
+			id.replace(ESM_EXT_RE, ".cjs.js"),
+			id.replace(ESM_EXT_RE, ".js")
+		]) if (existsSync(i)) return i;
+	}
+	if (id.match(ESM_FOLDER_RE)) {
+		for (const i of [
+			id.replace(ESM_FOLDER_RE, "/umd/$1"),
+			id.replace(ESM_FOLDER_RE, "/cjs/$1"),
+			id.replace(ESM_FOLDER_RE, "/lib/$1"),
+			id.replace(ESM_FOLDER_RE, "/$1")
+		]) if (existsSync(i)) return i;
+	}
+}
+// The code from https://github.com/unjs/mlly/blob/c5bcca0cda175921344fd6de1bc0c499e73e5dac/src/syntax.ts#L51-L98
+async function isValidNodeImport(id) {
+	const extension = extname(id);
+	if (BUILTIN_EXTENSIONS.has(extension)) return true;
+	if (extension !== ".js") return false;
+	id = id.replace("file:///", "");
+	const package_ = findNearestPackageData(dirname(id));
+	if (package_.type === "module") return true;
+	if (/\.(?:\w+-)?esm?(?:-\w+)?\.js$|\/esm?\//.test(id)) return false;
+	try {
+		await esModuleLexer.init;
+		const code = await promises.readFile(id, "utf8"), [, , , hasModuleSyntax] = esModuleLexer.parse(code);
+		return !hasModuleSyntax;
+	} catch {
+		return false;
+	}
+}
+async function shouldExternalize(id, options, cache) {
+	if (!cache.has(id)) cache.set(id, _shouldExternalize(id, options));
+	return cache.get(id);
+}
+async function _shouldExternalize(id, options) {
+	// data: should be processed by native import,
+	// since it is a feature of ESM.
+	// also externalize network imports since nodejs allows it when --experimental-network-imports
+	if (isBuiltin(id) || id.startsWith("data:") || /^(?:https?:)?\/\//.test(id)) return id;
+	const moduleDirectories = options?.moduleDirectories || ["/node_modules/"];
+	if (matchExternalizePattern(id, moduleDirectories, options?.inline) || options?.inlineFiles && options?.inlineFiles.includes(id)) return false;
+	// Unless the user explicitly opted to inline them, externalize Vite deps.
+	// They are too big to inline by default.
+	if (matchExternalizePattern(id, moduleDirectories, options?.external) || options?.cacheDir && id.includes(options.cacheDir)) return id;
+	const isLibraryModule = moduleDirectories.some((dir) => id.includes(dir)), guessCJS = isLibraryModule && options?.fallbackCJS;
+	return id = guessCJS ? guessCJSversion(id) || id : id, matchExternalizePattern(id, moduleDirectories, defaultInline) ? false : matchExternalizePattern(id, moduleDirectories, depsExternal) || isLibraryModule && await isValidNodeImport(id) ? id : false;
+}
+function matchExternalizePattern(id, moduleDirectories, patterns) {
+	if (patterns == null) return false;
+	if (patterns === true) return true;
+	for (const ex of patterns) if (typeof ex === "string") {
+		if (moduleDirectories.some((dir) => id.includes(join(dir, ex)))) return true;
+	} else if (ex.test(id)) return true;
+	return false;
+}
+
 class TestSpecification {
-	/**
-	* @deprecated use `project` instead
-	*/
-	0;
-	/**
-	* @deprecated use `moduleId` instead
-	*/
-	1;
-	/**
-	* @deprecated use `pool` instead
-	*/
-	2;
 	/**
 	* The task ID associated with the test module.
 	*/
@@ -6857,24 +7100,15 @@ class TestSpecification {
 	*/
 	testLines;
 	constructor(project, moduleId, pool, testLines) {
-		this[0] = project;
-		this[1] = moduleId;
-		this[2] = { pool };
-		const name = project.config.name;
-		const hashName = pool !== "typescript" ? name : name ? `${name}:__typecheck__` : "__typecheck__";
-		this.taskId = generateFileHash(relative(project.config.root, moduleId), hashName);
-		this.project = project;
-		this.moduleId = moduleId;
-		this.pool = pool;
-		this.testLines = testLines;
+		const name = project.config.name, hashName = pool !== "typescript" ? name : name ? `${name}:__typecheck__` : "__typecheck__";
+		this.taskId = generateFileHash(relative(project.config.root, moduleId), hashName), this.project = project, this.moduleId = moduleId, this.pool = pool, this.testLines = testLines;
 	}
 	/**
 	* Test module associated with the specification.
 	*/
 	get testModule() {
 		const task = this.project.vitest.state.idMap.get(this.taskId);
-		if (!task) return void 0;
-		return this.project.vitest.state.getReportedEntity(task);
+		return task ? this.project.vitest.state.getReportedEntity(task) : void 0;
 	}
 	toJSON() {
 		return [
@@ -6889,15 +7123,6 @@ class TestSpecification {
 			}
 		];
 	}
-	/**
-	* for backwards compatibility
-	* @deprecated
-	*/
-	*[Symbol.iterator]() {
-		yield this.project;
-		yield this.moduleId;
-		yield this.pool;
-	}
 }
 
 async function createViteServer(inlineConfig) {
@@ -6905,12 +7130,10 @@ async function createViteServer(inlineConfig) {
 	// But Vitest works correctly either way
 	const error = console.error;
 	console.error = (...args) => {
-		if (typeof args[0] === "string" && args[0].includes("WebSocket server error:")) return;
-		error(...args);
+		typeof args[0] === "string" && args[0].includes("WebSocket server error:") || error(...args);
 	};
 	const server = await createServer(inlineConfig);
-	console.error = error;
-	return server;
+	return console.error = error, server;
 }
 
 class TestProject {
@@ -6927,29 +7150,24 @@ class TestProject {
 	* Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
 	*/
 	browser;
-	/** @deprecated use `vitest` instead */
-	ctx;
 	/**
 	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
 	*/
 	tmpDir = join(tmpdir(), nanoid());
-	/** @internal */ vitenode;
 	/** @internal */ typechecker;
 	/** @internal */ _config;
 	/** @internal */ _vite;
 	/** @internal */ _hash;
+	/** @internal */ _resolver;
+	/** @internal */ _serializedDefines;
+	/** @inetrnal */ testFilesList = null;
 	runner;
 	closingPromise;
-	testFilesList = null;
 	typecheckFilesList = null;
 	_globalSetups;
 	_provided = {};
-	constructor(path, vitest, options) {
-		this.path = path;
-		this.options = options;
-		this.vitest = vitest;
-		this.ctx = vitest;
-		this.globalConfig = vitest.config;
+	constructor(vitest, options) {
+		this.options = options, this.vitest = vitest, this.globalConfig = vitest.config;
 	}
 	/**
 	* The unique hash of this project. This value is consistent between the reruns.
@@ -6978,10 +7196,9 @@ class TestProject {
 	* Get the provided context. The project context is merged with the global context.
 	*/
 	getProvidedContext() {
-		if (this.isRootProject()) return this._provided;
 		// globalSetup can run even if core workspace is not part of the test run
 		// so we need to inherit its provided context
-		return {
+		return this.isRootProject() ? this._provided : {
 			...this.vitest.getRootProject().getProvidedContext(),
 			...this._provided
 		};
@@ -6991,7 +7208,7 @@ class TestProject {
 	* @param moduleId The file path
 	*/
 	createSpecification(moduleId, locations, pool) {
-		return new TestSpecification(this, moduleId, pool || getFilePoolName(this, moduleId), locations);
+		return new TestSpecification(this, moduleId, pool || getFilePoolName(this), locations);
 	}
 	toJSON() {
 		return {
@@ -7005,13 +7222,11 @@ class TestProject {
 	*/
 	get vite() {
 		if (!this._vite) throw new Error("The server was not set. It means that `project.vite` was called before the Vite server was established.");
-		// checking it once should be enough
-		Object.defineProperty(this, "vite", {
+		return Object.defineProperty(this, "vite", {
 			configurable: true,
 			writable: true,
 			value: this._vite
-		});
-		return this._vite;
+		}), this._vite;
 	}
 	/**
 	* Resolved project configuration.
@@ -7044,85 +7259,38 @@ class TestProject {
 	get serializedConfig() {
 		return this._serializeOverriddenConfig();
 	}
-	/** @deprecated use `vite` instead */
-	get server() {
-		return this._vite;
-	}
 	/**
 	* Check if this is the root project. The root project is the one that has the root config.
 	*/
 	isRootProject() {
 		return this.vitest.getRootProject() === this;
 	}
-	/** @deprecated use `isRootProject` instead */
-	isCore() {
-		return this.isRootProject();
-	}
-	/** @deprecated use `createSpecification` instead */
-	createSpec(moduleId, pool) {
-		return new TestSpecification(this, moduleId, pool);
-	}
-	/** @deprecated */
-	initializeGlobalSetup() {
-		return this._initializeGlobalSetup();
-	}
 	/** @internal */
 	async _initializeGlobalSetup() {
-		if (this._globalSetups) return;
-		this._globalSetups = await loadGlobalSetupFiles(this.runner, this.config.globalSetup);
-		for (const globalSetupFile of this._globalSetups) {
-			const teardown = await globalSetupFile.setup?.(this);
-			if (teardown == null || !!globalSetupFile.teardown) continue;
-			if (typeof teardown !== "function") throw new TypeError(`invalid return value in globalSetup file ${globalSetupFile.file}. Must return a function`);
-			globalSetupFile.teardown = teardown;
+		if (!this._globalSetups) {
+			this._globalSetups = await loadGlobalSetupFiles(this.runner, this.config.globalSetup);
+			for (const globalSetupFile of this._globalSetups) {
+				const teardown = await globalSetupFile.setup?.(this);
+				if (teardown == null || !!globalSetupFile.teardown) continue;
+				if (typeof teardown !== "function") throw new TypeError(`invalid return value in globalSetup file ${globalSetupFile.file}. Must return a function`);
+				globalSetupFile.teardown = teardown;
+			}
 		}
 	}
 	onTestsRerun(cb) {
 		this.vitest.onTestsRerun(cb);
 	}
-	/** @deprecated */
-	teardownGlobalSetup() {
-		return this._teardownGlobalSetup();
-	}
 	/** @internal */
 	async _teardownGlobalSetup() {
-		if (!this._globalSetups) return;
-		for (const globalSetupFile of [...this._globalSetups].reverse()) await globalSetupFile.teardown?.();
-	}
-	/** @deprecated use `vitest.logger` instead */
-	get logger() {
-		return this.vitest.logger;
-	}
-	// it's possible that file path was imported with different queries (?raw, ?url, etc)
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getModulesByFilepath(file) {
-		const set = this.server.moduleGraph.getModulesByFile(file) || this.browser?.vite.moduleGraph.getModulesByFile(file);
-		return set || /* @__PURE__ */ new Set();
-	}
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getModuleById(id) {
-		return this.server.moduleGraph.getModuleById(id) || this.browser?.vite.moduleGraph.getModuleById(id);
-	}
-	/** @deprecated use `.vite` or `.browser.vite` directly */
-	getSourceMapModuleById(id) {
-		const mod = this.server.moduleGraph.getModuleById(id);
-		return mod?.ssrTransformResult?.map || mod?.transformResult?.map;
-	}
-	/** @deprecated use `vitest.reporters` instead */
-	get reporters() {
-		return this.ctx.reporters;
+		if (this._globalSetups) for (const globalSetupFile of [...this._globalSetups].reverse()) await globalSetupFile.teardown?.();
 	}
 	/**
 	* Get all files in the project that match the globs in the config and the filters.
 	* @param filters String filters to match the test files.
 	*/
 	async globTestFiles(filters = []) {
-		const dir = this.config.dir || this.config.root;
-		const { include, exclude, includeSource } = this.config;
-		const typecheck = this.config.typecheck;
-		const [testFiles, typecheckTestFiles] = await Promise.all([typecheck.enabled && typecheck.only ? [] : this.globAllTestFiles(include, exclude, includeSource, dir), typecheck.enabled ? this.typecheckFilesList || this.globFiles(typecheck.include, typecheck.exclude, dir) : []]);
-		this.typecheckFilesList = typecheckTestFiles;
-		return {
+		const dir = this.config.dir || this.config.root, { include, exclude, includeSource } = this.config, typecheck = this.config.typecheck, [testFiles, typecheckTestFiles] = await Promise.all([typecheck.enabled && typecheck.only ? [] : this.globAllTestFiles(include, exclude, includeSource, dir), typecheck.enabled ? this.typecheckFilesList || this.globFiles(typecheck.include, typecheck.exclude, dir) : []]);
+		return this.typecheckFilesList = typecheckTestFiles, {
 			testFiles: this.filterFiles(testFiles, filters, dir),
 			typecheckTestFiles: this.filterFiles(typecheckTestFiles, filters, dir)
 		};
@@ -7141,8 +7309,7 @@ class TestProject {
 				}
 			}));
 		}
-		this.testFilesList = testFiles;
-		return testFiles;
+		return this.testFilesList = testFiles, testFiles;
 	}
 	isBrowserEnabled() {
 		return isBrowserEnabled(this.config);
@@ -7168,10 +7335,6 @@ class TestProject {
 	_isCachedTypecheckFile(testPath) {
 		return !!this.typecheckFilesList && this.typecheckFilesList.includes(testPath);
 	}
-	/** @deprecated use `serializedConfig` instead */
-	getSerializableConfig() {
-		return this._serializeOverriddenConfig();
-	}
 	/** @internal */
 	async globFiles(include, exclude, cwd) {
 		const globOptions = {
@@ -7179,8 +7342,7 @@ class TestProject {
 			cwd,
 			ignore: exclude,
 			expandDirectories: false
-		};
-		const files = await glob(include, globOptions);
+		}, files = await glob(include, globOptions);
 		// keep the slashes consistent with Vite
 		// we are not using the pathe here because it normalizes the drive letter on Windows
 		// and we want to keep it the same as working dir
@@ -7193,29 +7355,19 @@ class TestProject {
 		if (this._isCachedTestFile(moduleId)) return true;
 		const relativeId = relative(this.config.dir || this.config.root, moduleId);
 		if (pm.isMatch(relativeId, this.config.exclude)) return false;
-		if (pm.isMatch(relativeId, this.config.include)) {
-			this.markTestFile(moduleId);
-			return true;
-		}
+		if (pm.isMatch(relativeId, this.config.include)) return this.markTestFile(moduleId), true;
 		if (this.config.includeSource?.length && pm.isMatch(relativeId, this.config.includeSource)) {
 			const code = source?.() || readFileSync(moduleId, "utf-8");
-			if (this.isInSourceTestCode(code)) {
-				this.markTestFile(moduleId);
-				return true;
-			}
+			if (this.isInSourceTestCode(code)) return this.markTestFile(moduleId), true;
 		}
 		return false;
 	}
-	/** @deprecated use `matchesTestGlob` instead */
-	async isTargetFile(id, source) {
-		return this.matchesTestGlob(id, source ? () => source : void 0);
-	}
 	isInSourceTestCode(code) {
 		return code.includes("import.meta.vitest");
 	}
 	filterFiles(testFiles, filters, dir) {
 		if (filters.length && process.platform === "win32") filters = filters.map((f) => slash(f));
-		if (filters.length) return testFiles.filter((t) => {
+		return filters.length ? testFiles.filter((t) => {
 			const testFile = relative(dir, t).toLocaleLowerCase();
 			return filters.some((f) => {
 				// if filter is a full file path, we should include it if it's in the same folder
@@ -7223,8 +7375,7 @@ class TestProject {
 				const relativePath = f.endsWith("/") ? join(relative(dir, f), "/") : relative(dir, f);
 				return testFile.includes(f.toLocaleLowerCase()) || testFile.includes(relativePath.toLocaleLowerCase());
 			});
-		});
-		return testFiles;
+		}) : testFiles;
 	}
 	_parentBrowser;
 	/** @internal */
@@ -7235,25 +7386,23 @@ class TestProject {
 		await this.vitest.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.vitest.version);
 		const { createBrowserServer, distRoot } = await import('@vitest/browser');
 		let cacheDir;
-		const browser = await createBrowserServer(this, this.vite.config.configFile, [{
-			name: "vitest:browser-cacheDir",
-			configResolved(config) {
-				cacheDir = config.cacheDir;
-			}
-		}, ...MocksPlugins({ filter(id) {
-			if (id.includes(distRoot) || id.includes(cacheDir)) return false;
-			return true;
-		} })], [CoverageTransform(this.vitest)]);
-		this._parentBrowser = browser;
-		if (this.config.browser.ui) setup(this.vitest, browser.vite);
+		const browser = await createBrowserServer(this, this.vite.config.configFile, [
+			{
+				name: "vitest:browser-cacheDir",
+				configResolved(config) {
+					cacheDir = config.cacheDir;
+				}
+			},
+			...MocksPlugins({ filter(id) {
+				return !(id.includes(distRoot) || id.includes(cacheDir));
+			} }),
+			MetaEnvReplacerPlugin()
+		], [CoverageTransform(this.vitest)]);
+		if (this._parentBrowser = browser, this.config.browser.ui) setup(this.vitest, browser.vite);
 	});
 	/** @internal */
 	_initBrowserServer = deduped(async () => {
-		await this._parent?._initParentBrowser();
-		if (!this.browser && this._parent?._parentBrowser) {
-			this.browser = this._parent._parentBrowser.spawn(this);
-			await this.vitest.report("onBrowserInit", this);
-		}
+		if (await this._parent?._initParentBrowser(), !this.browser && this._parent?._parentBrowser) this.browser = this._parent._parentBrowser.spawn(this), await this.vitest.report("onBrowserInit", this);
 	});
 	/**
 	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
@@ -7266,8 +7415,7 @@ class TestProject {
 			this.browser?.close(),
 			this.clearTmpDir()
 		].filter(Boolean)).then(() => {
-			this._provided = {};
-			this._vite = void 0;
+			this._provided = {}, this._vite = void 0;
 		});
 		return this.closingPromise;
 	}
@@ -7276,66 +7424,41 @@ class TestProject {
 	* @param moduleId The ID of the module in Vite module graph
 	*/
 	import(moduleId) {
-		return this.runner.executeId(moduleId);
-	}
-	/** @deprecated use `name` instead */
-	getName() {
-		return this.config.name || "";
-	}
-	/** @deprecated internal */
-	setServer(options, server) {
-		return this._configureServer(options, server);
+		return this.runner.import(moduleId);
 	}
 	_setHash() {
 		this._hash = generateHash(this._config.root + this._config.name);
 	}
 	/** @internal */
 	async _configureServer(options, server) {
-		this._config = resolveConfig(this.vitest, {
+		for (const _providedKey in this._config = resolveConfig(this.vitest, {
 			...options,
 			coverage: this.vitest.config.coverage
-		}, server.config);
-		this._setHash();
-		for (const _providedKey in this.config.provide) {
+		}, server.config), this._setHash(), this.config.provide) {
 			const providedKey = _providedKey;
 			// type is very strict here, so we cast it to any
 			this.provide(providedKey, this.config.provide[providedKey]);
 		}
-		this.closingPromise = void 0;
-		this._vite = server;
-		this.vitenode = new ViteNodeServer(server, this.config.server);
-		const node = this.vitenode;
-		this.runner = new ViteNodeRunner({
-			root: server.config.root,
-			base: server.config.base,
-			fetchModule(id) {
-				return node.fetchModule(id);
-			},
-			resolveId(id, importer) {
-				return node.resolveId(id, importer);
-			}
-		});
+		this.closingPromise = void 0, this._resolver = new VitestResolver(server.config.cacheDir, this._config), this._vite = server, this._serializedDefines = createDefinesScript(server.config.define);
+		const environment = server.environments.__vitest__;
+		this.runner = new ServerModuleRunner(environment, this._resolver, this._config);
 	}
 	_serializeOverriddenConfig() {
 		// TODO: serialize the config _once_ or when needed
-		const config = serializeConfig(this.config, this.vitest.config, this.vite.config);
-		if (!this.vitest.configOverride) return config;
-		return deepMerge(config, this.vitest.configOverride);
+		const config = serializeConfig(this);
+		return this.vitest.configOverride ? deepMerge(config, this.vitest.configOverride) : config;
 	}
 	async clearTmpDir() {
 		try {
 			await rm(this.tmpDir, { recursive: true });
 		} catch {}
 	}
-	/** @deprecated */
-	initBrowserProvider() {
-		return this._initBrowserProvider();
-	}
 	/** @internal */
 	_initBrowserProvider = deduped(async () => {
-		if (!this.isBrowserEnabled() || this.browser?.provider) return;
-		if (!this.browser) await this._initBrowserServer();
-		await this.browser?.initBrowserProvider(this);
+		if (!(!this.isBrowserEnabled() || this.browser?.provider)) {
+			if (!this.browser) await this._initBrowserServer();
+			await this.browser?.initBrowserProvider(this);
+		}
 	});
 	/** @internal */
 	_provideObject(context) {
@@ -7347,41 +7470,26 @@ class TestProject {
 	}
 	/** @internal */
 	static _createBasicProject(vitest) {
-		const project = new TestProject(vitest.config.name || vitest.config.root, vitest);
-		project.vitenode = vitest.vitenode;
-		project.runner = vitest.runner;
-		project._vite = vitest.server;
-		project._config = vitest.config;
-		project._setHash();
-		project._provideObject(vitest.config.provide);
-		return project;
+		const project = new TestProject(vitest);
+		return project.runner = vitest.runner, project._vite = vitest.vite, project._config = vitest.config, project._resolver = vitest._resolver, project._serializedDefines = createDefinesScript(vitest.vite.config.define), project._setHash(), project._provideObject(vitest.config.provide), project;
 	}
 	/** @internal */
 	static _cloneBrowserProject(parent, config) {
-		const clone = new TestProject(parent.path, parent.vitest);
-		clone.vitenode = parent.vitenode;
-		clone.runner = parent.runner;
-		clone._vite = parent._vite;
-		clone._config = config;
-		clone._setHash();
-		clone._parent = parent;
-		clone._provideObject(config.provide);
-		return clone;
+		const clone = new TestProject(parent.vitest);
+		return clone.runner = parent.runner, clone._vite = parent._vite, clone._resolver = parent._resolver, clone._config = config, clone._setHash(), clone._parent = parent, clone._serializedDefines = parent._serializedDefines, clone._provideObject(config.provide), clone;
 	}
 }
 function deduped(cb) {
 	let _promise;
-	return (...args) => {
+	return ((...args) => {
 		if (!_promise) _promise = cb(...args).finally(() => {
 			_promise = void 0;
 		});
 		return _promise;
-	};
+	});
 }
 async function initializeProject(workspacePath, ctx, options) {
-	const project = new TestProject(workspacePath, ctx, options);
-	const { configFile,...restOptions } = options;
-	const config = {
+	const project = new TestProject(ctx, options), { configFile,...restOptions } = options, config = {
 		...restOptions,
 		configFile,
 		configLoader: ctx.vite.config.inlineConfig.configLoader,
@@ -7391,25 +7499,20 @@ async function initializeProject(workspacePath, ctx, options) {
 			workspacePath
 		})]
 	};
-	await createViteServer(config);
-	return project;
+	return await createViteServer(config), project;
 }
 function generateHash(str) {
 	let hash = 0;
 	if (str.length === 0) return `${hash}`;
 	for (let i = 0; i < str.length; i++) {
 		const char = str.charCodeAt(i);
-		hash = (hash << 5) - hash + char;
-		hash = hash & hash;
+		hash = (hash << 5) - hash + char, hash = hash & hash;
 	}
 	return `${hash}`;
 }
 
 async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projectsDefinition, names) {
-	const { configFiles, projectConfigs, nonConfigDirectories } = await resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDefinition);
-	// cli options that affect the project config,
-	// not all options are allowed to be overridden
-	const overridesOptions = [
+	const { configFiles, projectConfigs, nonConfigDirectories } = await resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDefinition), overridesOptions = [
 		"logHeapUsage",
 		"allowOnly",
 		"sequence",
@@ -7428,21 +7531,12 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		"inspect",
 		"inspectBrk",
 		"fileParallelism"
-	];
-	const cliOverrides = overridesOptions.reduce((acc, name) => {
+	], cliOverrides = overridesOptions.reduce((acc, name) => {
 		if (name in cliOptions) acc[name] = cliOptions[name];
 		return acc;
-	}, {});
-	const projectPromises = [];
-	const fileProjects = [...configFiles, ...nonConfigDirectories];
-	const concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
+	}, {}), projectPromises = [], fileProjects = [...configFiles, ...nonConfigDirectories], concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
 	projectConfigs.forEach((options, index) => {
-		const configRoot = workspaceConfigPath ? dirname(workspaceConfigPath) : vitest.config.root;
-		// if extends a config file, resolve the file path
-		const configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : options.extends === true ? vitest.vite.config.configFile || false : false;
-		// if `root` is configured, resolve it relative to the workspace file or vite root (like other options)
-		// if `root` is not specified, inline configs use the same root as the root project
-		const root = options.root ? resolve(configRoot, options.root) : vitest.config.root;
+		const configRoot = vitest.config.root, configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : options.extends === true ? vitest.vite.config.configFile || false : false, root = options.root ? resolve(configRoot, options.root) : vitest.config.root;
 		projectPromises.push(concurrent(() => initializeProject(index, vitest, {
 			...options,
 			root,
@@ -7460,8 +7554,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 			if (project) projectPromises.push(Promise.resolve(project));
 			continue;
 		}
-		const configFile = path.endsWith("/") ? false : path;
-		const root = path.endsWith("/") ? path : dirname(path);
+		const configFile = path.endsWith("/") ? false : path, root = path.endsWith("/") ? path : dirname(path);
 		projectPromises.push(concurrent(() => initializeProject(path, vitest, {
 			root,
 			configFile,
@@ -7474,9 +7567,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		vitest.config.project.length ? `The filter matched no projects: ${vitest.config.project.join(", ")}. ` : "",
 		`The projects definition: ${JSON.stringify(projectsDefinition, null, 4)}.`
 	].join(""));
-	const resolvedProjectsPromises = await Promise.allSettled(projectPromises);
-	const errors = [];
-	const resolvedProjects = [];
+	const resolvedProjectsPromises = await Promise.allSettled(projectPromises), errors = [], resolvedProjects = [];
 	for (const result of resolvedProjectsPromises) if (result.status === "rejected") {
 		if (result.reason instanceof VitestFilteredOutProjectError)
  // filter out filtered out projects
@@ -7488,8 +7579,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 	for (const project of resolvedProjects) {
 		const name = project.name;
 		if (names.has(name)) {
-			const duplicate = resolvedProjects.find((p) => p.name === name && p !== project);
-			const filesError = fileProjects.length ? [
+			const duplicate = resolvedProjects.find((p) => p.name === name && p !== project), filesError = fileProjects.length ? [
 				"\n\nYour config matched these files:\n",
 				fileProjects.map((p) => ` - ${relative(vitest.config.root, p)}`).join("\n"),
 				"\n\n"
@@ -7511,24 +7601,18 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	const removeProjects = /* @__PURE__ */ new Set();
 	resolvedProjects.forEach((project) => {
 		if (!project.config.browser.enabled) return;
-		const instances = project.config.browser.instances || [];
-		const browser = project.config.browser.name;
-		if (instances.length === 0 && browser) {
-			instances.push({
-				browser,
-				name: project.name ? `${project.name} (${browser})` : browser
-			});
-			vitest.logger.warn(withLabel("yellow", "Vitest", [
-				`No browser "instances" were defined`,
-				project.name ? ` for the "${project.name}" project. ` : ". ",
-				`Running tests in "${project.config.browser.name}" browser. `,
-				"The \"browser.name\" field is deprecated since Vitest 3. ",
-				"Read more: https://vitest.dev/guide/browser/config#browser-instances"
-			].filter(Boolean).join("")));
-		}
-		const originalName = project.config.name;
-		// if original name is in the --project=name filter, keep all instances
-		const filteredInstances = vitest.matchesProjectFilter(originalName) ? instances : instances.filter((instance) => {
+		const instances = project.config.browser.instances || [], browser = project.config.browser.name;
+		if (instances.length === 0 && browser) instances.push({
+			browser,
+			name: project.name ? `${project.name} (${browser})` : browser
+		}), vitest.logger.warn(withLabel("yellow", "Vitest", [
+			`No browser "instances" were defined`,
+			project.name ? ` for the "${project.name}" project. ` : ". ",
+			`Running tests in "${project.config.browser.name}" browser. `,
+			"The \"browser.name\" field is deprecated since Vitest 3. ",
+			"Read more: https://vitest.dev/guide/browser/config#browser-instances"
+		].filter(Boolean).join("")));
+		const originalName = project.config.name, filteredInstances = vitest.matchesProjectFilter(originalName) ? instances : instances.filter((instance) => {
 			const newName = instance.name;
 			return vitest.matchesProjectFilter(newName);
 		});
@@ -7537,12 +7621,10 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			removeProjects.add(project);
 			return;
 		}
-		if (project.config.browser.providerOptions) vitest.logger.warn(withLabel("yellow", "Vitest", `"providerOptions"${originalName ? ` in "${originalName}" project` : ""} is ignored because it's overridden by the configs. To hide this warning, remove the "providerOptions" property from the browser configuration.`));
 		filteredInstances.forEach((config, index) => {
 			const browser = config.browser;
 			if (!browser) {
-				const nth = index + 1;
-				const ending = nth === 2 ? "nd" : nth === 3 ? "rd" : "th";
+				const nth = index + 1, ending = nth === 2 ? "nd" : nth === 3 ? "rd" : "th";
 				throw new Error(`The browser configuration must have a "browser" property. The ${nth}${ending} item in "browser.instances" doesn't have it. Make sure your${originalName ? ` "${originalName}"` : ""} configuration is correct.`);
 			}
 			const name = config.name;
@@ -7557,18 +7639,15 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			clonedConfig.name = name;
 			const clone = TestProject._cloneBrowserProject(project, clonedConfig);
 			resolvedProjects.push(clone);
-		});
-		removeProjects.add(project);
-	});
-	resolvedProjects = resolvedProjects.filter((project) => !removeProjects.has(project));
+		}), removeProjects.add(project);
+	}), resolvedProjects = resolvedProjects.filter((project) => !removeProjects.has(project));
 	const headedBrowserProjects = resolvedProjects.filter((project) => {
 		return project.config.browser.enabled && !project.config.browser.headless;
 	});
 	if (headedBrowserProjects.length > 1) {
 		const message = [`Found multiple projects that run browser tests in headed mode: "${headedBrowserProjects.map((p) => p.name).join("\", \"")}".`, ` Vitest cannot run multiple headed browsers at the same time.`].join("");
 		if (!isTTY) throw new Error(`${message} Please, filter projects with --browser=name or --project=name flag or run tests with "headless: true" option.`);
-		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; });
-		const { projectName } = await prompts.default({
+		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; }), { projectName } = await prompts.default({
 			type: "select",
 			name: "projectName",
 			choices: headedBrowserProjects.map((project) => ({
@@ -7583,10 +7662,9 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	return resolvedProjects;
 }
 function cloneConfig(project, { browser,...config }) {
-	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name,...overrideConfig } = config;
-	const currentConfig = project.config.browser;
+	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name, provider,...overrideConfig } = config, currentConfig = project.config.browser, clonedConfig = deepClone(project.config);
 	return mergeConfig({
-		...deepClone(project.config),
+		...clonedConfig,
 		browser: {
 			...project.config.browser,
 			locators: locators ? { testIdAttribute: locators.testIdAttribute ?? currentConfig.locators.testIdAttribute } : project.config.browser.locators,
@@ -7595,21 +7673,18 @@ function cloneConfig(project, { browser,...config }) {
 			screenshotDirectory: screenshotDirectory ?? currentConfig.screenshotDirectory,
 			screenshotFailures: screenshotFailures ?? currentConfig.screenshotFailures,
 			headless: headless ?? currentConfig.headless,
+			provider: provider ?? currentConfig.provider,
 			name: browser,
-			providerOptions: config,
-			instances: void 0
-		}
+			instances: []
+		},
+		include: overrideConfig.include && overrideConfig.include.length > 0 ? [] : clonedConfig.include,
+		exclude: overrideConfig.exclude && overrideConfig.exclude.length > 0 ? [] : clonedConfig.exclude,
+		includeSource: overrideConfig.includeSource && overrideConfig.includeSource.length > 0 ? [] : clonedConfig.includeSource
 	}, overrideConfig);
 }
 async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDefinition) {
 	// project configurations that were specified directly
-	const projectsOptions = [];
-	// custom config files that were specified directly or resolved from a directory
-	const projectsConfigFiles = [];
-	// custom glob matches that should be resolved as directories or config files
-	const projectsGlobMatches = [];
-	// directories that don't have a config file inside, but should be treated as projects
-	const nonConfigProjectDirectories = [];
+	const projectsOptions = [], projectsConfigFiles = [], projectsGlobMatches = [], nonConfigProjectDirectories = [];
 	for (const definition of projectsDefinition) if (typeof definition === "string") {
 		const stringOption = definition.replace("<rootDir>", vitest.config.root);
 		// if the string doesn't contain a glob, we can resolve it directly
@@ -7617,8 +7692,7 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 		if (!isDynamicPattern(stringOption)) {
 			const file = resolve(vitest.config.root, stringOption);
 			if (!existsSync(file)) {
-				const relativeWorkspaceConfigPath = workspaceConfigPath ? relative(vitest.config.root, workspaceConfigPath) : void 0;
-				const note = workspaceConfigPath ? `Workspace config file "${relativeWorkspaceConfigPath}"` : "Projects definition";
+				const note = "Projects definition";
 				throw new Error(`${note} references a non-existing file or a directory: ${file}`);
 			}
 			const stats = await promises.stat(file);
@@ -7628,7 +7702,7 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 				const configFile = await resolveDirectoryConfig(file);
 				if (configFile) projectsConfigFiles.push(configFile);
 				else {
-					const directory = file[file.length - 1] === "/" ? file : `${file}/`;
+					const directory = file.at(-1) === "/" ? file : `${file}/`;
 					nonConfigProjectDirectories.push(directory);
 				}
 			} else
@@ -7654,8 +7728,7 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 				"**/*.timestamp-*",
 				"**/.DS_Store"
 			]
-		};
-		const projectsFs = await glob(projectsGlobMatches, globOptions);
+		}, projectsFs = await glob(projectsGlobMatches, globOptions);
 		await Promise.all(projectsFs.map(async (path) => {
 			// directories are allowed with a glob like `packages/*`
 			// in this case every directory is treated as a project
@@ -7674,21 +7747,15 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 	};
 }
 async function resolveDirectoryConfig(directory) {
-	const files = new Set(await promises.readdir(directory));
-	// default resolution looks for vitest.config.* or vite.config.* files
-	// this simulates how `findUp` works in packages/vitest/src/node/create.ts:29
-	const configFile = configFiles.find((file) => files.has(file));
-	if (configFile) return resolve(directory, configFile);
-	return null;
+	const files = new Set(await promises.readdir(directory)), configFile = configFiles.find((file) => files.has(file));
+	return configFile ? resolve(directory, configFile) : null;
 }
 function getDefaultTestProject(vitest) {
-	const filter = vitest.config.project;
-	const project = vitest._ensureRootProject();
+	const filter = vitest.config.project, project = vitest._ensureRootProject();
 	if (!filter.length) return project;
 	// check for the project name and browser names
 	const hasProjects = getPotentialProjectNames(project).some((p) => vitest.matchesProjectFilter(p));
-	if (hasProjects) return project;
-	return null;
+	return hasProjects ? project : null;
 }
 function getPotentialProjectNames(project) {
 	const names = [project.name];
@@ -7700,7 +7767,7 @@ function getPotentialProjectNames(project) {
 async function loadCustomReporterModule(path, runner) {
 	let customReporterModule;
 	try {
-		customReporterModule = await runner.executeId(path);
+		customReporterModule = await runner.import(path);
 	} catch (customReporterModuleError) {
 		throw new Error(`Failed to load custom Reporter from ${path}`, { cause: customReporterModuleError });
 	}
@@ -7708,12 +7775,11 @@ async function loadCustomReporterModule(path, runner) {
 	return customReporterModule.default;
 }
 function createReporters(reporterReferences, ctx) {
-	const runner = ctx.runner;
-	const promisedReporters = reporterReferences.map(async (referenceOrInstance) => {
+	const runner = ctx.runner, promisedReporters = reporterReferences.map(async (referenceOrInstance) => {
 		if (Array.isArray(referenceOrInstance)) {
 			const [reporterName, reporterOptions] = referenceOrInstance;
 			if (reporterName === "html") {
-				await ctx.packageInstaller.ensureInstalled("@vitest/ui", runner.root, ctx.version);
+				await ctx.packageInstaller.ensureInstalled("@vitest/ui", ctx.config.root, ctx.version);
 				const CustomReporter = await loadCustomReporterModule("@vitest/ui/reporter", runner);
 				return new CustomReporter(reporterOptions);
 			} else if (reporterName in ReportersMap) {
@@ -7750,14 +7816,12 @@ function parseFilter(filter) {
 		filename: parsedFilename,
 		lineNumber: Number.parseInt(lineNumber)
 	};
-	else if (lineNumber.match(/^\d+-\d+$/)) throw new RangeLocationFilterProvidedError(filter);
-	else return { filename: filter };
+	if (lineNumber.match(/^\d+-\d+$/)) throw new RangeLocationFilterProvidedError(filter);
+	return { filename: filter };
 }
 function groupFilters(filters) {
-	const groupedFilters_ = groupBy(filters, (f) => f.filename);
-	const groupedFilters = Object.fromEntries(Object.entries(groupedFilters_).map((entry) => {
-		const [filename, filters] = entry;
-		const testLocations = filters.map((f) => f.lineNumber);
+	const groupedFilters_ = groupBy(filters, (f) => f.filename), groupedFilters = Object.fromEntries(Object.entries(groupedFilters_).map((entry) => {
+		const [filename, filters] = entry, testLocations = filters.map((f) => f.lineNumber);
 		return [filename, testLocations.filter((l) => l !== void 0)];
 	}));
 	return groupedFilters;
@@ -7776,45 +7840,35 @@ class VitestSpecifications {
 			if (project._isCachedTestFile(moduleId)) specs.push(project.createSpecification(moduleId));
 			if (project._isCachedTypecheckFile(moduleId)) specs.push(project.createSpecification(moduleId, [], "typescript"));
 		}
-		specs.forEach((spec) => this.ensureSpecificationCached(spec));
-		return specs;
+		return specs.forEach((spec) => this.ensureSpecificationCached(spec)), specs;
 	}
 	async getRelevantTestSpecifications(filters = []) {
 		return this.filterTestsBySource(await this.globTestSpecifications(filters));
 	}
 	async globTestSpecifications(filters = []) {
-		const files = [];
-		const dir = process.cwd();
-		const parsedFilters = filters.map((f) => parseFilter(f));
+		const files = [], dir = process.cwd(), parsedFilters = filters.map((f) => parseFilter(f));
 		// Require includeTaskLocation when a location filter is passed
 		if (!this.vitest.config.includeTaskLocation && parsedFilters.some((f) => f.lineNumber !== void 0)) throw new IncludeTaskLocationDisabledError();
 		const testLines = groupFilters(parsedFilters.map((f) => ({
 			...f,
 			filename: resolve(dir, f.filename)
-		})));
-		// Key is file and val specifies whether we have matched this file with testLocation
-		const testLocHasMatch = {};
-		await Promise.all(this.vitest.projects.map(async (project) => {
+		}))), testLocHasMatch = {};
+		return await Promise.all(this.vitest.projects.map(async (project) => {
 			const { testFiles, typecheckTestFiles } = await project.globTestFiles(parsedFilters.map((f) => f.filename));
 			testFiles.forEach((file) => {
 				const lines = testLines[file];
 				testLocHasMatch[file] = true;
 				const spec = project.createSpecification(file, lines);
-				this.ensureSpecificationCached(spec);
-				files.push(spec);
-			});
-			typecheckTestFiles.forEach((file) => {
+				this.ensureSpecificationCached(spec), files.push(spec);
+			}), typecheckTestFiles.forEach((file) => {
 				const lines = testLines[file];
 				testLocHasMatch[file] = true;
 				const spec = project.createSpecification(file, lines, "typescript");
-				this.ensureSpecificationCached(spec);
-				files.push(spec);
+				this.ensureSpecificationCached(spec), files.push(spec);
 			});
-		}));
-		Object.entries(testLines).forEach(([filepath, loc]) => {
+		})), Object.entries(testLines).forEach(([filepath, loc]) => {
 			if (loc.length !== 0 && !testLocHasMatch[filepath]) throw new LocationFilterFileNotFoundError(relative(dir, filepath));
-		});
-		return files;
+		}), files;
 	}
 	clearCache(moduleId) {
 		if (moduleId) this._cachedSpecs.delete(moduleId);
@@ -7824,30 +7878,20 @@ class VitestSpecifications {
 		return this._cachedSpecs.get(moduleId);
 	}
 	ensureSpecificationCached(spec) {
-		const file = spec.moduleId;
-		const specs = this._cachedSpecs.get(file) || [];
-		const index = specs.findIndex((_s) => _s.project === spec.project && _s.pool === spec.pool);
-		if (index === -1) {
-			specs.push(spec);
-			this._cachedSpecs.set(file, specs);
-		} else specs.splice(index, 1, spec);
+		const file = spec.moduleId, specs = this._cachedSpecs.get(file) || [], index = specs.findIndex((_s) => _s.project === spec.project && _s.pool === spec.pool);
+		if (index === -1) specs.push(spec), this._cachedSpecs.set(file, specs);
+		else specs.splice(index, 1, spec);
 		return specs;
 	}
 	async filterTestsBySource(specs) {
 		if (this.vitest.config.changed && !this.vitest.config.related) {
-			const { VitestGit } = await import('./git.BVQ8w_Sw.js');
-			const vitestGit = new VitestGit(this.vitest.config.root);
-			const related = await vitestGit.findChangedFiles({ changedSince: this.vitest.config.changed });
-			if (!related) {
-				process.exitCode = 1;
-				throw new GitNotFoundError();
-			}
+			const { VitestGit } = await import('./git.BFNcloKD.js'), vitestGit = new VitestGit(this.vitest.config.root), related = await vitestGit.findChangedFiles({ changedSince: this.vitest.config.changed });
+			if (!related) throw process.exitCode = 1, new GitNotFoundError();
 			this.vitest.config.related = Array.from(new Set(related));
 		}
 		const related = this.vitest.config.related;
 		if (!related) return specs;
-		const forceRerunTriggers = this.vitest.config.forceRerunTriggers;
-		const matcher = forceRerunTriggers.length ? pm(forceRerunTriggers) : void 0;
+		const forceRerunTriggers = this.vitest.config.forceRerunTriggers, matcher = forceRerunTriggers.length ? pm(forceRerunTriggers) : void 0;
 		if (matcher && related.some((file) => matcher(file))) return specs;
 		// don't run anything if no related sources are found
 		// if we are in watch mode, we want to process all tests
@@ -7855,8 +7899,7 @@ class VitestSpecifications {
 		const testGraphs = await Promise.all(specs.map(async (spec) => {
 			const deps = await this.getTestDependencies(spec);
 			return [spec, deps];
-		}));
-		const runningTests = [];
+		})), runningTests = [];
 		for (const [specification, deps] of testGraphs)
  // if deps or the test itself were changed
 		if (related.some((path) => path === specification.moduleId || deps.has(path))) runningTests.push(specification);
@@ -7866,8 +7909,7 @@ class VitestSpecifications {
 		const addImports = async (project, filepath) => {
 			if (deps.has(filepath)) return;
 			deps.add(filepath);
-			const mod = project.vite.moduleGraph.getModuleById(filepath);
-			const transformed = mod?.ssrTransformResult || await project.vitenode.transformRequest(filepath);
+			const mod = project.vite.environments.ssr.moduleGraph.getModuleById(filepath), transformed = mod?.transformResult || await project.vite.environments.ssr.transformRequest(filepath);
 			if (!transformed) return;
 			const dependencies = [...transformed.deps || [], ...transformed.dynamicDeps || []];
 			await Promise.all(dependencies.map(async (dep) => {
@@ -7875,9 +7917,7 @@ class VitestSpecifications {
 				if (!fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) await addImports(project, fsPath);
 			}));
 		};
-		await addImports(spec.project, spec.moduleId);
-		deps.delete(spec.moduleId);
-		return deps;
+		return await addImports(spec.project, spec.moduleId), deps.delete(spec.moduleId), deps;
 	}
 }
 
@@ -7903,10 +7943,7 @@ class ReportedTaskImplementation {
 	location;
 	/** @internal */
 	constructor(task, project) {
-		this.task = task;
-		this.project = project;
-		this.id = task.id;
-		this.location = task.location;
+		this.task = task, this.project = project, this.id = task.id, this.location = task.location;
 	}
 	/**
 	* Checks if the test did not fail the suite.
@@ -7928,8 +7965,7 @@ class ReportedTaskImplementation {
 	*/
 	static register(task, project) {
 		const state = new this(task, project);
-		storeTask(project, task, state);
-		return state;
+		return storeTask(project, task, state), state;
 	}
 }
 class TestCase extends ReportedTaskImplementation {
@@ -7953,9 +7989,7 @@ class TestCase extends ReportedTaskImplementation {
 	parent;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.name = task.name;
-		this.module = getReportedTask(project, task.file);
+		super(task, project), this.name = task.name, this.module = getReportedTask(project, task.file);
 		const suite = this.task.suite;
 		if (suite) this.parent = getReportedTask(project, suite);
 		else this.parent = this.module;
@@ -7977,8 +8011,7 @@ class TestCase extends ReportedTaskImplementation {
 	* - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
 	*/
 	result() {
-		const result = this.task.result;
-		const mode = result?.state || this.task.mode;
+		const result = this.task.result, mode = result?.state || this.task.mode;
 		if (!result && (mode === "skip" || mode === "todo")) return {
 			state: "skipped",
 			note: void 0,
@@ -7989,16 +8022,14 @@ class TestCase extends ReportedTaskImplementation {
 			errors: void 0
 		};
 		const state = result.state === "fail" ? "failed" : result.state === "pass" ? "passed" : "skipped";
-		if (state === "skipped") return {
+		return state === "skipped" ? {
 			state,
 			note: result.note,
 			errors: void 0
-		};
-		if (state === "passed") return {
+		} : state === "passed" ? {
 			state,
 			errors: result.errors
-		};
-		return {
+		} : {
 			state,
 			errors: result.errors || []
 		};
@@ -8017,8 +8048,7 @@ class TestCase extends ReportedTaskImplementation {
 		const result = this.task.result;
 		// startTime should always be available if the test has properly finished
 		if (!result || !result.startTime) return void 0;
-		const duration = result.duration || 0;
-		const slow = duration > this.project.globalConfig.slowTestThreshold;
+		const duration = result.duration || 0, slow = duration > this.project.globalConfig.slowTestThreshold;
 		return {
 			slow,
 			heap: result.heap,
@@ -8034,8 +8064,7 @@ class TestCollection {
 	#task;
 	#project;
 	constructor(task, project) {
-		this.#task = task;
-		this.#project = project;
+		this.#task = task, this.#project = project;
 	}
 	/**
 	* Returns the test or suite at a specific index.
@@ -8088,10 +8117,7 @@ class TestCollection {
 	* Filters all suites that are part of this collection and its children.
 	*/
 	*allSuites() {
-		for (const child of this) if (child.type === "suite") {
-			yield child;
-			yield* child.children.allSuites();
-		}
+		for (const child of this) if (child.type === "suite") yield child, yield* child.children.allSuites();
 	}
 	*[Symbol.iterator]() {
 		for (const task of this.#task.tasks) yield getReportedTask(this.#project, task);
@@ -8104,8 +8130,7 @@ class SuiteImplementation extends ReportedTaskImplementation {
 	children;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.children = new TestCollection(task, project);
+		super(task, project), this.children = new TestCollection(task, project);
 	}
 	/**
 	* Errors that happened outside of the test run during collection, like syntax errors.
@@ -8135,9 +8160,7 @@ class TestSuite extends SuiteImplementation {
 	options;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.name = task.name;
-		this.module = getReportedTask(project, task.file);
+		super(task, project), this.name = task.name, this.module = getReportedTask(project, task.file);
 		const suite = this.task.suite;
 		if (suite) this.parent = getReportedTask(project, suite);
 		else this.parent = this.module;
@@ -8166,31 +8189,27 @@ class TestModule extends SuiteImplementation {
 	* This value corresponds to the ID in the Vite's module graph.
 	*/
 	moduleId;
+	/**
+	* Module id relative to the project. This is the same as `task.name`.
+	*/
+	relativeModuleId;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.moduleId = task.filepath;
+		super(task, project), this.moduleId = task.filepath, this.relativeModuleId = task.name;
 	}
 	/**
 	* Checks the running state of the test file.
 	*/
 	state() {
 		const state = this.task.result?.state;
-		if (state === "queued") return "queued";
-		return getSuiteState(this.task);
+		return state === "queued" ? "queued" : getSuiteState(this.task);
 	}
 	/**
 	* Useful information about the module like duration, memory usage, etc.
 	* If the module was not executed yet, all diagnostic values will return `0`.
 	*/
 	diagnostic() {
-		const setupDuration = this.task.setupDuration || 0;
-		const collectDuration = this.task.collectDuration || 0;
-		const prepareDuration = this.task.prepareDuration || 0;
-		const environmentSetupDuration = this.task.environmentLoad || 0;
-		const duration = this.task.result?.duration || 0;
-		const heap = this.task.result?.heap;
-		const importDurations = this.task.importDurations ?? {};
+		const setupDuration = this.task.setupDuration || 0, collectDuration = this.task.collectDuration || 0, prepareDuration = this.task.prepareDuration || 0, environmentSetupDuration = this.task.environmentLoad || 0, duration = this.task.result?.duration || 0, heap = this.task.result?.heap, importDurations = this.task.importDurations ?? {};
 		return {
 			environmentSetupDuration,
 			prepareDuration,
@@ -8222,18 +8241,19 @@ function getReportedTask(project, runnerTask) {
 	return reportedTask;
 }
 function getSuiteState(task) {
-	const mode = task.mode;
-	const state = task.result?.state;
+	const mode = task.mode, state = task.result?.state;
 	if (mode === "skip" || mode === "todo" || state === "skip" || state === "todo") return "skipped";
 	if (state == null || state === "run" || state === "only") return "pending";
 	if (state === "fail") return "failed";
 	if (state === "pass") return "passed";
 	throw new Error(`Unknown suite state: ${state}`);
 }
+function experimental_getRunnerTask(entity) {
+	return entity.task;
+}
 
 function isAggregateError(err) {
-	if (typeof AggregateError !== "undefined" && err instanceof AggregateError) return true;
-	return err instanceof Error && "errors" in err;
+	return typeof AggregateError !== "undefined" && err instanceof AggregateError ? true : err instanceof Error && "errors" in err;
 }
 class StateManager {
 	filesMap = /* @__PURE__ */ new Map();
@@ -8244,25 +8264,30 @@ class StateManager {
 	processTimeoutCauses = /* @__PURE__ */ new Set();
 	reportedTasksMap = /* @__PURE__ */ new WeakMap();
 	blobs;
-	catchError(err, type) {
-		if (isAggregateError(err)) return err.errors.forEach((error) => this.catchError(error, type));
-		if (err === Object(err)) err.type = type;
-		else err = {
+	transformTime = 0;
+	onUnhandledError;
+	/** @internal */
+	_data = {
+		browserLastPort: defaultBrowserPort,
+		timeoutIncreased: false
+	};
+	constructor(options) {
+		this.onUnhandledError = options.onUnhandledError;
+	}
+	catchError(error, type) {
+		if (isAggregateError(error)) return error.errors.forEach((error) => this.catchError(error, type));
+		if (typeof error === "object" && error !== null) error.type = type;
+		else error = {
 			type,
-			message: err
+			message: error
 		};
-		const _err = err;
-		if (_err && typeof _err === "object" && _err.code === "VITEST_PENDING") {
-			const task = this.idMap.get(_err.taskId);
-			if (task) {
-				task.mode = "skip";
-				task.result ??= { state: "skip" };
-				task.result.state = "skip";
-				task.result.note = _err.note;
-			}
+		const _error = error;
+		if (_error && typeof _error === "object" && _error.code === "VITEST_PENDING") {
+			const task = this.idMap.get(_error.taskId);
+			if (task) task.mode = "skip", task.result ??= { state: "skip" }, task.result.state = "skip", task.result.note = _error.note;
 			return;
 		}
-		this.errorsSet.add(err);
+		if (!this.onUnhandledError || this.onUnhandledError(error) !== false) this.errorsSet.add(error);
 	}
 	clearErrors() {
 		this.errorsSet.clear();
@@ -8283,12 +8308,8 @@ class StateManager {
 	* Return files that were running or collected.
 	*/
 	getFiles(keys) {
-		if (keys) return keys.map((key) => this.filesMap.get(key)).flat().filter((file) => file && !file.local);
-		return Array.from(this.filesMap.values()).flat().filter((file) => !file.local).sort((f1, f2) => {
-			// print typecheck files first
-			if (f1.meta?.typecheck && f2.meta?.typecheck) return 0;
-			if (f1.meta?.typecheck) return -1;
-			return 1;
+		return keys ? keys.map((key) => this.filesMap.get(key)).flat().filter((file) => file && !file.local) : Array.from(this.filesMap.values()).flat().filter((file) => !file.local).sort((f1, f2) => {
+			return f1.meta?.typecheck && f2.meta?.typecheck ? 0 : f1.meta?.typecheck ? -1 : 1;
 		});
 	}
 	getTestModules(keys) {
@@ -8307,25 +8328,17 @@ class StateManager {
 	}
 	collectFiles(project, files = []) {
 		files.forEach((file) => {
-			const existing = this.filesMap.get(file.filepath) || [];
-			const otherFiles = existing.filter((i) => i.projectName !== file.projectName || i.meta.typecheck !== file.meta.typecheck);
-			const currentFile = existing.find((i) => i.projectName === file.projectName);
+			const existing = this.filesMap.get(file.filepath) || [], otherFiles = existing.filter((i) => i.projectName !== file.projectName || i.meta.typecheck !== file.meta.typecheck), currentFile = existing.find((i) => i.projectName === file.projectName);
 			// keep logs for the previous file because it should always be initiated before the collections phase
 			// which means that all logs are collected during the collection and not inside tests
 			if (currentFile) file.logs = currentFile.logs;
-			otherFiles.push(file);
-			this.filesMap.set(file.filepath, otherFiles);
-			this.updateId(file, project);
+			otherFiles.push(file), this.filesMap.set(file.filepath, otherFiles), this.updateId(file, project);
 		});
 	}
 	clearFiles(project, paths = []) {
 		paths.forEach((path) => {
-			const files = this.filesMap.get(path);
-			const fileTask = createFileTask(path, project.config.root, project.config.name);
-			fileTask.local = true;
-			TestModule.register(fileTask, project);
-			this.idMap.set(fileTask.id, fileTask);
-			if (!files) {
+			const files = this.filesMap.get(path), fileTask = createFileTask$1(path, project.config.root, project.config.name);
+			if (fileTask.local = true, TestModule.register(fileTask, project), this.idMap.set(fileTask.id, fileTask), !files) {
 				this.filesMap.set(path, [fileTask]);
 				return;
 			}
@@ -8336,14 +8349,14 @@ class StateManager {
 		});
 	}
 	updateId(task, project) {
-		if (this.idMap.get(task.id) === task) return;
-		if (task.type === "suite" && "filepath" in task) TestModule.register(task, project);
-		else if (task.type === "suite") TestSuite.register(task, project);
-		else TestCase.register(task, project);
-		this.idMap.set(task.id, task);
-		if (task.type === "suite") task.tasks.forEach((task) => {
-			this.updateId(task, project);
-		});
+		if (this.idMap.get(task.id) !== task) {
+			if (task.type === "suite" && "filepath" in task) TestModule.register(task, project);
+			else if (task.type === "suite") TestSuite.register(task, project);
+			else TestCase.register(task, project);
+			if (this.idMap.set(task.id, task), task.type === "suite") task.tasks.forEach((task) => {
+				this.updateId(task, project);
+			});
+		}
 	}
 	getReportedEntity(task) {
 		return this.reportedTasksMap.get(task);
@@ -8352,10 +8365,8 @@ class StateManager {
 		for (const [id, result, meta] of packs) {
 			const task = this.idMap.get(id);
 			if (task) {
-				task.result = result;
-				task.meta = meta;
 				// skipped with new PendingError
-				if (result?.state === "skip") task.mode = "skip";
+				if (task.result = result, task.meta = meta, result?.state === "skip") task.mode = "skip";
 			}
 		}
 	}
@@ -8370,7 +8381,7 @@ class StateManager {
 		return Array.from(this.idMap.values()).filter((t) => t.result?.state === "fail").length;
 	}
 	cancelFiles(files, project) {
-		this.collectFiles(project, files.map((filepath) => createFileTask(filepath, project.config.root, project.config.name)));
+		this.collectFiles(project, files.map((filepath) => createFileTask$1(filepath, project.config.root, project.config.name)));
 	}
 }
 
@@ -8832,10 +8843,7 @@ class TestRun {
 	}
 	async start(specifications) {
 		const filepaths = specifications.map((spec) => spec.moduleId);
-		this.vitest.state.collectPaths(filepaths);
-		await this.vitest.report("onPathsCollected", Array.from(new Set(filepaths)));
-		await this.vitest.report("onSpecsCollected", specifications.map((spec) => spec.toJSON()));
-		await this.vitest.report("onTestRunStart", [...specifications]);
+		this.vitest.state.collectPaths(filepaths), await this.vitest.report("onTestRunStart", [...specifications]);
 	}
 	async enqueued(project, file) {
 		this.vitest.state.collectFiles(project, [file]);
@@ -8843,30 +8851,22 @@ class TestRun {
 		await this.vitest.report("onTestModuleQueued", testModule);
 	}
 	async collected(project, files) {
-		this.vitest.state.collectFiles(project, files);
-		await Promise.all([this.vitest.report("onCollected", files), ...files.map((file) => {
+		this.vitest.state.collectFiles(project, files), await Promise.all(files.map((file) => {
 			const testModule = this.vitest.state.getReportedEntity(file);
 			return this.vitest.report("onTestModuleCollected", testModule);
-		})]);
+		}));
 	}
 	async log(log) {
-		this.vitest.state.updateUserLog(log);
-		await this.vitest.report("onUserConsoleLog", log);
+		this.vitest.state.updateUserLog(log), await this.vitest.report("onUserConsoleLog", log);
 	}
 	async annotate(testId, annotation) {
-		const task = this.vitest.state.idMap.get(testId);
-		const entity = task && this.vitest.state.getReportedEntity(task);
-		assert$1(task && entity, `Entity must be found for task ${task?.name || testId}`);
-		assert$1(entity.type === "test", `Annotation can only be added to a test, instead got ${entity.type}`);
-		await this.resolveTestAttachment(entity, annotation);
-		entity.task.annotations.push(annotation);
-		await this.vitest.report("onTestCaseAnnotate", entity, annotation);
-		return annotation;
+		const task = this.vitest.state.idMap.get(testId), entity = task && this.vitest.state.getReportedEntity(task);
+		return assert$1(task && entity, `Entity must be found for task ${task?.name || testId}`), assert$1(entity.type === "test", `Annotation can only be added to a test, instead got ${entity.type}`), await this.resolveTestAttachment(entity, annotation), entity.task.annotations.push(annotation), await this.vitest.report("onTestCaseAnnotate", entity, annotation), annotation;
 	}
 	async updated(update, events) {
-		this.vitest.state.updateTasks(update);
+		this.syncUpdateStacks(update), this.vitest.state.updateTasks(update);
 		for (const [id, event, data] of events) await this.reportEvent(id, event, data).catch((error) => {
-			this.vitest.state.catchError(serializeError(error), "Unhandled Reporter Error");
+			this.vitest.state.catchError(serializeError$1(error), "Unhandled Reporter Error");
 		});
 		// TODO: what is the order or reports here?
 		// "onTaskUpdate" in parallel with others or before all or after all?
@@ -8874,30 +8874,32 @@ class TestRun {
 		await this.vitest.report("onTaskUpdate", update, events);
 	}
 	async end(specifications, errors, coverage) {
+		if (coverage) await this.vitest.report("onCoverage", coverage);
 		// specification won't have the File task if they were filtered by the --shard command
-		const modules = specifications.map((spec) => spec.testModule).filter((s) => s != null);
-		const files = modules.map((m) => m.task);
-		const state = this.vitest.isCancelling ? "interrupted" : this.hasFailed(modules) ? "failed" : "passed";
+		const modules = specifications.map((spec) => spec.testModule).filter((s) => s != null), state = this.vitest.isCancelling ? "interrupted" : this.hasFailed(modules) ? "failed" : "passed";
 		if (state !== "passed") process.exitCode = 1;
-		try {
-			await Promise.all([this.vitest.report("onTestRunEnd", modules, [...errors], state), this.vitest.report("onFinished", files, errors, coverage)]);
-		} finally {
-			if (coverage) await this.vitest.report("onCoverage", coverage);
-		}
+		await this.vitest.report("onTestRunEnd", modules, [...errors], state);
 	}
 	hasFailed(modules) {
-		if (!modules.length) return !this.vitest.config.passWithNoTests;
-		return modules.some((m) => !m.ok());
+		return modules.length ? modules.some((m) => !m.ok()) : !this.vitest.config.passWithNoTests;
+	}
+	syncUpdateStacks(update) {
+		update.forEach(([taskId, result]) => {
+			const task = this.vitest.state.idMap.get(taskId), isBrowser = task && task.file.pool === "browser";
+			result?.errors?.forEach((error) => {
+				if (isPrimitive(error)) return;
+				const project = this.vitest.getProjectByName(task.file.projectName || "");
+				if (isBrowser) error.stacks = project.browser?.parseErrorStacktrace(error, { frameFilter: project.config.onStackTrace }) || [];
+				else error.stacks = parseErrorStacktrace(error, { frameFilter: project.config.onStackTrace });
+			});
+		});
 	}
 	async reportEvent(id, event, data) {
-		const task = this.vitest.state.idMap.get(id);
-		const entity = task && this.vitest.state.getReportedEntity(task);
-		assert$1(task && entity, `Entity must be found for task ${task?.name || id}`);
-		if (event === "suite-prepare" && entity.type === "suite") return await this.vitest.report("onTestSuiteReady", entity);
+		const task = this.vitest.state.idMap.get(id), entity = task && this.vitest.state.getReportedEntity(task);
+		if (assert$1(task && entity, `Entity must be found for task ${task?.name || id}`), event === "suite-prepare" && entity.type === "suite") return await this.vitest.report("onTestSuiteReady", entity);
 		if (event === "suite-prepare" && entity.type === "module") return await this.vitest.report("onTestModuleStart", entity);
 		if (event === "suite-finished") {
-			assert$1(entity.type === "suite" || entity.type === "module", "Entity type must be suite or module");
-			if (entity.state() === "skipped")
+			if (assert$1(entity.type === "suite" || entity.type === "module", "Entity type must be suite or module"), entity.state() === "skipped")
  // everything inside suite or a module is skipped,
 			// so we won't get any children events
 			// we need to report everything manually
@@ -8909,8 +8911,7 @@ class TestRun {
 		if (event === "test-prepare" && entity.type === "test") return await this.vitest.report("onTestCaseReady", entity);
 		if (event === "test-finished" && entity.type === "test") return await this.vitest.report("onTestCaseResult", entity);
 		if (event.startsWith("before-hook") || event.startsWith("after-hook")) {
-			const isBefore = event.startsWith("before-hook");
-			const hook = entity.type === "test" ? {
+			const isBefore = event.startsWith("before-hook"), hook = entity.type === "test" ? {
 				name: isBefore ? "beforeEach" : "afterEach",
 				entity
 			} : {
@@ -8922,37 +8923,25 @@ class TestRun {
 			// this can only happen in --merge-reports, and annotation is already resolved
 			if (event === "test-annotation") {
 				const annotation = data?.annotation;
-				assert$1(annotation && entity.type === "test");
-				await this.vitest.report("onTestCaseAnnotate", entity, annotation);
+				assert$1(annotation && entity.type === "test"), await this.vitest.report("onTestCaseAnnotate", entity, annotation);
 			}
 		}
 	}
 	async resolveTestAttachment(test, annotation) {
-		const project = test.project;
-		const attachment = annotation.attachment;
+		const project = test.project, attachment = annotation.attachment;
 		if (!attachment) return attachment;
 		const path = attachment.path;
 		if (path && !path.startsWith("http://") && !path.startsWith("https://")) {
-			const currentPath = resolve(project.config.root, path);
-			const hash = createHash("sha1").update(currentPath).digest("hex");
-			const newPath = resolve(project.config.attachmentsDir, `${sanitizeFilePath(annotation.message)}-${hash}${extname(currentPath)}`);
-			await mkdir(dirname(newPath), { recursive: true });
-			await copyFile(currentPath, newPath);
-			attachment.path = newPath;
+			const currentPath = resolve(project.config.root, path), hash = createHash("sha1").update(currentPath).digest("hex"), newPath = resolve(project.config.attachmentsDir, `${sanitizeFilePath(annotation.message)}-${hash}${extname(currentPath)}`);
+			await mkdir(dirname(newPath), { recursive: true }), await copyFile(currentPath, newPath), attachment.path = newPath;
 			const contentType = attachment.contentType ?? mime.getType(basename(currentPath));
 			attachment.contentType = contentType || void 0;
 		}
 		return attachment;
 	}
 	async reportChildren(children) {
-		for (const child of children) if (child.type === "test") {
-			await this.vitest.report("onTestCaseReady", child);
-			await this.vitest.report("onTestCaseResult", child);
-		} else {
-			await this.vitest.report("onTestSuiteReady", child);
-			await this.reportChildren(child.children);
-			await this.vitest.report("onTestSuiteResult", child);
-		}
+		for (const child of children) if (child.type === "test") await this.vitest.report("onTestCaseReady", child), await this.vitest.report("onTestCaseResult", child);
+		else await this.vitest.report("onTestSuiteReady", child), await this.reportChildren(child.children), await this.vitest.report("onTestSuiteResult", child);
 	}
 }
 function sanitizeFilePath(s) {
@@ -8980,23 +8969,15 @@ class VitestWatcher {
 	* @internal
 	*/
 	onWatcherRerun(cb) {
-		this._onRerun.push(cb);
-		return this;
+		return this._onRerun.push(cb), this;
 	}
 	unregisterWatcher = noop;
 	registerWatcher() {
 		const watcher = this.vitest.vite.watcher;
 		if (this.vitest.config.forceRerunTriggers.length) watcher.add(this.vitest.config.forceRerunTriggers);
-		watcher.on("change", this.onChange);
-		watcher.on("unlink", this.onUnlink);
-		watcher.on("add", this.onAdd);
-		this.unregisterWatcher = () => {
-			watcher.off("change", this.onChange);
-			watcher.off("unlink", this.onUnlink);
-			watcher.off("add", this.onAdd);
-			this.unregisterWatcher = noop;
-		};
-		return this;
+		return watcher.on("change", this.onFileChange), watcher.on("unlink", this.onFileDelete), watcher.on("add", this.onFileCreate), this.unregisterWatcher = () => {
+			watcher.off("change", this.onFileChange), watcher.off("unlink", this.onFileDelete), watcher.off("add", this.onFileCreate), this.unregisterWatcher = noop;
+		}, this;
 	}
 	scheduleRerun(file) {
 		this._onRerun.forEach((cb) => cb(file));
@@ -9004,25 +8985,17 @@ class VitestWatcher {
 	getTestFilesFromWatcherTrigger(id) {
 		if (!this.vitest.config.watchTriggerPatterns) return false;
 		let triggered = false;
-		this.vitest.config.watchTriggerPatterns.forEach((definition) => {
+		return this.vitest.config.watchTriggerPatterns.forEach((definition) => {
 			const exec = definition.pattern.exec(id);
 			if (exec) {
 				const files = definition.testsToRun(id, exec);
-				if (Array.isArray(files)) {
-					triggered = true;
-					files.forEach((file) => this.changedTests.add(resolve(this.vitest.config.root, file)));
-				} else if (typeof files === "string") {
-					triggered = true;
-					this.changedTests.add(resolve(this.vitest.config.root, files));
-				}
+				if (Array.isArray(files)) triggered = true, files.forEach((file) => this.changedTests.add(resolve(this.vitest.config.root, file)));
+				else if (typeof files === "string") triggered = true, this.changedTests.add(resolve(this.vitest.config.root, files));
 			}
-		});
-		return triggered;
+		}), triggered;
 	}
-	onChange = (id) => {
-		id = slash(id);
-		this.vitest.logger.clearHighlightCache(id);
-		this.vitest.invalidateFile(id);
+	onFileChange = (id) => {
+		id = slash(id), this.vitest.logger.clearHighlightCache(id), this.vitest.invalidateFile(id);
 		const testFiles = this.getTestFilesFromWatcherTrigger(id);
 		if (testFiles) this.scheduleRerun(id);
 		else {
@@ -9030,22 +9003,11 @@ class VitestWatcher {
 			if (needsRerun) this.scheduleRerun(id);
 		}
 	};
-	onUnlink = (id) => {
-		id = slash(id);
-		this.vitest.logger.clearHighlightCache(id);
-		this.invalidates.add(id);
-		if (this.vitest.state.filesMap.has(id)) {
-			this.vitest.projects.forEach((project) => project._removeCachedTestFile(id));
-			this.vitest.state.filesMap.delete(id);
-			this.vitest.cache.results.removeFromCache(id);
-			this.vitest.cache.stats.removeStats(id);
-			this.changedTests.delete(id);
-			this.vitest.report("onTestRemoved", id);
-		}
+	onFileDelete = (id) => {
+		if (id = slash(id), this.vitest.logger.clearHighlightCache(id), this.invalidates.add(id), this.vitest.state.filesMap.has(id)) this.vitest.projects.forEach((project) => project._removeCachedTestFile(id)), this.vitest.state.filesMap.delete(id), this.vitest.cache.results.removeFromCache(id), this.vitest.cache.stats.removeStats(id), this.changedTests.delete(id), this.vitest.report("onTestRemoved", id);
 	};
-	onAdd = (id) => {
-		id = slash(id);
-		this.vitest.invalidateFile(id);
+	onFileCreate = (id) => {
+		id = slash(id), this.vitest.invalidateFile(id);
 		const testFiles = this.getTestFilesFromWatcherTrigger(id);
 		if (testFiles) {
 			this.scheduleRerun(id);
@@ -9053,13 +9015,10 @@ class VitestWatcher {
 		}
 		let fileContent;
 		const matchingProjects = [];
-		this.vitest.projects.forEach((project) => {
+		if (this.vitest.projects.forEach((project) => {
 			if (project.matchesTestGlob(id, () => fileContent ??= readFileSync(id, "utf-8"))) matchingProjects.push(project);
-		});
-		if (matchingProjects.length > 0) {
-			this.changedTests.add(id);
-			this.scheduleRerun(id);
-		} else {
+		}), matchingProjects.length > 0) this.changedTests.add(id), this.scheduleRerun(id);
+		else {
 			// it's possible that file was already there but watcher triggered "add" event instead
 			const needsRerun = this.handleFileChanged(id);
 			if (needsRerun) this.scheduleRerun(id);
@@ -9067,51 +9026,33 @@ class VitestWatcher {
 	};
 	handleSetupFile(filepath) {
 		let isSetupFile = false;
-		this.vitest.projects.forEach((project) => {
-			if (!project.config.setupFiles.includes(filepath)) return;
-			this.vitest.state.filesMap.forEach((files) => {
+		return this.vitest.projects.forEach((project) => {
+			project.config.setupFiles.includes(filepath) && this.vitest.state.filesMap.forEach((files) => {
 				files.forEach((file) => {
-					if (file.projectName === project.name) {
-						isSetupFile = true;
-						this.changedTests.add(file.filepath);
-					}
+					if (file.projectName === project.name) isSetupFile = true, this.changedTests.add(file.filepath);
 				});
 			});
-		});
-		return isSetupFile;
+		}), isSetupFile;
 	}
 	/**
 	* @returns A value indicating whether rerun is needed (changedTests was mutated)
 	*/
 	handleFileChanged(filepath) {
 		if (this.changedTests.has(filepath) || this.invalidates.has(filepath)) return false;
-		if (pm.isMatch(filepath, this.vitest.config.forceRerunTriggers)) {
-			this.vitest.state.getFilepaths().forEach((file) => this.changedTests.add(file));
-			return true;
-		}
+		if (pm.isMatch(filepath, this.vitest.config.forceRerunTriggers)) return this.vitest.state.getFilepaths().forEach((file) => this.changedTests.add(file)), true;
 		if (this.handleSetupFile(filepath)) return true;
 		const projects = this.vitest.projects.filter((project) => {
 			const moduleGraph = project.browser?.vite.moduleGraph || project.vite.moduleGraph;
 			return moduleGraph.getModulesByFile(filepath)?.size;
 		});
-		if (!projects.length) {
-			// if there are no modules it's possible that server was restarted
-			// we don't have information about importers anymore, so let's check if the file is a test file at least
-			if (this.vitest.state.filesMap.has(filepath) || this.vitest.projects.some((project) => project._isCachedTestFile(filepath))) {
-				this.changedTests.add(filepath);
-				return true;
-			}
-			return false;
-		}
+		if (!projects.length) return this.vitest.state.filesMap.has(filepath) || this.vitest.projects.some((project) => project._isCachedTestFile(filepath)) ? (this.changedTests.add(filepath), true) : false;
 		const files = [];
 		for (const project of projects) {
 			const mods = project.browser?.vite.moduleGraph.getModulesByFile(filepath) || project.vite.moduleGraph.getModulesByFile(filepath);
 			if (!mods || !mods.size) continue;
-			this.invalidates.add(filepath);
 			// one of test files that we already run, or one of test files that we can run
-			if (this.vitest.state.filesMap.has(filepath) || project._isCachedTestFile(filepath)) {
-				this.changedTests.add(filepath);
-				files.push(filepath);
+			if (this.invalidates.add(filepath), this.vitest.state.filesMap.has(filepath) || project._isCachedTestFile(filepath)) {
+				this.changedTests.add(filepath), files.push(filepath);
 				continue;
 			}
 			let rerun = false;
@@ -9158,43 +9099,38 @@ class Vitest {
 	* If projects were filtered with `--project` flag, they won't appear here.
 	*/
 	projects = [];
+	/**
+	* A watcher handler. This is not the file system watcher. The handler only
+	* exposes methods to handle changed files.
+	*
+	* If you have your own watcher, you can use these methods to replicate
+	* Vitest behaviour.
+	*/
+	watcher;
 	/** @internal */ configOverride = {};
-	/** @internal */ coverageProvider;
 	/** @internal */ filenamePattern;
 	/** @internal */ runningPromise;
 	/** @internal */ closingPromise;
 	/** @internal */ isCancelling = false;
 	/** @internal */ coreWorkspaceProject;
-	/**
-	* @internal
-	* @deprecated
-	*/
-	resolvedProjects = [];
-	/** @internal */ _browserLastPort = defaultBrowserPort;
 	/** @internal */ _browserSessions = new BrowserSessions();
 	/** @internal */ _cliOptions = {};
 	/** @internal */ reporters = [];
-	/** @internal */ vitenode = void 0;
-	/** @internal */ runner = void 0;
+	/** @internal */ runner;
 	/** @internal */ _testRun = void 0;
+	/** @internal */ _resolver;
 	isFirstRun = true;
 	restartsCount = 0;
 	specifications;
-	watcher;
 	pool;
 	_config;
 	_vite;
 	_state;
 	_cache;
 	_snapshot;
-	_workspaceConfigPath;
+	_coverageProvider;
 	constructor(mode, cliOptions, options = {}) {
-		this.mode = mode;
-		this._cliOptions = cliOptions;
-		this.logger = new Logger(this, options.stdout, options.stderr);
-		this.packageInstaller = options.packageInstaller || new VitestPackageInstaller();
-		this.specifications = new VitestSpecifications(this);
-		this.watcher = new VitestWatcher(this).onWatcherRerun((file) => this.scheduleRerun([file]));
+		this.mode = mode, this._cliOptions = cliOptions, this.logger = new Logger(this, options.stdout, options.stderr), this.packageInstaller = options.packageInstaller || new VitestPackageInstaller(), this.specifications = new VitestSpecifications(this), this.watcher = new VitestWatcher(this).onWatcherRerun((file) => this.scheduleRerun(file));
 	}
 	_onRestartListeners = [];
 	_onClose = [];
@@ -9202,114 +9138,54 @@ class Vitest {
 	_onCancelListeners = [];
 	_onUserTestsRerun = [];
 	_onFilterWatchedSpecification = [];
-	/** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
-	get invalidates() {
-		return this.watcher.invalidates;
-	}
-	/** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
-	get changedTests() {
-		return this.watcher.changedTests;
-	}
 	/**
 	* The global config.
 	*/
 	get config() {
-		assert(this._config, "config");
-		return this._config;
-	}
-	/** @deprecated use `vitest.vite` instead */
-	get server() {
-		return this._vite;
+		return assert(this._config, "config"), this._config;
 	}
 	/**
 	* Global Vite's dev server instance.
 	*/
 	get vite() {
-		assert(this._vite, "vite", "server");
-		return this._vite;
+		return assert(this._vite, "vite", "server"), this._vite;
 	}
 	/**
 	* The global test state manager.
 	* @experimental The State API is experimental and not subject to semver.
 	*/
 	get state() {
-		assert(this._state, "state");
-		return this._state;
+		return assert(this._state, "state"), this._state;
 	}
 	/**
 	* The global snapshot manager. You can access the current state on `snapshot.summary`.
 	*/
 	get snapshot() {
-		assert(this._snapshot, "snapshot", "snapshot manager");
-		return this._snapshot;
+		return assert(this._snapshot, "snapshot", "snapshot manager"), this._snapshot;
 	}
 	/**
 	* Test results and test file stats cache. Primarily used by the sequencer to sort tests.
 	*/
 	get cache() {
-		assert(this._cache, "cache");
-		return this._cache;
-	}
-	/** @deprecated internal */
-	setServer(options, server) {
-		return this._setServer(options, server);
+		return assert(this._cache, "cache"), this._cache;
 	}
 	/** @internal */
 	async _setServer(options, server) {
-		this.watcher.unregisterWatcher();
-		clearTimeout(this._rerunTimer);
-		this.restartsCount += 1;
-		this._browserLastPort = defaultBrowserPort;
-		this.pool?.close?.();
-		this.pool = void 0;
-		this.closingPromise = void 0;
-		this.projects = [];
-		this.resolvedProjects = [];
-		this._workspaceConfigPath = void 0;
-		this.coverageProvider = void 0;
-		this.runningPromise = void 0;
-		this.coreWorkspaceProject = void 0;
-		this.specifications.clearCache();
-		this._onUserTestsRerun = [];
-		this._vite = server;
+		this.watcher.unregisterWatcher(), clearTimeout(this._rerunTimer), this.restartsCount += 1, this.pool?.close?.(), this.pool = void 0, this.closingPromise = void 0, this.projects = [], this.runningPromise = void 0, this.coreWorkspaceProject = void 0, this.specifications.clearCache(), this._coverageProvider = void 0, this._onUserTestsRerun = [], this._vite = server;
 		const resolved = resolveConfig(this, options, server.config);
-		this._config = resolved;
-		this._state = new StateManager();
-		this._cache = new VitestCache(this.version);
-		this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
-		this._testRun = new TestRun(this);
-		if (this.config.watch) this.watcher.registerWatcher();
-		this.vitenode = new ViteNodeServer(server, this.config.server);
-		const node = this.vitenode;
-		this.runner = new ViteNodeRunner({
-			root: server.config.root,
-			base: server.config.base,
-			fetchModule(id) {
-				return node.fetchModule(id);
-			},
-			resolveId(id, importer) {
-				return node.resolveId(id, importer);
-			}
-		});
-		if (this.config.watch) {
+		if (this._config = resolved, this._state = new StateManager({ onUnhandledError: resolved.onUnhandledError }), this._cache = new VitestCache(this.version), this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions }), this._testRun = new TestRun(this), this.config.watch) this.watcher.registerWatcher();
+		this._resolver = new VitestResolver(server.config.cacheDir, resolved);
+		const environment = server.environments.__vitest__;
+		if (this.runner = new ServerModuleRunner(environment, this._resolver, resolved), this.config.watch) {
 			// hijack server restart
 			const serverRestart = server.restart;
-			server.restart = async (...args) => {
-				await Promise.all(this._onRestartListeners.map((fn) => fn()));
-				this.report("onServerRestart");
-				await this.close();
-				await serverRestart(...args);
-			};
 			// since we set `server.hmr: false`, Vite does not auto restart itself
-			server.watcher.on("change", async (file) => {
+			server.restart = async (...args) => {
+				await Promise.all(this._onRestartListeners.map((fn) => fn())), this.report("onServerRestart"), await this.close(), await serverRestart(...args);
+			}, server.watcher.on("change", async (file) => {
 				file = normalize(file);
-				const isConfig = file === server.config.configFile || this.projects.some((p) => p.vite.config.configFile === file) || file === this._workspaceConfigPath;
-				if (isConfig) {
-					await Promise.all(this._onRestartListeners.map((fn) => fn("config")));
-					this.report("onServerRestart", "config");
-					await this.close();
-					await serverRestart();
-				}
+				const isConfig = file === server.config.configFile || this.projects.some((p) => p.vite.config.configFile === file);
+				if (isConfig) await Promise.all(this._onRestartListeners.map((fn) => fn("config"))), this.report("onServerRestart", "config"), await this.close(), await serverRestart();
 			});
 		}
 		this.cache.results.setConfig(resolved.root, resolved.cache);
@@ -9317,29 +9193,44 @@ class Vitest {
 			await this.cache.results.readFromCache();
 		} catch {}
 		const projects = await this.resolveProjects(this._cliOptions);
-		this.resolvedProjects = projects;
-		this.projects = projects;
-		await Promise.all(projects.flatMap((project) => {
+		if (this.projects = projects, await Promise.all(projects.flatMap((project) => {
 			const hooks = project.vite.config.getSortedPluginHooks("configureVitest");
 			return hooks.map((hook) => hook({
 				project,
 				vitest: this,
 				injectTestProjects: this.injectTestProject
 			}));
-		}));
-		if (this._cliOptions.browser?.enabled) {
+		})), this._cliOptions.browser?.enabled) {
 			const browserProjects = this.projects.filter((p) => p.config.browser.enabled);
 			if (!browserProjects.length) throw new Error(`Vitest received --browser flag, but no project had a browser configuration.`);
 		}
 		if (!this.projects.length) {
 			const filter = toArray(resolved.project).join("\", \"");
-			if (filter) throw new Error(`No projects matched the filter "${filter}".`);
-			else throw new Error(`Vitest wasn't able to resolve any project.`);
+			throw filter ? new Error(`No projects matched the filter "${filter}".`) : new Error(`Vitest wasn't able to resolve any project.`);
 		}
 		if (!this.coreWorkspaceProject) this.coreWorkspaceProject = TestProject._createBasicProject(this);
 		if (this.config.testNamePattern) this.configOverride.testNamePattern = this.config.testNamePattern;
-		this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this);
-		await Promise.all(this._onSetServer.map((fn) => fn()));
+		this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this), await Promise.all(this._onSetServer.map((fn) => fn()));
+	}
+	/** @internal */
+	get coverageProvider() {
+		return this.configOverride.coverage?.enabled === false ? null : this._coverageProvider;
+	}
+	async enableCoverage() {
+		this.configOverride.coverage = {}, this.configOverride.coverage.enabled = true, await this.createCoverageProvider(), await this.coverageProvider?.onEnabled?.();
+	}
+	disableCoverage() {
+		this.configOverride.coverage ??= {}, this.configOverride.coverage.enabled = false;
+	}
+	_coverageOverrideCache = /* @__PURE__ */ new WeakMap();
+	/** @internal */
+	get _coverageOptions() {
+		if (!this.configOverride.coverage) return this.config.coverage;
+		if (!this._coverageOverrideCache.has(this.configOverride.coverage)) {
+			const coverage = deepClone(this.config.coverage), options = deepMerge(coverage, this.configOverride.coverage);
+			this._coverageOverrideCache.set(this.configOverride.coverage, options);
+		}
+		return this._coverageOverrideCache.get(this.configOverride.coverage);
 	}
 	/**
 	* Inject new test projects into the workspace.
@@ -9347,10 +9238,8 @@ class Vitest {
 	* @returns An array of new test projects. Can be empty if the name was filtered out.
 	*/
 	injectTestProject = async (config) => {
-		const currentNames = new Set(this.projects.map((p) => p.name));
-		const projects = await resolveProjects(this, this._cliOptions, void 0, Array.isArray(config) ? config : [config], currentNames);
-		this.projects.push(...projects);
-		return projects;
+		const currentNames = new Set(this.projects.map((p) => p.name)), projects = await resolveProjects(this, this._cliOptions, void 0, Array.isArray(config) ? config : [config], currentNames);
+		return this.projects.push(...projects), projects;
 	};
 	/**
 	* Provide a value to the test context. This value will be available to all tests with `inject`.
@@ -9366,13 +9255,7 @@ class Vitest {
 	}
 	/** @internal */
 	_ensureRootProject() {
-		if (this.coreWorkspaceProject) return this.coreWorkspaceProject;
-		this.coreWorkspaceProject = TestProject._createBasicProject(this);
-		return this.coreWorkspaceProject;
-	}
-	/** @deprecated use `getRootProject` instead */
-	getCoreWorkspaceProject() {
-		return this.getRootProject();
+		return this.coreWorkspaceProject ||= TestProject._createBasicProject(this), this.coreWorkspaceProject;
 	}
 	/**
 	* Return project that has the root (or "global") config.
@@ -9381,14 +9264,6 @@ class Vitest {
 		if (!this.coreWorkspaceProject) throw new Error(`Root project is not initialized. This means that the Vite server was not established yet and the the workspace config is not resolved.`);
 		return this.coreWorkspaceProject;
 	}
-	/**
-	* @deprecated use Reported Task API instead
-	*/
-	getProjectByTaskId(taskId) {
-		const task = this.state.idMap.get(taskId);
-		const projectName = task.projectName || task?.file?.projectName || "";
-		return this.getProjectByName(projectName);
-	}
 	getProjectByName(name) {
 		const project = this.projects.find((p) => p.name === name) || this.coreWorkspaceProject || this.projects[0];
 		if (!project) throw new Error(`Project "${name}" was not found.`);
@@ -9399,43 +9274,25 @@ class Vitest {
 	* @param moduleId The ID of the module in Vite module graph
 	*/
 	import(moduleId) {
-		return this.runner.executeId(moduleId);
-	}
-	async resolveWorkspaceConfigPath() {
-		if (typeof this.config.workspace === "string") return this.config.workspace;
-		const configDir = this.vite.config.configFile ? dirname(this.vite.config.configFile) : this.config.root;
-		const rootFiles = await promises.readdir(configDir);
-		const workspaceConfigName = workspacesFiles.find((configFile) => {
-			return rootFiles.includes(configFile);
-		});
-		if (!workspaceConfigName) return void 0;
-		return join(configDir, workspaceConfigName);
+		return this.runner.import(moduleId);
+	}
+	/**
+	* Creates a coverage provider if `coverage` is enabled in the config.
+	*/
+	async createCoverageProvider() {
+		if (this._coverageProvider) return this._coverageProvider;
+		const coverageProvider = await this.initCoverageProvider();
+		if (coverageProvider) await coverageProvider.clean(this._coverageOptions.clean);
+		return coverageProvider || null;
 	}
 	async resolveProjects(cliOptions) {
 		const names = /* @__PURE__ */ new Set();
-		if (this.config.projects) {
-			if (typeof this.config.workspace !== "undefined") this.logger.warn("Both `test.projects` and `test.workspace` are defined. Ignoring the `test.workspace` option.");
-			return resolveProjects(this, cliOptions, void 0, this.config.projects, names);
-		}
-		if (Array.isArray(this.config.workspace)) {
-			this.logger.deprecate("The `test.workspace` option is deprecated and will be removed in the next major. To hide this warning, rename `test.workspace` option to `test.projects`.");
-			return resolveProjects(this, cliOptions, void 0, this.config.workspace, names);
-		}
-		const workspaceConfigPath = await this.resolveWorkspaceConfigPath();
-		this._workspaceConfigPath = workspaceConfigPath;
-		// user doesn't have a workspace config, return default project
-		if (!workspaceConfigPath) {
-			// user can filter projects with --project flag, `getDefaultTestProject`
-			// returns the project only if it matches the filter
-			const project = getDefaultTestProject(this);
-			if (!project) return [];
-			return resolveBrowserProjects(this, new Set([project.name]), [project]);
-		}
-		const configFile = this.vite.config.configFile ? resolve(this.vite.config.root, this.vite.config.configFile) : "the root config file";
-		this.logger.deprecate(`The workspace file is deprecated and will be removed in the next major. Please, use the \`test.projects\` field in ${configFile} instead.`);
-		const workspaceModule = await this.import(workspaceConfigPath);
-		if (!workspaceModule.default || !Array.isArray(workspaceModule.default)) throw new TypeError(`Workspace config file "${workspaceConfigPath}" must export a default array of project paths.`);
-		return resolveProjects(this, cliOptions, workspaceConfigPath, workspaceModule.default, names);
+		if (this.config.projects) return resolveProjects(this, cliOptions, void 0, this.config.projects, names);
+		if ("workspace" in this.config) throw new Error("The `test.workspace` option was removed in Vitest 4. Please, migrate to `test.projects` instead. See https://vitest.dev/guide/projects for examples.");
+		// user can filter projects with --project flag, `getDefaultTestProject`
+		// returns the project only if it matches the filter
+		const project = getDefaultTestProject(this);
+		return project ? resolveBrowserProjects(this, new Set([project.name]), [project]) : [];
 	}
 	/**
 	* Glob test files in every project and create a TestSpecification for each file and pool.
@@ -9445,13 +9302,10 @@ class Vitest {
 		return this.specifications.globTestSpecifications(filters);
 	}
 	async initCoverageProvider() {
-		if (this.coverageProvider !== void 0) return;
-		this.coverageProvider = await getCoverageProvider(this.config.coverage, this.runner);
-		if (this.coverageProvider) {
-			await this.coverageProvider.initialize(this);
-			this.config.coverage = this.coverageProvider.resolveOptions();
-		}
-		return this.coverageProvider;
+		if (this._coverageProvider != null) return;
+		const coverageConfig = this.configOverride.coverage ? this.getRootProject().serializedConfig.coverage : this.config.coverage;
+		if (this._coverageProvider = await getCoverageProvider(coverageConfig, this.runner), this._coverageProvider) await this._coverageProvider.initialize(this), this.config.coverage = this._coverageProvider.resolveOptions();
+		return this._coverageProvider;
 	}
 	/**
 	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
@@ -9464,23 +9318,15 @@ class Vitest {
 			errors,
 			coverages,
 			executionTimes
-		};
-		await this.report("onInit", this);
-		await this.report("onPathsCollected", files.flatMap((f) => f.filepath));
+		}, await this.report("onInit", this);
 		const specifications = [];
 		for (const file of files) {
-			const project = this.getProjectByName(file.projectName || "");
-			const specification = project.createSpecification(file.filepath, void 0, file.pool);
+			const project = this.getProjectByName(file.projectName || ""), specification = project.createSpecification(file.filepath, void 0, file.pool);
 			specifications.push(specification);
 		}
-		await this.report("onSpecsCollected", specifications.map((spec) => spec.toJSON()));
 		await this._testRun.start(specifications).catch(noop);
 		for (const file of files) await this._reportFileTask(file);
-		this._checkUnhandledErrors(errors);
-		await this._testRun.end(specifications, errors).catch(noop);
-		await this.initCoverageProvider();
-		await this.coverageProvider?.mergeReports?.(coverages);
-		return {
+		return this._checkUnhandledErrors(errors), await this._testRun.end(specifications, errors).catch(noop), await this.initCoverageProvider(), await this.coverageProvider?.mergeReports?.(coverages), {
 			testModules: this.state.getTestModules(),
 			unhandledErrors: this.state.getUnhandledErrors()
 		};
@@ -9488,10 +9334,8 @@ class Vitest {
 	/** @internal */
 	async _reportFileTask(file) {
 		const project = this.getProjectByName(file.projectName || "");
-		await this._testRun.enqueued(project, file).catch(noop);
-		await this._testRun.collected(project, [file]).catch(noop);
-		const logs = [];
-		const { packs, events } = convertTasksToEvents(file, (task) => {
+		await this._testRun.enqueued(project, file).catch(noop), await this._testRun.collected(project, [file]).catch(noop);
+		const logs = [], { packs, events } = convertTasksToEvents(file, (task) => {
 			if (task.logs) logs.push(...task.logs);
 		});
 		logs.sort((log1, log2) => log1.time - log2.time);
@@ -9500,16 +9344,10 @@ class Vitest {
 	}
 	async collect(filters) {
 		const files = await this.specifications.getRelevantTestSpecifications(filters);
-		// if run with --changed, don't exit if no tests are found
-		if (!files.length) return {
+		return files.length ? this.collectTests(files) : {
 			testModules: [],
 			unhandledErrors: []
 		};
-		return this.collectTests(files);
-	}
-	/** @deprecated use `getRelevantTestSpecifications` instead */
-	listFiles(filters) {
-		return this.getRelevantTestSpecifications(filters);
 	}
 	/**
 	* Returns the list of test files that match the config and filters.
@@ -9528,8 +9366,7 @@ class Vitest {
 	*/
 	async start(filters) {
 		try {
-			await this.initCoverageProvider();
-			await this.coverageProvider?.clean(this.config.coverage.clean);
+			await this.initCoverageProvider(), await this.coverageProvider?.clean(this._coverageOptions.clean);
 		} finally {
 			await this.report("onInit", this);
 		}
@@ -9539,20 +9376,13 @@ class Vitest {
 		if (!files.length) {
 			await this._testRun.start([]);
 			const coverage = await this.coverageProvider?.generateCoverage?.({ allTestsRun: true });
-			await this._testRun.end([], [], coverage);
-			// Report coverage for uncovered files
-			await this.reportCoverage(coverage, true);
-			if (!this.config.watch || !(this.config.changed || this.config.related?.length)) throw new FilesNotFoundError(this.mode);
+			if (await this._testRun.end([], [], coverage), await this.reportCoverage(coverage, true), !this.config.watch || !(this.config.changed || this.config.related?.length)) throw new FilesNotFoundError(this.mode);
 		}
 		let testModules = {
 			testModules: [],
 			unhandledErrors: []
 		};
-		if (files.length) {
-			// populate once, update cache on watch
-			await this.cache.stats.populateStats(this.config.root, files);
-			testModules = await this.runFiles(files, true);
-		}
+		if (files.length) await this.cache.stats.populateStats(this.config.root, files), testModules = await this.runFiles(files, true);
 		if (this.config.watch) await this.report("onWatcherStart");
 		return testModules;
 	}
@@ -9562,24 +9392,18 @@ class Vitest {
 	*/
 	async init() {
 		try {
-			await this.initCoverageProvider();
-			await this.coverageProvider?.clean(this.config.coverage.clean);
+			await this.initCoverageProvider(), await this.coverageProvider?.clean(this._coverageOptions.clean);
 		} finally {
 			await this.report("onInit", this);
 		}
-		// populate test files cache so watch mode can trigger a file rerun
-		await this.globTestSpecifications();
-		if (this.config.watch) await this.report("onWatcherStart");
+		if (await this.globTestSpecifications(), this.config.watch) await this.report("onWatcherStart");
 	}
 	/**
-	* @deprecated remove when vscode extension supports "getModuleSpecifications"
+	* If there is a test run happening, returns a promise that will
+	* resolve when the test run is finished.
 	*/
-	getProjectsByTestFile(file) {
-		return this.getModuleSpecifications(file);
-	}
-	/** @deprecated */
-	getFileWorkspaceSpecs(file) {
-		return this.getModuleSpecifications(file);
+	async waitForTestRunEnd() {
+		this.runningPromise && await this.runningPromise;
 	}
 	/**
 	* Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
@@ -9594,7 +9418,9 @@ class Vitest {
 	* Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache altogether.
 	*/
 	clearSpecificationsCache(moduleId) {
-		this.specifications.clearCache(moduleId);
+		if (this.specifications.clearCache(moduleId), !moduleId) this.projects.forEach((project) => {
+			project.testFilesList = null;
+		});
 	}
 	/**
 	* Run tests for the given test specifications. This does not trigger `onWatcher*` events.
@@ -9602,8 +9428,7 @@ class Vitest {
 	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
 	*/
 	runTestSpecifications(specifications, allTestsRun = false) {
-		specifications.forEach((spec) => this.specifications.ensureSpecificationCached(spec));
-		return this.runFiles(specifications, allTestsRun);
+		return specifications.forEach((spec) => this.specifications.ensureSpecificationCached(spec)), this.runFiles(specifications, allTestsRun);
 	}
 	/**
 	* Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
@@ -9611,28 +9436,17 @@ class Vitest {
 	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
 	*/
 	async rerunTestSpecifications(specifications, allTestsRun = false) {
-		this.configOverride.testNamePattern = void 0;
 		const files = specifications.map((spec) => spec.moduleId);
 		await Promise.all([this.report("onWatcherRerun", files, "rerun test"), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
 		const result = await this.runTestSpecifications(specifications, allTestsRun);
-		await this.report("onWatcherStart", this.state.getFiles(files));
-		return result;
+		return await this.report("onWatcherStart", this.state.getFiles(files)), result;
 	}
 	async runFiles(specs, allTestsRun) {
-		await this._testRun.start(specs);
-		// previous run
-		await this.runningPromise;
-		this._onCancelListeners = [];
-		this.isCancelling = false;
-		// schedule the new run
-		this.runningPromise = (async () => {
+		return await this._testRun.start(specs), await this.runningPromise, this._onCancelListeners = [], this.isCancelling = false, this.runningPromise = (async () => {
 			try {
 				if (!this.pool) this.pool = createPool(this);
 				const invalidates = Array.from(this.watcher.invalidates);
-				this.watcher.invalidates.clear();
-				this.snapshot.clear();
-				this.state.clearErrors();
-				if (!this.isFirstRun && this.config.coverage.cleanOnRerun) await this.coverageProvider?.clean();
+				if (this.watcher.invalidates.clear(), this.snapshot.clear(), this.state.clearErrors(), !this.isFirstRun && this._coverageOptions.cleanOnRerun) await this.coverageProvider?.clean();
 				await this.initializeGlobalSetup(specs);
 				try {
 					await this.pool.runTests(specs, invalidates);
@@ -9649,21 +9463,24 @@ class Vitest {
 					unhandledErrors: this.state.getUnhandledErrors()
 				};
 			} finally {
-				// TODO: wait for coverage only if `onFinished` is defined
-				const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun });
-				const errors = this.state.getUnhandledErrors();
-				this._checkUnhandledErrors(errors);
-				await this._testRun.end(specs, errors, coverage);
-				await this.reportCoverage(coverage, allTestsRun);
+				const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun }), errors = this.state.getUnhandledErrors();
+				this._checkUnhandledErrors(errors), await this._testRun.end(specs, errors, coverage), await this.reportCoverage(coverage, allTestsRun);
 			}
 		})().finally(() => {
-			this.runningPromise = void 0;
-			this.isFirstRun = false;
-			// all subsequent runs will treat this as a fresh run
-			this.config.changed = false;
-			this.config.related = void 0;
+			this.runningPromise = void 0, this.isFirstRun = false, this.config.changed = false, this.config.related = void 0;
+		}), await this.runningPromise;
+	}
+	async experimental_parseSpecifications(specifications, options) {
+		if (this.mode !== "test") throw new Error(`The \`experimental_parseSpecifications\` does not support "${this.mode}" mode.`);
+		const concurrency = options?.concurrency ?? (typeof nodeos__default.availableParallelism === "function" ? nodeos__default.availableParallelism() : nodeos__default.cpus().length), limit = limitConcurrency(concurrency), promises = specifications.map((specification) => limit(() => this.experimental_parseSpecification(specification)));
+		return Promise.all(promises);
+	}
+	async experimental_parseSpecification(specification) {
+		if (this.mode !== "test") throw new Error(`The \`experimental_parseSpecification\` does not support "${this.mode}" mode.`);
+		const file = await astCollectTests(specification.project, specification.moduleId).catch((error) => {
+			return createFailedFileTask(specification.project, specification.moduleId, error);
 		});
-		return await this.runningPromise;
+		return this.state.collectFiles(specification.project, [file]), this.state.getReportedEntity(file);
 	}
 	/**
 	* Collect tests in specified modules. Vitest will run the files to collect tests.
@@ -9671,19 +9488,10 @@ class Vitest {
 	*/
 	async collectTests(specifications) {
 		const filepaths = specifications.map((spec) => spec.moduleId);
-		this.state.collectPaths(filepaths);
-		// previous run
-		await this.runningPromise;
-		this._onCancelListeners = [];
-		this.isCancelling = false;
-		// schedule the new run
-		this.runningPromise = (async () => {
+		return this.state.collectPaths(filepaths), await this.runningPromise, this._onCancelListeners = [], this.isCancelling = false, this.runningPromise = (async () => {
 			if (!this.pool) this.pool = createPool(this);
 			const invalidates = Array.from(this.watcher.invalidates);
-			this.watcher.invalidates.clear();
-			this.snapshot.clear();
-			this.state.clearErrors();
-			await this.initializeGlobalSetup(specifications);
+			this.watcher.invalidates.clear(), this.snapshot.clear(), this.state.clearErrors(), await this.initializeGlobalSetup(specifications);
 			try {
 				await this.pool.collectTests(specifications, invalidates);
 			} catch (err) {
@@ -9698,28 +9506,21 @@ class Vitest {
 				unhandledErrors: this.state.getUnhandledErrors()
 			};
 		})().finally(() => {
-			this.runningPromise = void 0;
-			// all subsequent runs will treat this as a fresh run
-			this.config.changed = false;
-			this.config.related = void 0;
-		});
-		return await this.runningPromise;
+			this.runningPromise = void 0, this.config.changed = false, this.config.related = void 0;
+		}), await this.runningPromise;
 	}
 	/**
 	* Gracefully cancel the current test run. Vitest will wait until all running tests are finished before cancelling.
 	*/
 	async cancelCurrentRun(reason) {
-		this.isCancelling = true;
-		await Promise.all(this._onCancelListeners.splice(0).map((listener) => listener(reason)));
-		await this.runningPromise;
+		this.isCancelling = true, await Promise.all(this._onCancelListeners.splice(0).map((listener) => listener(reason))), await this.runningPromise;
 	}
 	/** @internal */
 	async _initBrowserServers() {
 		await Promise.all(this.projects.map((p) => p._initBrowserServer()));
 	}
 	async initializeGlobalSetup(paths) {
-		const projects = new Set(paths.map((spec) => spec.project));
-		const coreProject = this.getRootProject();
+		const projects = new Set(paths.map((spec) => spec.project)), coreProject = this.getRootProject();
 		if (!projects.has(coreProject)) projects.add(coreProject);
 		for (const project of projects) await project._initializeGlobalSetup();
 	}
@@ -9733,8 +9534,7 @@ class Vitest {
 		const specifications = files.flatMap((file) => this.getModuleSpecifications(file));
 		await Promise.all([this.report("onWatcherRerun", files, trigger), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
 		const testResult = await this.runFiles(specifications, allTestsRun);
-		await this.report("onWatcherStart", this.state.getFiles(files));
-		return testResult;
+		return await this.report("onWatcherStart", this.state.getFiles(files)), testResult;
 	}
 	/** @internal */
 	async rerunTask(id) {
@@ -9754,9 +9554,8 @@ class Vitest {
 		// Empty test name pattern should reset filename pattern as well
 		if (pattern === "") this.filenamePattern = void 0;
 		const testNamePattern = pattern ? new RegExp(pattern) : void 0;
-		this.configOverride.testNamePattern = testNamePattern;
 		// filter only test files that have tests matching the pattern
-		if (testNamePattern) files = files.filter((filepath) => {
+		if (this.configOverride.testNamePattern = testNamePattern, testNamePattern) files = files.filter((filepath) => {
 			const files = this.state.getFiles([filepath]);
 			return !files.length || files.some((file) => {
 				const tasks = getTasks(file);
@@ -9780,9 +9579,7 @@ class Vitest {
 	* @param files The list of files on the file system
 	*/
 	async updateSnapshot(files) {
-		// default to failed files
-		files = files || [...this.state.getFailedFilepaths(), ...this.snapshot.summary.uncheckedKeysByFile.map((s) => s.filePath)];
-		this.enableSnapshotUpdate();
+		files = files || [...this.state.getFailedFilepaths(), ...this.snapshot.summary.uncheckedKeysByFile.map((s) => s.filePath)], this.enableSnapshotUpdate();
 		try {
 			return await this.rerunFiles(files, "update snapshot", false);
 		} finally {
@@ -9800,15 +9597,13 @@ class Vitest {
 		this.configOverride.snapshotOptions = {
 			updateSnapshot: "all",
 			snapshotEnvironment: null
-		};
-		this.snapshot.options.updateSnapshot = "all";
+		}, this.snapshot.options.updateSnapshot = "all";
 	}
 	/**
 	* Disable the mode that allows updating snapshots when running tests.
 	*/
 	resetSnapshotUpdate() {
-		delete this.configOverride.snapshotOptions;
-		this.snapshot.options.updateSnapshot = this.config.snapshotOptions.updateSnapshot;
+		delete this.configOverride.snapshotOptions, this.snapshot.options.updateSnapshot = this.config.snapshotOptions.updateSnapshot;
 	}
 	/**
 	* Set the global test name pattern to a regexp.
@@ -9819,74 +9614,60 @@ class Vitest {
 		else this.configOverride.testNamePattern = pattern ? new RegExp(pattern) : void 0;
 	}
 	/**
+	* Returns the regexp used for the global test name pattern.
+	*/
+	getGlobalTestNamePattern() {
+		return this.configOverride.testNamePattern == null ? this.config.testNamePattern : this.configOverride.testNamePattern;
+	}
+	/**
 	* Resets the global test name pattern. This method doesn't run any tests.
 	*/
 	resetGlobalTestNamePattern() {
 		this.configOverride.testNamePattern = void 0;
 	}
 	_rerunTimer;
-	// we can't use a single `triggerId` yet because vscode extension relies on this
 	async scheduleRerun(triggerId) {
 		const currentCount = this.restartsCount;
-		clearTimeout(this._rerunTimer);
-		await this.runningPromise;
-		clearTimeout(this._rerunTimer);
-		// server restarted
-		if (this.restartsCount !== currentCount) return;
-		this._rerunTimer = setTimeout(async () => {
+		clearTimeout(this._rerunTimer), await this.runningPromise, clearTimeout(this._rerunTimer), this.restartsCount === currentCount && (this._rerunTimer = setTimeout(async () => {
 			if (this.watcher.changedTests.size === 0) {
 				this.watcher.invalidates.clear();
 				return;
 			}
 			// server restarted
 			if (this.restartsCount !== currentCount) return;
-			this.isFirstRun = false;
-			this.snapshot.clear();
+			this.isFirstRun = false, this.snapshot.clear();
 			let files = Array.from(this.watcher.changedTests);
 			if (this.filenamePattern) {
 				const filteredFiles = await this.globTestSpecifications(this.filenamePattern);
-				files = files.filter((file) => filteredFiles.some((f) => f.moduleId === file));
 				// A file that does not match the current filename pattern was changed
-				if (files.length === 0) return;
+				if (files = files.filter((file) => filteredFiles.some((f) => f.moduleId === file)), files.length === 0) return;
 			}
 			this.watcher.changedTests.clear();
-			const triggerIds = new Set(triggerId.map((id) => relative(this.config.root, id)));
-			const triggerLabel = Array.from(triggerIds).join(", ");
-			// get file specifications and filter them if needed
-			const specifications = files.flatMap((file) => this.getModuleSpecifications(file)).filter((specification) => {
-				if (this._onFilterWatchedSpecification.length === 0) return true;
-				return this._onFilterWatchedSpecification.every((fn) => fn(specification));
+			const triggerLabel = relative(this.config.root, triggerId), specifications = files.flatMap((file) => this.getModuleSpecifications(file)).filter((specification) => {
+				return this._onFilterWatchedSpecification.length === 0 ? true : this._onFilterWatchedSpecification.every((fn) => fn(specification));
 			});
-			await Promise.all([this.report("onWatcherRerun", files, triggerLabel), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
-			await this.runFiles(specifications, false);
-			await this.report("onWatcherStart", this.state.getFiles(files));
-		}, WATCHER_DEBOUNCE);
+			await Promise.all([this.report("onWatcherRerun", files, triggerLabel), ...this._onUserTestsRerun.map((fn) => fn(specifications))]), await this.runFiles(specifications, false), await this.report("onWatcherStart", this.state.getFiles(files));
+		}, WATCHER_DEBOUNCE));
 	}
 	/**
 	* Invalidate a file in all projects.
 	*/
 	invalidateFile(filepath) {
 		this.projects.forEach(({ vite, browser }) => {
-			const serverMods = vite.moduleGraph.getModulesByFile(filepath);
-			serverMods?.forEach((mod) => vite.moduleGraph.invalidateModule(mod));
-			if (browser) {
-				const browserMods = browser.vite.moduleGraph.getModulesByFile(filepath);
-				browserMods?.forEach((mod) => browser.vite.moduleGraph.invalidateModule(mod));
-			}
+			const environments = [...Object.values(vite.environments), ...Object.values(browser?.vite.environments || {})];
+			environments.forEach(({ moduleGraph }) => {
+				const modules = moduleGraph.getModulesByFile(filepath);
+				modules?.forEach((module) => moduleGraph.invalidateModule(module));
+			});
 		});
 	}
-	/** @deprecated use `invalidateFile` */
-	updateLastChanged(filepath) {
-		this.invalidateFile(filepath);
-	}
 	/** @internal */
 	_checkUnhandledErrors(errors) {
 		if (errors.length && !this.config.dangerouslyIgnoreUnhandledErrors) process.exitCode = 1;
 	}
 	async reportCoverage(coverage, allTestsRun) {
 		if (this.state.getCountOfFailedTests() > 0) {
-			await this.coverageProvider?.onTestFailure?.();
-			if (!this.config.coverage.reportOnFailure) return;
+			if (await this.coverageProvider?.onTestFailure?.(), !this._coverageOptions.reportOnFailure) return;
 		}
 		if (this.coverageProvider) {
 			await this.coverageProvider.reportCoverage(coverage, { allTestsRun });
@@ -9909,11 +9690,9 @@ class Vitest {
 			// it's possible that it's not initialized at all because it's not running any tests
 			if (this.coreWorkspaceProject && !this.projects.includes(this.coreWorkspaceProject)) closePromises.push(this.coreWorkspaceProject.close().then(() => this._vite = void 0));
 			if (this.pool) closePromises.push((async () => {
-				await this.pool?.close?.();
-				this.pool = void 0;
+				await this.pool?.close?.(), this.pool = void 0;
 			})());
-			closePromises.push(...this._onClose.map((fn) => fn()));
-			return Promise.allSettled(closePromises).then((results) => {
+			return closePromises.push(...this._onClose.map((fn) => fn())), Promise.allSettled(closePromises).then((results) => {
 				results.forEach((r) => {
 					if (r.status === "rejected") this.logger.error("error during close", r.reason);
 				});
@@ -9926,11 +9705,9 @@ class Vitest {
 	* @param force If true, the process will exit immediately after closing the projects.
 	*/
 	async exit(force = false) {
-		setTimeout(() => {
+		if (setTimeout(() => {
 			this.report("onProcessTimeout").then(() => {
-				console.warn(`close timed out after ${this.config.teardownTimeout}ms`);
-				this.state.getProcessTimeoutCauses().forEach((cause) => console.warn(cause));
-				if (!this.pool) {
+				if (console.warn(`close timed out after ${this.config.teardownTimeout}ms`), this.state.getProcessTimeoutCauses().forEach((cause) => console.warn(cause)), !this.pool) {
 					const runningServers = [this._vite, ...this.projects.map((p) => p._vite)].filter(Boolean).length;
 					if (runningServers === 1) console.warn("Tests closed successfully but something prevents Vite server from exiting");
 					else if (runningServers > 1) console.warn(`Tests closed successfully but something prevents ${runningServers} Vite servers from exiting`);
@@ -9939,9 +9716,7 @@ class Vitest {
 				}
 				process.exit();
 			});
-		}, this.config.teardownTimeout).unref();
-		await this.close();
-		if (force) process.exit();
+		}, this.config.teardownTimeout).unref(), await this.close(), force) process.exit();
 	}
 	/** @internal */
 	async report(name, ...args) {
@@ -9956,25 +9731,6 @@ class Vitest {
 		return Array.from(new Set(specifications.map((spec) => spec.moduleId)));
 	}
 	/**
-	* @deprecated use `globTestSpecifications` instead
-	*/
-	async globTestSpecs(filters = []) {
-		return this.globTestSpecifications(filters);
-	}
-	/**
-	* @deprecated use `globTestSpecifications` instead
-	*/
-	async globTestFiles(filters = []) {
-		return this.globTestSpecifications(filters);
-	}
-	/** @deprecated filter by `this.projects` yourself */
-	getModuleProjects(filepath) {
-		return this.projects.filter((project) => {
-			return project.getModulesByFilepath(filepath).size;
-			// TODO: reevaluate || project.browser?.moduleGraph.getModulesByFile(id)?.size
-		});
-	}
-	/**
 	* Should the server be kept running after the tests are done.
 	*/
 	shouldKeepServer() {
@@ -10023,9 +9779,7 @@ class Vitest {
 	*/
 	matchesProjectFilter(name) {
 		const projects = this._config?.project || this._cliOptions?.project;
-		// no filters applied, any project can be included
-		if (!projects || !projects.length) return true;
-		return toArray(projects).some((project) => {
+		return !projects || !projects.length ? true : toArray(projects).some((project) => {
 			const regexp = wildcardPatternToRegExp(project);
 			return regexp.test(name);
 		});
@@ -10038,8 +9792,7 @@ function assert(condition, property, name = property) {
 async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(options))) {
 	const userConfig = deepMerge({}, options);
 	async function UIPlugin() {
-		await vitest.packageInstaller.ensureInstalled("@vitest/ui", options.root || process.cwd(), vitest.version);
-		return (await import('@vitest/ui')).default(vitest);
+		return await vitest.packageInstaller.ensureInstalled("@vitest/ui", options.root || process.cwd(), vitest.version), (await import('@vitest/ui')).default(vitest);
 	}
 	return [
 		{
@@ -10065,14 +9818,9 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				let open = false;
 				if (testConfig.ui && testConfig.open) open = testConfig.uiBase ?? "/__vitest__/";
 				const resolveOptions = getDefaultResolveOptions();
-				const config = {
+				let config = {
 					root: viteConfig.test?.root || options.root,
 					define: { "process.env.NODE_ENV": "process.env.NODE_ENV" },
-					esbuild: viteConfig.esbuild === false ? false : {
-						target: viteConfig.esbuild?.target || "node18",
-						sourcemap: "external",
-						legalComments: "inline"
-					},
 					resolve: {
 						...resolveOptions,
 						alias: testConfig.alias
@@ -10089,7 +9837,10 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 						outDir: "dummy-non-existing-folder",
 						emptyOutDir: false
 					},
-					environments: { ssr: { resolve: resolveOptions } },
+					environments: {
+						ssr: { resolve: resolveOptions },
+						__vitest__: { dev: {} }
+					},
 					test: {
 						poolOptions: {
 							threads: { isolate: options.poolOptions?.threads?.isolate ?? options.isolate ?? testConfig.poolOptions?.threads?.isolate ?? viteConfig.test?.isolate },
@@ -10099,33 +9850,29 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 						deps: testConfig.deps ?? viteConfig.test?.deps
 					}
 				};
+				if ("rolldownVersion" in vite) config = {
+					...config,
+					oxc: viteConfig.oxc === false ? false : { target: viteConfig.oxc?.target || "node18" }
+				};
+				else config = {
+					...config,
+					esbuild: viteConfig.esbuild === false ? false : {
+						target: viteConfig.esbuild?.target || "node18",
+						sourcemap: "external",
+						legalComments: "inline"
+					}
+				};
 				// inherit so it's available in VitestOptimizer
 				// I cannot wait to rewrite all of this in Vitest 4
 				if (options.cache != null) config.test.cache = options.cache;
 				if (vitest.configOverride.project)
  // project filter was set by the user, so we need to filter the project
 				options.project = vitest.configOverride.project;
-				config.customLogger = createViteLogger(vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false });
-				config.customLogger = silenceImportViteIgnoreWarning(config.customLogger);
-				// we want inline dependencies to be resolved by analyser plugin so module graph is populated correctly
-				if (viteConfig.ssr?.noExternal !== true) {
-					const inline = testConfig.server?.deps?.inline;
-					if (inline === true) config.ssr = { noExternal: true };
-					else {
-						const noExternal = viteConfig.ssr?.noExternal;
-						const noExternalArray = typeof noExternal !== "undefined" ? toArray(noExternal) : void 0;
-						// filter the same packages
-						const uniqueInline = inline && noExternalArray ? inline.filter((dep) => !noExternalArray.includes(dep)) : inline;
-						config.ssr = { noExternal: uniqueInline };
-					}
-				}
 				// chokidar fsevents is unstable on macos when emitting "ready" event
-				if (process.platform === "darwin" && false);
+				if (config.customLogger = createViteLogger(vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false }), config.customLogger = silenceImportViteIgnoreWarning(config.customLogger), process.platform === "darwin" && false);
 				const classNameStrategy = typeof testConfig.css !== "boolean" && testConfig.css?.modules?.classNameStrategy || "stable";
 				if (classNameStrategy !== "scoped") {
-					config.css ??= {};
-					config.css.modules ??= {};
-					if (config.css.modules) config.css.modules.generateScopedName = (name, filename) => {
+					if (config.css ??= {}, config.css.modules ??= {}, config.css.modules) config.css.modules.generateScopedName = (name, filename) => {
 						const root = vitest.config.root || options.root || process.cwd();
 						return generateScopedClassName(classNameStrategy, name, relative(root, filename));
 					};
@@ -10136,17 +9883,11 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				const viteConfigTest = viteConfig.test || {};
 				if (viteConfigTest.watch === false) viteConfigTest.run = true;
 				if ("alias" in viteConfigTest) delete viteConfigTest.alias;
-				// viteConfig.test is final now, merge it for real
-				options = deepMerge({}, configDefaults, viteConfigTest, options);
-				options.api = resolveApiServerConfig(options, defaultPort);
+				options = deepMerge({}, configDefaults, viteConfigTest, options), options.api = resolveApiServerConfig(options, defaultPort);
 				// we replace every "import.meta.env" with "process.env"
 				// to allow reassigning, so we need to put all envs on process.env
 				const { PROD, DEV,...envs } = viteConfig.env;
-				// process.env can have only string values and will cast string on it if we pass other type,
-				// so we are making them truthy
-				process.env.PROD ??= PROD ? "1" : "";
-				process.env.DEV ??= DEV ? "1" : "";
-				for (const name in envs) process.env[name] ??= envs[name];
+				for (const name in process.env.PROD ??= PROD ? "1" : "", process.env.DEV ??= DEV ? "1" : "", envs) process.env[name] ??= envs[name];
 				// don't watch files in run mode
 				if (!options.watch) viteConfig.server.watch = null;
 				if (options.ui)
@@ -10166,20 +9907,20 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				order: "post",
 				async handler(server) {
 					if (options.watch && false);
-					await vitest._setServer(options, server);
-					if (options.api && options.watch) (await Promise.resolve().then(function () { return setup$1; })).setup(vitest);
+					if (await vitest._setServer(options, server), options.api && options.watch) (await Promise.resolve().then(function () { return setup$1; })).setup(vitest);
 					// #415, in run mode we don't need the watcher, close it would improve the performance
 					if (!options.watch) await server.watcher.close();
 				}
 			}
 		},
-		SsrReplacerPlugin(),
+		MetaEnvReplacerPlugin(),
 		...CSSEnablerPlugin(vitest),
 		CoverageTransform(vitest),
 		VitestCoreResolver(vitest),
 		...MocksPlugins(),
 		VitestOptimizer(),
-		NormalizeURLPlugin()
+		NormalizeURLPlugin(),
+		ModuleRunnerTransform()
 	].filter(notNullish);
 }
 function removeUndefinedValues(obj) {
@@ -10188,25 +9929,19 @@ function removeUndefinedValues(obj) {
 }
 
 async function createVitest(mode, options, viteOverrides = {}, vitestOptions = {}) {
-	const ctx = new Vitest(mode, deepClone(options), vitestOptions);
-	const root = slash(resolve$1(options.root || process.cwd()));
-	const configPath = options.config === false ? false : options.config ? resolve$1(root, options.config) : await findUp(configFiles, { cwd: root });
+	const ctx = new Vitest(mode, deepClone(options), vitestOptions), root = slash(resolve$1(options.root || process.cwd())), configPath = options.config === false ? false : options.config ? resolve$1(root, options.config) : await findUp(configFiles, { cwd: root });
 	options.config = configPath;
-	const { browser: _removeBrowser,...restOptions } = options;
-	const config = {
+	const { browser: _removeBrowser,...restOptions } = options, config = {
 		configFile: configPath,
 		configLoader: options.configLoader,
 		mode: options.mode || mode,
 		plugins: await VitestPlugin(restOptions, ctx)
-	};
-	const server = await createViteServer(mergeConfig(config, mergeConfig(viteOverrides, { root: options.root })));
+	}, server = await createViteServer(mergeConfig(config, mergeConfig(viteOverrides, { root: options.root })));
 	if (ctx.config.api?.port) await server.listen();
 	return ctx;
 }
 
-const MAX_RESULT_COUNT = 10;
-const SELECTION_MAX_INDEX = 7;
-const ESC = "\x1B[";
+const MAX_RESULT_COUNT = 10, SELECTION_MAX_INDEX = 7, ESC = "\x1B[";
 class WatchFilter {
 	filterRL;
 	currentKeyword = void 0;
@@ -10217,23 +9952,17 @@ class WatchFilter {
 	stdin;
 	stdout;
 	constructor(message, stdin = process.stdin, stdout$1 = stdout()) {
-		this.message = message;
-		this.stdin = stdin;
-		this.stdout = stdout$1;
-		this.filterRL = readline.createInterface({
+		if (this.message = message, this.stdin = stdin, this.stdout = stdout$1, this.filterRL = readline.createInterface({
 			input: this.stdin,
 			escapeCodeTimeout: 50
-		});
-		readline.emitKeypressEvents(this.stdin, this.filterRL);
-		if (this.stdin.isTTY) this.stdin.setRawMode(true);
+		}), readline.emitKeypressEvents(this.stdin, this.filterRL), this.stdin.isTTY) this.stdin.setRawMode(true);
 	}
 	async filter(filterFunc) {
 		this.write(this.promptLine());
 		const resultPromise = createDefer();
 		this.onKeyPress = this.filterHandler(filterFunc, (result) => {
 			resultPromise.resolve(result);
-		});
-		this.stdin.on("keypress", this.onKeyPress);
+		}), this.stdin.on("keypress", this.onKeyPress);
 		try {
 			return await resultPromise;
 		} finally {
@@ -10249,13 +9978,11 @@ class WatchFilter {
 					break;
 				case key?.ctrl && key?.name === "c":
 				case key?.name === "escape":
-					this.write(`${ESC}1G${ESC}0J`);
-					onSubmit(void 0);
+					this.write(`${ESC}1G${ESC}0J`), onSubmit(void 0);
 					return;
 				case key?.name === "enter":
 				case key?.name === "return":
-					onSubmit(this.results[this.selectionIndex] || this.currentKeyword || "");
-					this.currentKeyword = void 0;
+					onSubmit(this.results[this.selectionIndex] || this.currentKeyword || ""), this.currentKeyword = void 0;
 					break;
 				case key?.name === "up":
 					if (this.selectionIndex && this.selectionIndex > 0) this.selectionIndex--;
@@ -10282,17 +10009,13 @@ class WatchFilter {
 			const resultCountLine = this.results.length === 1 ? `Pattern matches ${this.results.length} result` : `Pattern matches ${this.results.length} results`;
 			let resultBody = "";
 			if (this.results.length > MAX_RESULT_COUNT) {
-				const offset = this.selectionIndex > SELECTION_MAX_INDEX ? this.selectionIndex - SELECTION_MAX_INDEX : 0;
-				const displayResults = this.results.slice(offset, MAX_RESULT_COUNT + offset);
-				const remainingResultCount = this.results.length - offset - displayResults.length;
-				resultBody = `${displayResults.map((result, index) => index + offset === this.selectionIndex ? c.green(` › ${result}`) : c.dim(` › ${result}`)).join("\n")}`;
-				if (remainingResultCount > 0) resultBody += `
+				const offset = this.selectionIndex > SELECTION_MAX_INDEX ? this.selectionIndex - SELECTION_MAX_INDEX : 0, displayResults = this.results.slice(offset, MAX_RESULT_COUNT + offset), remainingResultCount = this.results.length - offset - displayResults.length;
+				if (resultBody = `${displayResults.map((result, index) => index + offset === this.selectionIndex ? c.green(` › ${result}`) : c.dim(` › ${result}`)).join("\n")}`, remainingResultCount > 0) resultBody += `
 ${c.dim(`   ...and ${remainingResultCount} more ${remainingResultCount === 1 ? "result" : "results"}`)}`;
 			} else resultBody = this.results.map((result, index) => index === this.selectionIndex ? c.green(` › ${result}`) : c.dim(` › ${result}`)).join("\n");
 			printStr += `\n${resultCountLine}\n${resultBody}`;
 		}
-		this.eraseAndPrint(printStr);
-		this.restoreCursor();
+		this.eraseAndPrint(printStr), this.restoreCursor();
 	}
 	keywordOffset() {
 		return `? ${this.message} › `.length + 1;
@@ -10308,14 +10031,10 @@ ${c.dim(`   ...and ${remainingResultCount} more ${remainingResultCount === 1 ? "
 			// We have to take care of screen width in case of long lines
 			rows += 1 + Math.floor(Math.max(stripVTControlCharacters(line).length - 1, 0) / columns);
 		}
-		this.write(`${ESC}1G`);
-		this.write(`${ESC}J`);
-		this.write(str);
-		this.write(`${ESC}${rows - 1}A`);
+		this.write(`${ESC}1G`), this.write(`${ESC}J`), this.write(str), this.write(`${ESC}${rows - 1}A`);
 	}
 	close() {
-		this.filterRL.close();
-		if (this.onKeyPress) this.stdin.removeListener("keypress", this.onKeyPress);
+		if (this.filterRL.close(), this.onKeyPress) this.stdin.removeListener("keypress", this.onKeyPress);
 		if (this.stdin.isTTY) this.stdin.setRawMode(false);
 	}
 	restoreCursor() {
@@ -10340,8 +10059,7 @@ const keys = [
 	["w", "filter by a project name"],
 	["b", "start the browser server if not started yet"],
 	["q", "quit"]
-];
-const cancelKeys = [
+], cancelKeys = [
 	"space",
 	"c",
 	"h",
@@ -10359,17 +10077,12 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 		// Cancel run and exit when ctrl-c or esc is pressed.
 		// If cancelling takes long and key is pressed multiple times, exit forcefully.
 		if (str === "" || str === "\x1B" || key && key.ctrl && key.name === "c") {
-			if (!ctx.isCancelling) {
-				ctx.logger.log(c.red("Cancelling test run. Press CTRL+c again to exit forcefully.\n"));
-				process.exitCode = 130;
-				await ctx.cancelCurrentRun("keyboard-input");
-			}
+			if (!ctx.isCancelling) ctx.logger.log(c.red("Cancelling test run. Press CTRL+c again to exit forcefully.\n")), process.exitCode = 130, await ctx.cancelCurrentRun("keyboard-input");
 			return ctx.exit(true);
 		}
 		// window not support suspend
 		if (!isWindows && key && key.ctrl && key.name === "z") {
-			process.kill(process.ppid, "SIGTSTP");
-			process.kill(process.pid, "SIGTSTP");
+			process.kill(process.ppid, "SIGTSTP"), process.kill(process.pid, "SIGTSTP");
 			return;
 		}
 		const name = key?.name;
@@ -10398,24 +10111,17 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 		if (name === "t") return inputNamePattern();
 		// change fileNamePattern
 		if (name === "p") return inputFilePattern();
-		if (name === "b") {
-			await ctx._initBrowserServers();
-			ctx.projects.forEach((project) => {
-				ctx.logger.log();
-				ctx.logger.printBrowserBanner(project);
-			});
-			return null;
-		}
+		if (name === "b") return await ctx._initBrowserServers(), ctx.projects.forEach((project) => {
+			ctx.logger.log(), ctx.logger.printBrowserBanner(project);
+		}), null;
 	}
 	async function keypressHandler(str, key) {
 		await _keypressHandler(str, key);
 	}
 	async function inputNamePattern() {
 		off();
-		const watchFilter = new WatchFilter("Input test name pattern (RegExp)", stdin, stdout);
-		const filter = await watchFilter.filter((str) => {
-			const files = ctx.state.getFiles();
-			const tests = getTests(files);
+		const watchFilter = new WatchFilter("Input test name pattern (RegExp)", stdin, stdout), filter = await watchFilter.filter((str) => {
+			const files = ctx.state.getFiles(), tests = getTests(files);
 			try {
 				const reg = new RegExp(str);
 				return tests.map((test) => test.name).filter((testName) => testName.match(reg));
@@ -10424,11 +10130,8 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 				return [];
 			}
 		});
-		on();
-		if (typeof filter === "undefined") return;
-		const files = ctx.state.getFilepaths();
-		// if running in standalone mode, Vitest instance doesn't know about any test file
-		const cliFiles = ctx.config.standalone && !files.length ? await ctx._globTestFilepaths() : void 0;
+		if (on(), typeof filter === "undefined") return;
+		const files = ctx.state.getFilepaths(), cliFiles = ctx.config.standalone && !files.length ? await ctx._globTestFilepaths() : void 0;
 		await ctx.changeNamePattern(filter?.trim() || "", cliFiles, "change pattern");
 	}
 	async function inputProjectName() {
@@ -10439,41 +10142,31 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 			message: "Input a single project name",
 			initial: ctx.config.project[0] || ""
 		}]);
-		on();
-		await ctx.changeProjectName(filter.trim());
+		on(), await ctx.changeProjectName(filter.trim());
 	}
 	async function inputFilePattern() {
 		off();
-		const watchFilter = new WatchFilter("Input filename pattern", stdin, stdout);
-		const filter = await watchFilter.filter(async (str) => {
-			const files = await ctx.globTestFiles([str]);
-			return files.map((file) => relative(ctx.config.root, file[1]));
+		const watchFilter = new WatchFilter("Input filename pattern", stdin, stdout), filter = await watchFilter.filter(async (str) => {
+			const specifications = await ctx.globTestSpecifications([str]);
+			return specifications.map((specification) => relative(ctx.config.root, specification.moduleId)).filter((file, index, all) => all.indexOf(file) === index);
 		});
-		on();
-		if (typeof filter === "undefined") return;
+		if (on(), typeof filter === "undefined") return;
 		latestFilename = filter?.trim() || "";
 		const lastResults = watchFilter.getLastResults();
 		await ctx.changeFilenamePattern(latestFilename, filter && lastResults.length ? lastResults.map((i) => resolve(ctx.config.root, i)) : void 0);
 	}
 	let rl;
 	function on() {
-		off();
-		rl = readline.createInterface({
+		if (off(), rl = readline.createInterface({
 			input: stdin,
 			escapeCodeTimeout: 50
-		});
-		readline.emitKeypressEvents(stdin, rl);
-		if (stdin.isTTY) stdin.setRawMode(true);
+		}), readline.emitKeypressEvents(stdin, rl), stdin.isTTY) stdin.setRawMode(true);
 		stdin.on("keypress", keypressHandler);
 	}
 	function off() {
-		rl?.close();
-		rl = void 0;
-		stdin.removeListener("keypress", keypressHandler);
-		if (stdin.isTTY) stdin.setRawMode(false);
+		if (rl?.close(), rl = void 0, stdin.removeListener("keypress", keypressHandler), stdin.isTTY) stdin.setRawMode(false);
 	}
-	on();
-	return function cleanup() {
+	return on(), function cleanup() {
 		off();
 	};
 }
@@ -10484,20 +10177,14 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 * Returns a Vitest instance if initialized successfully.
 */
 async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, vitestOptions) {
-	const root = resolve(options.root || process.cwd());
-	const ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions);
-	if (mode === "test" && ctx.config.coverage.enabled) {
-		const provider = ctx.config.coverage.provider || "v8";
-		const requiredPackages = CoverageProviderMap[provider];
+	const root = resolve(options.root || process.cwd()), ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions, cliFilters);
+	if (mode === "test" && ctx._coverageOptions.enabled) {
+		const provider = ctx._coverageOptions.provider || "v8", requiredPackages = CoverageProviderMap[provider];
 		if (requiredPackages) {
-			if (!await ctx.packageInstaller.ensureInstalled(requiredPackages, root, ctx.version)) {
-				process.exitCode = 1;
-				return ctx;
-			}
+			if (!await ctx.packageInstaller.ensureInstalled(requiredPackages, root, ctx.version)) return process.exitCode = 1, ctx;
 		}
 	}
-	const stdin = vitestOptions?.stdin || process.stdin;
-	const stdout = vitestOptions?.stdout || process.stdout;
+	const stdin = vitestOptions?.stdin || process.stdin, stdout = vitestOptions?.stdout || process.stdout;
 	let stdinCleanup;
 	if (stdin.isTTY && ctx.config.watch) stdinCleanup = registerConsoleShortcuts(ctx, stdin, stdout);
 	ctx.onAfterSetServer(() => {
@@ -10509,54 +10196,27 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
 		else if (ctx.config.standalone) await ctx.init();
 		else await ctx.start(cliFilters);
 	} catch (e) {
-		if (e instanceof FilesNotFoundError) return ctx;
-		if (e instanceof GitNotFoundError) {
-			ctx.logger.error(e.message);
-			return ctx;
-		}
-		if (e instanceof IncludeTaskLocationDisabledError || e instanceof RangeLocationFilterProvidedError || e instanceof LocationFilterFileNotFoundError) {
-			ctx.logger.printError(e, { verbose: false });
-			return ctx;
-		}
-		process.exitCode = 1;
-		ctx.logger.printError(e, {
+		return e instanceof FilesNotFoundError ? ctx : e instanceof GitNotFoundError ? (ctx.logger.error(e.message), ctx) : e instanceof IncludeTaskLocationDisabledError || e instanceof RangeLocationFilterProvidedError || e instanceof LocationFilterFileNotFoundError ? (ctx.logger.printError(e, { verbose: false }), ctx) : (process.exitCode = 1, ctx.logger.printError(e, {
 			fullStack: true,
 			type: "Unhandled Error"
-		});
-		ctx.logger.error("\n\n");
-		return ctx;
+		}), ctx.logger.error("\n\n"), ctx);
 	}
-	if (ctx.shouldKeepServer()) return ctx;
-	stdinCleanup?.();
-	await ctx.close();
-	return ctx;
+	return ctx.shouldKeepServer() ? ctx : (stdinCleanup?.(), await ctx.close(), ctx);
 }
-async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions) {
-	process.env.TEST = "true";
-	process.env.VITEST = "true";
-	process.env.NODE_ENV ??= "test";
-	if (options.run) options.watch = false;
+async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions, cliFilters) {
+	if (process.env.TEST = "true", process.env.VITEST = "true", process.env.NODE_ENV ??= "test", options.run) options.watch = false;
+	if (options.standalone && (cliFilters?.length || 0) > 0) options.standalone = false;
 	// this shouldn't affect _application root_ that can be changed inside config
-	const root = resolve(options.root || process.cwd());
-	const ctx = await createVitest(mode, options, viteOverrides, vitestOptions);
-	const environmentPackage = getEnvPackageName(ctx.config.environment);
-	if (environmentPackage && !await ctx.packageInstaller.ensureInstalled(environmentPackage, root)) {
-		process.exitCode = 1;
-		return ctx;
-	}
-	return ctx;
+	const root = resolve(options.root || process.cwd()), ctx = await createVitest(mode, options, viteOverrides, vitestOptions), environmentPackage = getEnvPackageName(ctx.config.environment);
+	return environmentPackage && !await ctx.packageInstaller.ensureInstalled(environmentPackage, root) && (process.exitCode = 1), ctx;
 }
 function processCollected(ctx, files, options) {
 	let errorsPrinted = false;
-	forEachSuite(files, (suite) => {
+	if (forEachSuite(files, (suite) => {
 		suite.errors().forEach((error) => {
-			errorsPrinted = true;
-			ctx.logger.printError(error, { project: suite.project });
+			errorsPrinted = true, ctx.logger.printError(error, { project: suite.project });
 		});
-	});
-	if (errorsPrinted) return;
-	if (typeof options.json !== "undefined") return processJsonOutput(files, options);
-	return formatCollectedAsString(files).forEach((test) => console.log(test));
+	}), !errorsPrinted) return typeof options.json === "undefined" ? formatCollectedAsString(files).forEach((test) => console.log(test)) : processJsonOutput(files, options);
 }
 function outputFileList(files, options) {
 	if (typeof options.json !== "undefined") return outputJsonFileList(files, options);
@@ -10566,8 +10226,7 @@ function outputJsonFileList(files, options) {
 	if (typeof options.json === "boolean") return console.log(JSON.stringify(formatFilesAsJSON(files), null, 2));
 	if (typeof options.json === "string") {
 		const jsonPath = resolve(options.root || process.cwd(), options.json);
-		mkdirSync(dirname(jsonPath), { recursive: true });
-		writeFileSync(jsonPath, JSON.stringify(formatFilesAsJSON(files), null, 2));
+		mkdirSync(dirname(jsonPath), { recursive: true }), writeFileSync(jsonPath, JSON.stringify(formatFilesAsJSON(files), null, 2));
 	}
 }
 function formatFilesAsJSON(files) {
@@ -10588,8 +10247,7 @@ function processJsonOutput(files, options) {
 	if (typeof options.json === "boolean") return console.log(JSON.stringify(formatCollectedAsJSON(files), null, 2));
 	if (typeof options.json === "string") {
 		const jsonPath = resolve(options.root || process.cwd(), options.json);
-		mkdirSync(dirname(jsonPath), { recursive: true });
-		writeFileSync(jsonPath, JSON.stringify(formatCollectedAsJSON(files), null, 2));
+		mkdirSync(dirname(jsonPath), { recursive: true }), writeFileSync(jsonPath, JSON.stringify(formatCollectedAsJSON(files), null, 2));
 	}
 }
 function forEachSuite(modules, callback) {
@@ -10600,7 +10258,7 @@ function forEachSuite(modules, callback) {
 }
 function formatCollectedAsJSON(files) {
 	const results = [];
-	files.forEach((file) => {
+	return files.forEach((file) => {
 		for (const test of file.children.allTests()) {
 			if (test.result().state === "skipped") continue;
 			const result = {
@@ -10611,19 +10269,17 @@ function formatCollectedAsJSON(files) {
 			if (test.location) result.location = test.location;
 			results.push(result);
 		}
-	});
-	return results;
+	}), results;
 }
 function formatCollectedAsString(testModules) {
 	const results = [];
-	testModules.forEach((testModule) => {
+	return testModules.forEach((testModule) => {
 		for (const test of testModule.children.allTests()) {
 			if (test.result().state === "skipped") continue;
 			const fullName = `${test.module.task.name} > ${test.fullName}`;
 			results.push((test.project.name ? `[${test.project.name}] ` : "") + fullName);
 		}
-	});
-	return results;
+	}), results;
 }
 const envPackageNames = {
 	"jsdom": "jsdom",
@@ -10631,10 +10287,7 @@ const envPackageNames = {
 	"edge-runtime": "@edge-runtime/vm"
 };
 function getEnvPackageName(env) {
-	if (env === "node") return null;
-	if (env in envPackageNames) return envPackageNames[env];
-	if (env[0] === "." || isAbsolute(env)) return null;
-	return `vitest-environment-${env}`;
+	return env === "node" ? null : env in envPackageNames ? envPackageNames[env] : env[0] === "." || isAbsolute(env) ? null : `vitest-environment-${env}`;
 }
 
 var cliApi = /*#__PURE__*/Object.freeze({
@@ -10647,4 +10300,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { FilesNotFoundError as F, GitNotFoundError as G, TestModule as T, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, registerConsoleShortcuts as d, createViteLogger as e, cliApi as f, isValidApiRequest as i, resolveFsAllow as r, startVitest as s };
+export { FilesNotFoundError as F, GitNotFoundError as G, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, experimental_getRunnerTask as d, escapeTestName as e, registerConsoleShortcuts as f, createViteLogger as g, createDebugger as h, isValidApiRequest as i, cliApi as j, resolveFsAllow as r, startVitest as s };