vitest 4.0.0-beta.5 → 4.0.0-beta.7

package/dist/chunks/{cli-api.COn58yrl.js → cli-api.DfGJyldU.js}

@@ -2,16 +2,17 @@ import fs, { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from
 import { relative, resolve, dirname, extname, normalize, join, basename, isAbsolute } from 'pathe';
 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, cleanUrl, deepMerge, KNOWN_ASSET_RE, 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, mergeConfig, createServer } from 'vite';
+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 { generateFileHash, limitConcurrency, createFileTask, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
+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 { v as version$1 } from './cac.CKnbxhn2.js';
+import { v as version$1 } from './cac.Dsn7ixFt.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.DQhAfQQU.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.C3EbxYwt.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -23,11 +24,12 @@ 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, 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.B6cReEn1.js';
-import { c as convertTasksToEvents } from './typechecker.BgoW4nTA.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.Dvxug1RM.js';
+import { b as ancestor, c as convertTasksToEvents } from './typechecker.DSo_maXz.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';
@@ -36,17 +38,16 @@ 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 MagicString from 'magic-string';
 import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
 import { c as configDefaults } from './defaults.CXFFjsi8.js';
-import { f as findNearestPackageData } from './resolver.D5bG4zy5.js';
+import { f as findNearestPackageData } from './resolver.Bx6lE0iq.js';
 import * as esModuleLexer from 'es-module-lexer';
-import { a as BenchmarkReportsMap } from './index.DgN0Zk9a.js';
+import { a as BenchmarkReportsMap } from './index.D2B6d2vv.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';
 
@@ -5017,26 +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);
 		// 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);
+		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));
@@ -5088,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.server;
 	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({
@@ -5116,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.`);
@@ -5139,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.vite.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");
@@ -5183,56 +5172,41 @@ function setup(ctx, _server) {
 			deserialize: parse,
 			timeout: -1
 		});
-		clients.set(ws, rpc);
-		ws.on("close", () => {
-			clients.delete(ws);
-			rpc.$close(/* @__PURE__ */ new Error("[vitest-api]: Pending methods while closing rpc"));
+		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);
 		});
@@ -5255,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.getName(),
+		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();
@@ -5266,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(() => {
+		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;
 	}
 }
 
@@ -5323,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"
@@ -5367,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,
@@ -5412,9 +5627,7 @@ class ServerModuleRunner extends ModuleRunner {
 					return { error };
 				}
 			} }
-		}, new VitestModuleEvaluator());
-		this.environment = environment;
-		this.config = config;
+		}, new VitestModuleEvaluator()), this.environment = environment, this.config = config;
 	}
 	async import(rawId) {
 		const resolved = await this.environment.pluginContainer.resolveId(rawId, this.config.root);
@@ -5481,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) {
@@ -5532,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);
@@ -5554,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;
@@ -5568,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.server.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.server.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));
@@ -5604,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;
@@ -5642,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);
 		});
 	}
@@ -5689,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;
+	const optimizer = config.deps?.optimizer || {}, poolOptions = config.poolOptions, isolate = viteConfig?.test?.isolate;
 	return {
 		environmentOptions: config.environmentOptions,
 		mode: config.mode,
@@ -5752,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,
@@ -5778,8 +5926,7 @@ function serializeConfig(config, coreConfig, viteConfig) {
 		deps: {
 			web: config.deps.web || {},
 			optimizer: Object.entries(optimizer).reduce((acc, [name, option]) => {
-				acc[name] = { enabled: option?.enabled ?? false };
-				return acc;
+				return acc[name] = { enabled: option?.enabled ?? false }, acc;
 			}, {}),
 			interopDefault: config.deps.interopDefault,
 			moduleDirectories: config.deps.moduleDirectories
@@ -5816,7 +5963,8 @@ 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: browser.provider === "playwright" ? { actionTimeout: browser.providerOptions?.context?.actionTimeout } : {},
+				trackUnhandledErrors: browser.trackUnhandledErrors ?? true
 			};
 		})(config.browser),
 		standalone: config.standalone,
@@ -5840,12 +5988,12 @@ 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) {
@@ -6350,12 +6498,10 @@ function MetaEnvReplacerPlugin() {
 		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);
+			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;
-				const endIndex = startIndex + env[0].length;
+				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)`);
 			}
 			if (s) return {
@@ -6373,9 +6519,7 @@ 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;
+			return id.includes(normalizedDistDir) ? false : options.filter ? options.filter(id) : true;
 		},
 		codeFrameGenerator(node, id, code) {
 			return generateCodeFrame(code, 4, node.start + 1);
@@ -6401,34 +6545,23 @@ const LogLevels = {
 	info: 3
 };
 function clearScreen(logger) {
-	const repeatCount = process.stdout.rows - 2;
-	const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+	const repeatCount = process.stdout.rows - 2, 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;
+let lastType, lastMsg, sameCount = 0, timeFormatter;
 function getTimeFormatter() {
-	timeFormatter ??= new Intl.DateTimeFormat(void 0, {
+	return timeFormatter ??= new Intl.DateTimeFormat(void 0, {
 		hour: "numeric",
 		minute: "numeric",
 		second: "numeric"
-	});
-	return timeFormatter;
+	}), 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 : () => {};
+	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 = "";
@@ -6443,39 +6576,27 @@ function createViteLogger(console, level = "info", 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);
+			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();
-	const logger = {
+	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);
+			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);
+			warnedMessages.has(msg) || (logger.hasWarned = true, output("warn", msg, opts), warnedMessages.add(msg));
 		},
 		error(msg, opts) {
-			logger.hasWarned = true;
-			output("error", msg, opts);
+			logger.hasWarned = true, output("error", msg, opts);
 		},
 		clearScreen(type) {
 			if (thresh >= LogLevels[type]) clear(console);
@@ -6491,16 +6612,12 @@ 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);
+			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)(?:$|\\?)";
-const cssLangRE = new RegExp(cssLangs);
-const cssModuleRE = /* @__PURE__ */ new RegExp(`\\.module${cssLangs}`);
-const cssInlineRE = /[?&]inline(?:&|$)/;
+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);
 }
@@ -6520,45 +6637,37 @@ function getCSSModuleProxyReturn(strategy, filename) {
 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 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)) 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: "" };
+			if (isCSS(id) && !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), {
+			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 };
+				}
+				return { code: "export default \"\"" };
 			}
-			return { code: "export default \"\"" };
 		}
 	}];
 }
 
-const metaUrlLength = 15;
-const locationString = "self.location".padEnd(metaUrlLength, " ");
+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".
@@ -6569,14 +6678,11 @@ function NormalizeURLPlugin() {
 		enforce: "post",
 		transform(code) {
 			if (this.environment.name !== "client" || !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;
+			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;
-				const metaUrlIndex = index + exp.indexOf("import.meta.url");
+				const { 0: exp, index } = match, metaUrlIndex = index + exp.indexOf("import.meta.url");
 				updatedCode = updatedCode.slice(0, metaUrlIndex) + locationString + updatedCode.slice(metaUrlIndex + metaUrlLength);
 			}
 			return {
@@ -6593,10 +6699,7 @@ function VitestOptimizer() {
 		config: {
 			order: "post",
 			handler(viteConfig) {
-				const testConfig = viteConfig.test || {};
-				const root = resolve(viteConfig.root || process.cwd());
-				const name = viteConfig.test?.name;
-				const label = typeof name === "string" ? name : name?.label || "";
+				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);
 			}
 		}
@@ -6606,21 +6709,17 @@ function VitestOptimizer() {
 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 || [];
-		const exclude = [
+	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 || []
-		];
-		const runtime = currentInclude.filter((n) => n.endsWith("jsx-dev-runtime") || n.endsWith("jsx-runtime"));
+		], 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 = {
@@ -6635,21 +6734,12 @@ function resolveOptimizerConfig(_testOptions, viteOptions) {
 	}
 	// `optimizeDeps.disabled` is deprecated since v5.1.0-beta.1
 	// https://github.com/vitejs/vite/pull/15184
-	if (optimizeDeps.disabled) {
-		optimizeDeps.noDiscovery = true;
-		optimizeDeps.include = [];
-	}
-	delete optimizeDeps.disabled;
-	return optimizeDeps;
+	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;
@@ -6662,26 +6752,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 {
@@ -6708,78 +6792,44 @@ function ModuleRunnerTransform() {
 				const testConfig = config.test || {};
 				config.environments ??= {};
 				const names = new Set(Object.keys(config.environments));
-				names.add("client");
-				names.add("ssr");
+				names.add("client"), names.add("ssr");
 				const pool = config.test?.pool;
 				if (pool === "vmForks" || pool === "vmThreads") names.add("__vitest_vm__");
-				const external = [];
-				const noExternal = [];
+				const external = [], noExternal = [];
 				let noExternalAll;
 				for (const name of names) {
 					config.environments[name] ??= {};
 					const environment = config.environments[name];
-					environment.dev ??= {};
 					// vm tests run using the native import mechanism
-					if (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 : [];
-					const resolveNoExternal = name === "client" ? config.resolve?.noExternal : [];
-					const topLevelResolveOptions = {};
+					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 || {});
-					const envNoExternal = resolveViteResolveOptions("noExternal", currentResolveOptions);
+					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);
-					// remove Vite's externalization logic because we have our own (unfortunetly)
-					environment.resolve ??= {};
-					environment.resolve.external = [...builtinModules, ...builtinModules.map((m) => `node:${m}`)];
-					// by setting `noExternal` to `true`, we make sure that
-					// Vite will never use its own externalization mechanism
-					// to externalize modules and always resolve static imports
-					// in both SSR and Client environments
-					environment.resolve.noExternal = true;
-					if (name === "__vitest_vm__" || name === "__vitest__") continue;
-					const currentOptimizeDeps = environment.optimizeDeps || (name === "client" ? config.optimizeDeps : name === "ssr" ? config.ssr?.optimizeDeps : void 0);
-					const optimizeDeps = resolveOptimizerConfig(testConfig.deps?.optimizer?.[name], currentOptimizeDeps);
+					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 (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;
 				}
-				testConfig.server ??= {};
-				testConfig.server.deps ??= {};
-				if (testConfig.server.deps.inline !== true) {
+				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);
+					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);
 			}
 		}
 	};
 }
 function resolveViteResolveOptions(key, options) {
-	if (Array.isArray(options[key])) return options[key];
-	else if (typeof options[key] === "string" || options[key] instanceof RegExp) return [options[key]];
-	else if (typeof options[key] === "boolean") return true;
-	return [];
+	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) {
@@ -6826,23 +6876,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
@@ -6870,22 +6913,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,
@@ -6898,19 +6933,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;
 			}
 		},
 		{
@@ -6918,8 +6961,7 @@ 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();
 			}
 		},
 		MetaEnvReplacerPlugin(),
@@ -6962,10 +7004,7 @@ const BUILTIN_EXTENSIONS = new Set([
 	".cjs",
 	".node",
 	".wasm"
-]);
-const ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/;
-const ESM_FOLDER_RE = /\/(es|esm)\/(.*\.js)$/;
-const defaultInline = [
+]), 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/,
@@ -6973,8 +7012,7 @@ const defaultInline = [
 	/^(?!.*node_modules).*\.mjs$/,
 	/^(?!.*node_modules).*\.cjs\.js$/,
 	/vite\w*\/dist\/client\/env.mjs/
-];
-const depsExternal = [/\/node_modules\/.*\.cjs\.js$/, /\/node_modules\/.*\.mjs$/];
+], depsExternal = [/\/node_modules\/.*\.cjs\.js$/, /\/node_modules\/.*\.mjs$/];
 function guessCJSversion(id) {
 	if (id.match(ESM_EXT_RE)) {
 		for (const i of [
@@ -7004,8 +7042,7 @@ async function isValidNodeImport(id) {
 	if (/\.(?:\w+-)?esm?(?:-\w+)?\.js$|\/esm?\//.test(id)) return false;
 	try {
 		await esModuleLexer.init;
-		const code = await promises.readFile(id, "utf8");
-		const [, , , hasModuleSyntax] = esModuleLexer.parse(code);
+		const code = await promises.readFile(id, "utf8"), [, , , hasModuleSyntax] = esModuleLexer.parse(code);
 		return !hasModuleSyntax;
 	} catch {
 		return false;
@@ -7016,25 +7053,17 @@ async function shouldExternalize(id, options, cache) {
 	return cache.get(id);
 }
 async function _shouldExternalize(id, options) {
-	if (isBuiltin(id)) return id;
 	// 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 (id.startsWith("data:") || /^(?:https?:)?\/\//.test(id)) return id;
+	if (isBuiltin(id) || id.startsWith("data:") || /^(?:https?:)?\/\//.test(id)) return id;
 	const moduleDirectories = options?.moduleDirectories || ["/node_modules/"];
-	if (matchExternalizePattern(id, moduleDirectories, options?.inline)) return false;
-	if (options?.inlineFiles && options?.inlineFiles.includes(id)) return false;
-	if (matchExternalizePattern(id, moduleDirectories, options?.external)) return id;
+	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 (options?.cacheDir && id.includes(options.cacheDir)) return id;
-	const isLibraryModule = moduleDirectories.some((dir) => id.includes(dir));
-	const guessCJS = isLibraryModule && options?.fallbackCJS;
-	id = guessCJS ? guessCJSversion(id) || id : id;
-	if (matchExternalizePattern(id, moduleDirectories, defaultInline)) return false;
-	if (matchExternalizePattern(id, moduleDirectories, depsExternal)) return id;
-	if (isLibraryModule && await isValidNodeImport(id)) return id;
-	return false;
+	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;
@@ -7080,24 +7109,16 @@ 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;
+		this[0] = project, this[1] = moduleId, this[2] = { pool };
+		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 [
@@ -7117,9 +7138,7 @@ class TestSpecification {
 	* @deprecated
 	*/
 	*[Symbol.iterator]() {
-		yield this.project;
-		yield this.moduleId;
-		yield this.pool;
+		yield this.project, yield this.moduleId, yield this.pool;
 	}
 }
 
@@ -7128,12 +7147,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 {
@@ -7161,18 +7178,14 @@ class TestProject {
 	/** @internal */ _vite;
 	/** @internal */ _hash;
 	/** @internal */ _resolver;
+	/** @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;
+		this.path = path, this.options = options, this.vitest = vitest, this.ctx = vitest, this.globalConfig = vitest.config;
 	}
 	/**
 	* The unique hash of this project. This value is consistent between the reruns.
@@ -7201,10 +7214,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
 		};
@@ -7228,13 +7240,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.
@@ -7291,13 +7301,14 @@ class TestProject {
 	}
 	/** @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) {
@@ -7309,8 +7320,7 @@ class TestProject {
 	}
 	/** @internal */
 	async _teardownGlobalSetup() {
-		if (!this._globalSetups) return;
-		for (const globalSetupFile of [...this._globalSetups].reverse()) await globalSetupFile.teardown?.();
+		if (this._globalSetups) for (const globalSetupFile of [...this._globalSetups].reverse()) await globalSetupFile.teardown?.();
 	}
 	/** @deprecated use `vitest.logger` instead */
 	get logger() {
@@ -7340,12 +7350,8 @@ class TestProject {
 	* @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)
 		};
@@ -7364,8 +7370,7 @@ class TestProject {
 				}
 			}));
 		}
-		this.testFilesList = testFiles;
-		return testFiles;
+		return this.testFilesList = testFiles, testFiles;
 	}
 	isBrowserEnabled() {
 		return isBrowserEnabled(this.config);
@@ -7402,8 +7407,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
@@ -7416,16 +7420,10 @@ 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;
 	}
@@ -7438,7 +7436,7 @@ class TestProject {
 	}
 	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
@@ -7446,8 +7444,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 */
@@ -7466,21 +7463,15 @@ class TestProject {
 				}
 			},
 			...MocksPlugins({ filter(id) {
-				if (id.includes(distRoot) || id.includes(cacheDir)) return false;
-				return true;
+				return !(id.includes(distRoot) || id.includes(cacheDir));
 			} }),
 			MetaEnvReplacerPlugin()
 		], [CoverageTransform(this.vitest)]);
-		this._parentBrowser = browser;
-		if (this.config.browser.ui) setup(this.vitest, browser.vite);
+		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.
@@ -7493,8 +7484,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;
 	}
@@ -7518,27 +7508,22 @@ class TestProject {
 	}
 	/** @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._resolver = new VitestResolver(server.config.cacheDir, this._config);
-		this._vite = server;
+		this.closingPromise = void 0, this._resolver = new VitestResolver(server.config.cacheDir, this._config), this._vite = server;
 		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);
+		return this.vitest.configOverride ? deepMerge(config, this.vitest.configOverride) : config;
 	}
 	async clearTmpDir() {
 		try {
@@ -7551,9 +7536,10 @@ class TestProject {
 	}
 	/** @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) {
@@ -7566,40 +7552,25 @@ class TestProject {
 	/** @internal */
 	static _createBasicProject(vitest) {
 		const project = new TestProject(vitest.config.name || vitest.config.root, vitest);
-		project.runner = vitest.runner;
-		project._vite = vitest.server;
-		project._config = vitest.config;
-		project._resolver = vitest._resolver;
-		project._setHash();
-		project._provideObject(vitest.config.provide);
-		return project;
+		return project.runner = vitest.runner, project._vite = vitest.server, project._config = vitest.config, project._resolver = vitest._resolver, project._setHash(), project._provideObject(vitest.config.provide), project;
 	}
 	/** @internal */
 	static _cloneBrowserProject(parent, config) {
 		const clone = new TestProject(parent.path, parent.vitest);
-		clone.runner = parent.runner;
-		clone._vite = parent._vite;
-		clone._resolver = parent._resolver;
-		clone._config = config;
-		clone._setHash();
-		clone._parent = parent;
-		clone._provideObject(config.provide);
-		return clone;
+		return clone.runner = parent.runner, clone._vite = parent._vite, clone._resolver = parent._resolver, clone._config = config, clone._setHash(), clone._parent = parent, 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(workspacePath, ctx, options), { configFile,...restOptions } = options, config = {
 		...restOptions,
 		configFile,
 		configLoader: ctx.vite.config.inlineConfig.configLoader,
@@ -7609,25 +7580,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",
@@ -7646,21 +7612,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 = 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,
@@ -7678,8 +7635,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,
@@ -7692,9 +7648,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
@@ -7706,8 +7660,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"
@@ -7729,24 +7682,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);
 		});
@@ -7759,8 +7706,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 		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;
@@ -7775,18 +7721,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) => ({
@@ -7801,10 +7744,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,...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,
@@ -7816,18 +7758,15 @@ function cloneConfig(project, { browser,...config }) {
 			name: browser,
 			providerOptions: config,
 			instances: void 0
-		}
+		},
+		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
@@ -7871,8 +7810,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
@@ -7891,21 +7829,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];
@@ -7925,8 +7857,7 @@ 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") {
@@ -7967,14 +7898,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;
@@ -7993,45 +7922,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);
@@ -8041,30 +7960,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
@@ -8072,8 +7981,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);
@@ -8083,8 +7991,7 @@ class VitestSpecifications {
 		const addImports = async (project, filepath) => {
 			if (deps.has(filepath)) return;
 			deps.add(filepath);
-			const mod = project.vite.environments.ssr.moduleGraph.getModuleById(filepath);
-			const transformed = mod?.transformResult || await project.vite.environments.ssr.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) => {
@@ -8092,9 +7999,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;
 	}
 }
 
@@ -8120,10 +8025,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.
@@ -8145,8 +8047,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 {
@@ -8170,9 +8071,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;
@@ -8194,8 +8093,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,
@@ -8206,16 +8104,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 || []
 		};
@@ -8234,8 +8130,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,
@@ -8251,8 +8146,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.
@@ -8305,10 +8199,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);
@@ -8321,8 +8212,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.
@@ -8352,9 +8242,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;
@@ -8385,29 +8273,21 @@ class TestModule extends SuiteImplementation {
 	moduleId;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project);
-		this.moduleId = task.filepath;
+		super(task, project), this.moduleId = task.filepath;
 	}
 	/**
 	* 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,
@@ -8439,18 +8319,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();
@@ -8481,12 +8362,7 @@ class StateManager {
 		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;
-			}
+			if (task) task.mode = "skip", task.result ??= { state: "skip" }, task.result.state = "skip", task.result.note = _error.note;
 			return;
 		}
 		if (!this.onUnhandledError || this.onUnhandledError(error) !== false) this.errorsSet.add(error);
@@ -8510,12 +8386,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) {
@@ -8534,25 +8406,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;
 			}
@@ -8563,14 +8427,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);
@@ -8579,10 +8443,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";
 			}
 		}
 	}
@@ -8597,7 +8459,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)));
 	}
 }
 
@@ -9059,10 +8921,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]);
@@ -9070,30 +8929,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?
@@ -9101,30 +8952,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);
-		}
+		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
@@ -9136,8 +8989,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
 			} : {
@@ -9149,37 +9001,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) {
@@ -9207,23 +9047,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));
@@ -9231,25 +9063,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 {
@@ -9257,22 +9081,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);
@@ -9280,13 +9093,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);
@@ -9294,51 +9104,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;
@@ -9385,6 +9177,14 @@ 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;
@@ -9401,7 +9201,6 @@ class Vitest {
 	isFirstRun = true;
 	restartsCount = 0;
 	specifications;
-	watcher;
 	pool;
 	_config;
 	_vite;
@@ -9409,12 +9208,7 @@ class Vitest {
 	_cache;
 	_snapshot;
 	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 = [];
@@ -9434,8 +9228,7 @@ class Vitest {
 	* The global config.
 	*/
 	get config() {
-		assert(this._config, "config");
-		return this._config;
+		return assert(this._config, "config"), this._config;
 	}
 	/** @deprecated use `vitest.vite` instead */
 	get server() {
@@ -9445,30 +9238,26 @@ class Vitest {
 	* 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;
+		return assert(this._cache, "cache"), this._cache;
 	}
 	/** @deprecated internal */
 	setServer(options, server) {
@@ -9476,48 +9265,21 @@ class Vitest {
 	}
 	/** @internal */
 	async _setServer(options, server) {
-		this.watcher.unregisterWatcher();
-		clearTimeout(this._rerunTimer);
-		this.restartsCount += 1;
-		this.pool?.close?.();
-		this.pool = void 0;
-		this.closingPromise = void 0;
-		this.projects = [];
-		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.coverageProvider = void 0, this.runningPromise = void 0, this.coreWorkspaceProject = void 0, this.specifications.clearCache(), this._onUserTestsRerun = [], this._vite = server;
 		const resolved = resolveConfig(this, options, server.config);
-		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);
-		if (this.config.watch) this.watcher.registerWatcher();
+		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__;
-		this.runner = new ServerModuleRunner(environment, this._resolver, resolved);
-		if (this.config.watch) {
+		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);
-				if (isConfig) {
-					await Promise.all(this._onRestartListeners.map((fn) => fn("config")));
-					this.report("onServerRestart", "config");
-					await this.close();
-					await serverRestart();
-				}
+				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);
@@ -9525,28 +9287,24 @@ class Vitest {
 			await this.cache.results.readFromCache();
 		} catch {}
 		const projects = await this.resolveProjects(this._cliOptions);
-		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()));
 	}
 	/**
 	* Inject new test projects into the workspace.
@@ -9554,10 +9312,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`.
@@ -9573,9 +9329,7 @@ class Vitest {
 	}
 	/** @internal */
 	_ensureRootProject() {
-		if (this.coreWorkspaceProject) return this.coreWorkspaceProject;
-		this.coreWorkspaceProject = TestProject._createBasicProject(this);
-		return this.coreWorkspaceProject;
+		return this.coreWorkspaceProject ||= TestProject._createBasicProject(this), this.coreWorkspaceProject;
 	}
 	/** @deprecated use `getRootProject` instead */
 	getCoreWorkspaceProject() {
@@ -9592,8 +9346,7 @@ class Vitest {
 	* @deprecated use Reported Task API instead
 	*/
 	getProjectByTaskId(taskId) {
-		const task = this.state.idMap.get(taskId);
-		const projectName = task.projectName || task?.file?.projectName || "";
+		const task = this.state.idMap.get(taskId), projectName = task.projectName || task?.file?.projectName || "";
 		return this.getProjectByName(projectName);
 	}
 	getProjectByName(name) {
@@ -9608,6 +9361,15 @@ class Vitest {
 	import(moduleId) {
 		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.config.coverage.clean);
+		return coverageProvider || null;
+	}
 	async resolveProjects(cliOptions) {
 		const names = /* @__PURE__ */ new Set();
 		if (this.config.projects) return resolveProjects(this, cliOptions, void 0, this.config.projects, names);
@@ -9615,8 +9377,7 @@ class Vitest {
 		// 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]);
+		return project ? resolveBrowserProjects(this, new Set([project.name]), [project]) : [];
 	}
 	/**
 	* Glob test files in every project and create a TestSpecification for each file and pool.
@@ -9626,13 +9387,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();
+		if (this.coverageProvider === void 0) {
+			if (this.coverageProvider = await getCoverageProvider(this.config.coverage, this.runner), this.coverageProvider) await this.coverageProvider.initialize(this), this.config.coverage = this.coverageProvider.resolveOptions();
+			return this.coverageProvider;
 		}
-		return this.coverageProvider;
 	}
 	/**
 	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
@@ -9645,23 +9403,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()
 		};
@@ -9669,10 +9419,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);
@@ -9681,12 +9429,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) {
@@ -9709,8 +9455,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.config.coverage.clean);
 		} finally {
 			await this.report("onInit", this);
 		}
@@ -9720,20 +9465,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;
 	}
@@ -9743,14 +9481,11 @@ class Vitest {
 	*/
 	async init() {
 		try {
-			await this.initCoverageProvider();
-			await this.coverageProvider?.clean(this.config.coverage.clean);
+			await this.initCoverageProvider(), await this.coverageProvider?.clean(this.config.coverage.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"
@@ -9763,6 +9498,13 @@ class Vitest {
 		return this.getModuleSpecifications(file);
 	}
 	/**
+	* If there is a test run happening, returns a promise that will
+	* resolve when the test run is finished.
+	*/
+	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.
 	*
 	* **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
@@ -9775,7 +9517,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.
@@ -9783,8 +9527,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.
@@ -9796,24 +9539,14 @@ class Vitest {
 		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.config.coverage.cleanOnRerun) await this.coverageProvider?.clean();
 				await this.initializeGlobalSetup(specs);
 				try {
 					await this.pool.runTests(specs, invalidates);
@@ -9830,21 +9563,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.
@@ -9852,19 +9588,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) {
@@ -9879,28 +9606,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();
 	}
@@ -9914,8 +9634,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) {
@@ -9935,9 +9654,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);
@@ -9961,9 +9679,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 {
@@ -9981,15 +9697,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.
@@ -10006,42 +9720,28 @@ class Vitest {
 		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.
@@ -10065,8 +9765,7 @@ class Vitest {
 	}
 	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.config.coverage.reportOnFailure) return;
 		}
 		if (this.coverageProvider) {
 			await this.coverageProvider.reportCoverage(coverage, { allTestsRun });
@@ -10089,11 +9788,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);
 				});
@@ -10106,11 +9803,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`);
@@ -10119,9 +9814,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) {
@@ -10203,9 +9896,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);
 		});
@@ -10218,8 +9909,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 [
 		{
@@ -10245,14 +9935,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
@@ -10282,21 +9967,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);
 				// 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));
 					};
@@ -10307,17 +10000,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)
@@ -10337,8 +10024,7 @@ 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();
 				}
@@ -10360,25 +10046,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;
@@ -10389,23 +10069,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 {
@@ -10421,13 +10095,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--;
@@ -10454,17 +10126,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;
@@ -10480,14 +10148,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() {
@@ -10512,8 +10176,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",
@@ -10531,17 +10194,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;
@@ -10570,24 +10228,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));
@@ -10596,11 +10247,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() {
@@ -10611,41 +10259,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 watchFilter = new WatchFilter("Input filename pattern", stdin, stdout), filter = await watchFilter.filter(async (str) => {
 			const files = await ctx.globTestFiles([str]);
 			return files.map((file) => relative(ctx.config.root, file[1])).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();
 	};
 }
@@ -10656,20 +10294,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, cliFilters);
+	const root = resolve(options.root || process.cwd()), ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions, cliFilters);
 	if (mode === "test" && ctx.config.coverage.enabled) {
-		const provider = ctx.config.coverage.provider || "v8";
-		const requiredPackages = CoverageProviderMap[provider];
+		const provider = ctx.config.coverage.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(() => {
@@ -10681,55 +10313,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, cliFilters) {
-	process.env.TEST = "true";
-	process.env.VITEST = "true";
-	process.env.NODE_ENV ??= "test";
-	if (options.run) options.watch = false;
+	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);
@@ -10739,8 +10343,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) {
@@ -10761,8 +10364,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) {
@@ -10773,7 +10375,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 = {
@@ -10784,19 +10386,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",
@@ -10804,10 +10404,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({
@@ -10820,4 +10417,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { FilesNotFoundError as F, GitNotFoundError as G, 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 };