vitest 3.2.0-beta.2 → 3.2.0

package/dist/chunks/{cli-api.d6IK1pnk.js → cli-api.Cej3MBjA.js}

@@ -1,19 +1,19 @@
-import { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { extname, normalize, relative, dirname, resolve, join, basename, isAbsolute } from 'pathe';
-import { C as CoverageProviderMap } from './coverage.0iPg4Wrz.js';
+import fs, { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { relative, resolve, dirname, extname, normalize, join, basename, isAbsolute } from 'pathe';
+import { C as CoverageProviderMap } from './coverage.DVF1vEu8.js';
 import path, { resolve as resolve$1 } from 'node:path';
-import { noop, isPrimitive, createDefer, highlight, toArray, deepMerge, nanoid, slash, deepClone, notNullish } from '@vitest/utils';
+import { noop, isPrimitive, createDefer, slash, highlight, toArray, deepMerge, nanoid, deepClone, 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 { A as API_PATH, c as configFiles, d as defaultBrowserPort, w as workspacesFiles, a as defaultPort } from './constants.BZZyIeIE.js';
+import { searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
+import { A as API_PATH, c as configFiles, d as defaultBrowserPort, w as workspacesFiles, a as defaultPort } from './constants.DnKduX2e.js';
 import { generateFileHash, limitConcurrency, createFileTask, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.I9MLYfT-.js';
+import { v as version$1 } from './cac.6rXCxFY1.js';
 import { c as createBirpc } from './index.CJ0plNrh.js';
-import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, j as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.CV36oG_L.js';
+import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, j as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.BZ0g1JD2.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -26,24 +26,24 @@ 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 from 'node:crypto';
+import crypto, { createHash } from 'node:crypto';
 import { distDir, rootDir } from '../path.js';
-import { R as RandomSequencer, i as isPackageExists, h as hash, V as VitestCache, g as getFilePoolName, d as isBrowserEnabled, r as resolveConfig, e as groupBy, f as getCoverageProvider, j as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.OGU09Jbh.js';
-import { c as convertTasksToEvents } from './typechecker.DnTrplSJ.js';
+import { h as hash, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, d as isBrowserEnabled, r as resolveConfig, e as groupBy, f as getCoverageProvider, j as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.EIiagJJP.js';
+import { c as convertTasksToEvents } from './typechecker.DRKU1-1g.js';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
 import { createRequire } from 'node:module';
 import url from 'node:url';
-import { i as isTTY, a as isWindows } from './env.Dq0hM4Xv.js';
-import { rm } from 'node:fs/promises';
+import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
+import { rm, mkdir, copyFile } from 'node:fs/promises';
 import nodeos__default, { tmpdir } from 'node:os';
 import pm from 'picomatch';
 import { glob, isDynamicPattern } from 'tinyglobby';
 import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
 import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
-import { c as configDefaults } from './defaults.DSxsTG0h.js';
+import { c as configDefaults } from './defaults.B7q_naMc.js';
 import MagicString from 'magic-string';
-import { a as BenchmarkReportsMap } from './index.CmC5OK9L.js';
+import { a as BenchmarkReportsMap } from './index.CIyJn3t1.js';
 import assert$1 from 'node:assert';
 import { serializeError } from '@vitest/utils/error';
 import readline from 'node:readline';
@@ -779,6 +779,14 @@ function requirePermessageDeflate () {
 	  this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
 	  this[kError][kStatusCode] = 1009;
 	  this.removeListener('data', inflateOnData);
+
+	  //
+	  // The choice to employ `zlib.reset()` over `zlib.close()` is dictated by the
+	  // fact that in Node.js versions prior to 13.10.0, the callback for
+	  // `zlib.flush()` is not called if `zlib.close()` is used. Utilizing
+	  // `zlib.reset()` ensures that either the callback is invoked or an error is
+	  // emitted.
+	  //
 	  this.reset();
 	}
 
@@ -794,6 +802,12 @@ function requirePermessageDeflate () {
 	  // closed when an error is emitted.
 	  //
 	  this[kPerMessageDeflate]._inflate = null;
+
+	  if (this[kError]) {
+	    this[kCallback](this[kError]);
+	    return;
+	  }
+
 	  err[kStatusCode] = 1007;
 	  this[kCallback](err);
 	}
@@ -3511,7 +3525,7 @@ function requireWebsocket () {
 	  if (parsedUrl.protocol !== 'ws:' && !isSecure && !isIpcUrl) {
 	    invalidUrlMessage =
 	      'The URL\'s protocol must be one of "ws:", "wss:", ' +
-	      '"http:", "https", or "ws+unix:"';
+	      '"http:", "https:", or "ws+unix:"';
 	  } else if (isIpcUrl && !parsedUrl.pathname) {
 	    invalidUrlMessage = "The URL's pathname is empty";
 	  } else if (parsedUrl.hash) {
@@ -4993,19 +5007,13 @@ var WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServerExport
 
 async function getModuleGraph(ctx, projectName, id, browser = false) {
 	const graph = {};
-	const externalized = new Set();
-	const inlined = new Set();
+	const externalized = /* @__PURE__ */ new Set();
+	const inlined = /* @__PURE__ */ new Set();
 	const project = ctx.getProjectByName(projectName);
-	async function get(mod, seen = new Map()) {
-		if (!mod || !mod.id) {
-			return;
-		}
-		if (mod.id === "\0@vitest/browser/context") {
-			return;
-		}
-		if (seen.has(mod)) {
-			return seen.get(mod);
-		}
+	async function get(mod, seen = /* @__PURE__ */ new Map()) {
+		if (!mod || !mod.id) return;
+		if (mod.id === "\0@vitest/browser/context") return;
+		if (seen.has(mod)) return seen.get(mod);
 		let id = clearId(mod.id);
 		seen.set(mod, id);
 		const rewrote = browser ? mod.file?.includes(project.browser.vite.config.cacheDir) ? mod.id : false : await project.vitenode.shouldExternalize(id);
@@ -5013,18 +5021,13 @@ async function getModuleGraph(ctx, projectName, id, browser = false) {
 			id = rewrote;
 			externalized.add(id);
 			seen.set(mod, id);
-		} else {
-			inlined.add(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;
 	}
-	if (browser && project.browser) {
-		await get(project.browser.vite.moduleGraph.getModuleById(id));
-	} else {
-		await get(project.vite.moduleGraph.getModuleById(id));
-	}
+	if (browser && project.browser) await get(project.browser.vite.moduleGraph.getModuleById(id));
+	else await get(project.vite.moduleGraph.getModuleById(id));
 	return {
 		graph,
 		externalized: Array.from(externalized),
@@ -5035,7 +5038,10 @@ function clearId(id) {
 	return id?.replace(/\?v=\w+$/, "") || "";
 }
 
+// Serialization support utils.
 function cloneByOwnProperties(value) {
+	// Clones the value's properties into a new Object. The simpler approach of
+	// Object.assign() won't work in the case that properties are not enumerable.
 	return Object.getOwnPropertyNames(value).reduce((clone, prop) => ({
 		...clone,
 		[prop]: value[prop]
@@ -5054,34 +5060,29 @@ function stringifyReplace(key, value) {
 			stack: value.stack,
 			...cloned
 		};
-	} else {
-		return value;
-	}
+	} else return value;
 }
 
 function isValidApiRequest(config, req) {
 	const url = new URL(req.url ?? "", "http://localhost");
+	// validate token. token is injected in ui/tester/orchestrator html, which is cross origin protected.
 	try {
 		const token = url.searchParams.get("token");
-		if (token && crypto.timingSafeEqual(Buffer.from(token), Buffer.from(config.api.token))) {
-			return true;
-		}
-	} catch {}
+		if (token && crypto.timingSafeEqual(Buffer.from(token), Buffer.from(config.api.token))) return true;
+	} 
+	// an error is thrown when the length is incorrect
+catch {}
 	return false;
 }
 
 function setup(ctx, _server) {
 	const wss = new WebSocketServer({ noServer: true });
-	const clients = new Map();
+	const clients = /* @__PURE__ */ new Map();
 	const server = _server || ctx.server;
 	server.httpServer?.on("upgrade", (request, socket, head) => {
-		if (!request.url) {
-			return;
-		}
+		if (!request.url) return;
 		const { pathname } = new URL(request.url, "http://localhost");
-		if (pathname !== API_PATH) {
-			return;
-		}
+		if (pathname !== API_PATH) return;
 		if (!isValidApiRequest(ctx.config, request)) {
 			socket.destroy();
 			return;
@@ -5103,19 +5104,15 @@ function setup(ctx, _server) {
 				return ctx.state.getPaths();
 			},
 			async readTestFile(id) {
-				if (!ctx.state.filesMap.has(id) || !existsSync(id)) {
-					return null;
-				}
+				if (!ctx.state.filesMap.has(id) || !existsSync(id)) return null;
 				return 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.`);
-				}
+				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.`);
 				return promises.writeFile(id, content, "utf-8");
 			},
 			async rerun(files, resetTestNamePattern) {
-				await ctx.rerunFiles(files, undefined, true, resetTestNamePattern);
+				await ctx.rerunFiles(files, void 0, true, resetTestNamePattern);
 			},
 			async rerunTask(id) {
 				await ctx.rerunTask(id);
@@ -5146,11 +5143,8 @@ function setup(ctx, _server) {
 				return getModuleGraph(ctx, project, id, browser);
 			},
 			async updateSnapshot(file) {
-				if (!file) {
-					await ctx.updateSnapshot();
-				} else {
-					await ctx.updateSnapshot([file.filepath]);
-				}
+				if (!file) await ctx.updateSnapshot();
+				else await ctx.updateSnapshot([file.filepath]);
 			},
 			getUnhandledErrors() {
 				return ctx.state.getUnhandledErrors();
@@ -5196,42 +5190,38 @@ class WebSocketReporter {
 		this.clients = clients;
 	}
 	onCollected(files) {
-		if (this.clients.size === 0) {
-			return;
-		}
+		if (this.clients.size === 0) return;
 		this.clients.forEach((client) => {
 			client.onCollected?.(files)?.catch?.(noop);
 		});
 	}
 	onSpecsCollected(specs) {
-		if (this.clients.size === 0) {
-			return;
-		}
+		if (this.clients.size === 0) return;
 		this.clients.forEach((client) => {
 			client.onSpecsCollected?.(specs)?.catch?.(noop);
 		});
 	}
-	async onTaskUpdate(packs) {
-		if (this.clients.size === 0) {
-			return;
-		}
+	async onTestCaseAnnotate(testCase, annotation) {
+		if (this.clients.size === 0) return;
+		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 (isPrimitive(error)) return;
 				if (isBrowser) {
 					const project = this.ctx.getProjectByName(task.file.projectName || "");
 					error.stacks = project.browser?.parseErrorStacktrace(error);
-				} else {
-					error.stacks = parseErrorStacktrace(error);
-				}
+				} else error.stacks = parseErrorStacktrace(error);
 			});
 		});
 		this.clients.forEach((client) => {
-			client.onTaskUpdate?.(packs)?.catch?.(noop);
+			client.onTaskUpdate?.(packs, events)?.catch?.(noop);
 		});
 	}
 	onFinished(files, errors) {
@@ -5258,8 +5248,8 @@ var setup$1 = /*#__PURE__*/Object.freeze({
 });
 
 class BrowserSessions {
-	sessions = new Map();
-	sessionIds = new Set();
+	sessions = /* @__PURE__ */ new Map();
+	sessionIds = /* @__PURE__ */ new Set();
 	getSession(sessionId) {
 		return this.sessions.get(sessionId);
 	}
@@ -5267,6 +5257,7 @@ class BrowserSessions {
 		this.sessions.delete(sessionId);
 	}
 	createSession(sessionId, project, pool) {
+		// this promise only waits for the WS connection with the orhcestrator to be established
 		const defer = createDefer();
 		const timeout = setTimeout(() => {
 			defer.reject(new Error(`Failed to connect to the browser session "${sessionId}" [${project.name}] within the timeout.`));
@@ -5287,6 +5278,116 @@ class BrowserSessions {
 	}
 }
 
+class FilesStatsCache {
+	cache = /* @__PURE__ */ new Map();
+	getStats(key) {
+		return this.cache.get(key);
+	}
+	async populateStats(root, specs) {
+		const promises = specs.map((spec) => {
+			const key = `${spec[0].name}:${relative(root, spec.moduleId)}`;
+			return this.updateStats(spec.moduleId, key);
+		});
+		await Promise.all(promises);
+	}
+	async updateStats(fsPath, key) {
+		if (!fs.existsSync(fsPath)) return;
+		const stats = await fs.promises.stat(fsPath);
+		this.cache.set(key, { size: stats.size });
+	}
+	removeStats(fsPath) {
+		this.cache.forEach((_, key) => {
+			if (key.endsWith(fsPath)) this.cache.delete(key);
+		});
+	}
+}
+
+class ResultsCache {
+	cache = /* @__PURE__ */ new Map();
+	workspacesKeyMap = /* @__PURE__ */ new Map();
+	cachePath = null;
+	version;
+	root = "/";
+	constructor(version) {
+		this.version = version;
+	}
+	getCachePath() {
+		return this.cachePath;
+	}
+	setConfig(root, config) {
+		this.root = root;
+		if (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(".");
+		// 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);
+			});
+		}
+	}
+	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);
+			this.cache.set(`${file.projectName || ""}:${relativePath}`, {
+				duration: duration >= 0 ? duration : 0,
+				failed: result.state === "fail"
+			});
+		});
+	}
+	removeFromCache(filepath) {
+		this.cache.forEach((_, key) => {
+			if (key.endsWith(filepath)) this.cache.delete(key);
+		});
+	}
+	async writeToCache() {
+		if (!this.cachePath) return;
+		const results = Array.from(this.cache.entries());
+		const cacheDirname = dirname(this.cachePath);
+		if (!fs.existsSync(cacheDirname)) await fs.promises.mkdir(cacheDirname, { recursive: true });
+		const cache = JSON.stringify({
+			version: this.version,
+			results
+		});
+		await fs.promises.writeFile(this.cachePath, cache);
+	}
+}
+
+class VitestCache {
+	results;
+	stats = new FilesStatsCache();
+	constructor(version) {
+		this.results = new ResultsCache(version);
+	}
+	getFileTestResults(key) {
+		return this.results.getResults(key);
+	}
+	getFileStats(key) {
+		return this.stats.getStats(key);
+	}
+	static resolveCacheDir(root, dir, projectName) {
+		const baseDir = slash(dir || "node_modules/.vite");
+		return resolve(root, baseDir, "vitest", hash("md5", projectName || "", "hex"));
+	}
+}
+
 class FilesNotFoundError extends Error {
 	code = "VITEST_FILES_NOT_FOUND";
 	constructor(mode) {
@@ -5302,7 +5403,7 @@ class GitNotFoundError extends Error {
 class LocationFilterFileNotFoundError extends Error {
 	code = "VITEST_LOCATION_FILTER_FILE_NOT_FOUND";
 	constructor(filename) {
-		super(`Couldn\'t find file ${filename}. Note when specifying the test ` + "location you have to specify the full test filename.");
+		super(`Couldn\'t find file ${filename}. Note when specifying the test location you have to specify the full test filename.`);
 	}
 }
 class IncludeTaskLocationDisabledError extends Error {
@@ -5314,7 +5415,7 @@ class IncludeTaskLocationDisabledError extends Error {
 class RangeLocationFilterProvidedError extends Error {
 	code = "VITEST_RANGE_LOCATION_FILTER_PROVIDED";
 	constructor(filter) {
-		super(`Found "-" in location filter ${filter}.  Note that range location filters ` + `are not supported.  Consider specifying the exact line numbers of your tests.`);
+		super(`Found "-" in location filter ${filter}.  Note that range location filters are not supported.  Consider specifying the exact line numbers of your tests.`);
 	}
 }
 class VitestFilteredOutProjectError extends Error {
@@ -5334,9 +5435,7 @@ const HIGHLIGHT_SUPPORTED_EXTS = new Set(["js", "ts"].flatMap((lang) => [
 ]));
 function highlightCode(id, source, colors) {
 	const ext = extname(id);
-	if (!HIGHLIGHT_SUPPORTED_EXTS.has(ext)) {
-		return source;
-	}
+	if (!HIGHLIGHT_SUPPORTED_EXTS.has(ext)) return source;
 	const isJsx = ext.endsWith("x");
 	return highlight(source, {
 		jsx: isJsx,
@@ -5354,7 +5453,7 @@ const SHOW_CURSOR = `${ESC$1}?25h`;
 const CLEAR_SCREEN = "\x1Bc";
 class Logger {
 	_clearScreenPending;
-	_highlights = new Map();
+	_highlights = /* @__PURE__ */ new Map();
 	cleanupListeners = [];
 	console;
 	constructor(ctx, outputStream = process.stdout, errorStream = process.stderr) {
@@ -5368,9 +5467,7 @@ class Logger {
 		this._highlights.clear();
 		this.addCleanupListeners();
 		this.registerUnhandledRejection();
-		if (this.outputStream.isTTY) {
-			this.outputStream.write(HIDE_CURSOR);
-		}
+		if (this.outputStream.isTTY) this.outputStream.write(HIDE_CURSOR);
 	}
 	log(...args) {
 		this._clearScreen();
@@ -5389,11 +5486,8 @@ class Logger {
 			this.console.log(message);
 			return;
 		}
-		if (message) {
-			this.console.log(`${CLEAR_SCREEN}${ERASE_SCROLLBACK}${message}`);
-		} else {
-			this.outputStream.write(`${CLEAR_SCREEN}${ERASE_SCROLLBACK}`);
-		}
+		if (message) this.console.log(`${CLEAR_SCREEN}${ERASE_SCROLLBACK}${message}`);
+		else this.outputStream.write(`${CLEAR_SCREEN}${ERASE_SCROLLBACK}`);
 	}
 	clearScreen(message, force = false) {
 		if (!this.ctx.config.clearScreen) {
@@ -5401,72 +5495,46 @@ class Logger {
 			return;
 		}
 		this._clearScreenPending = message;
-		if (force) {
-			this._clearScreen();
-		}
+		if (force) this._clearScreen();
 	}
 	_clearScreen() {
-		if (this._clearScreenPending == null) {
-			return;
-		}
+		if (this._clearScreenPending == null) return;
 		const log = this._clearScreenPending;
-		this._clearScreenPending = undefined;
+		this._clearScreenPending = void 0;
 		this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`);
 	}
 	printError(err, options = {}) {
 		printError(err, this.ctx, this, options);
 	}
 	deprecate(message) {
-		this.log(c.bold(c.bgYellow(" DEPRECATED ")), c.yellow(message));
+		this.error(c.bold(c.bgYellow(" DEPRECATED ")), c.yellow(message));
 	}
 	clearHighlightCache(filename) {
-		if (filename) {
-			this._highlights.delete(filename);
-		} else {
-			this._highlights.clear();
-		}
+		if (filename) this._highlights.delete(filename);
+		else this._highlights.clear();
 	}
 	highlight(filename, source) {
-		if (this._highlights.has(filename)) {
-			return this._highlights.get(filename);
-		}
+		if (this._highlights.has(filename)) return this._highlights.get(filename);
 		const code = highlightCode(filename, source);
 		this._highlights.set(filename, code);
 		return code;
 	}
 	printNoTestFound(filters) {
 		const config = this.ctx.config;
-		if (config.watch && (config.changed || config.related?.length)) {
-			this.log(`No affected ${config.mode} files found\n`);
-		} else if (config.watch) {
-			this.log(c.red(`No ${config.mode} files found. You can change the file name pattern by pressing "p"\n`));
-		} else {
-			if (config.passWithNoTests) {
-				this.log(`No ${config.mode} files found, exiting with code 0\n`);
-			} else {
-				this.error(c.red(`No ${config.mode} files found, exiting with code 1\n`));
-			}
-		}
+		if (config.watch && (config.changed || config.related?.length)) this.log(`No affected ${config.mode} files found\n`);
+		else if (config.watch) this.log(c.red(`No ${config.mode} files found. You can change the file name pattern by pressing "p"\n`));
+		else if (config.passWithNoTests) this.log(`No ${config.mode} files found, exiting with code 0\n`);
+		else this.error(c.red(`No ${config.mode} files found, exiting with code 1\n`));
 		const comma = c.dim(", ");
-		if (filters?.length) {
-			this.console.error(c.dim("filter: ") + c.yellow(filters.join(comma)));
-		}
+		if (filters?.length) this.console.error(c.dim("filter: ") + c.yellow(filters.join(comma)));
 		const projectsFilter = toArray(config.project);
-		if (projectsFilter.length) {
-			this.console.error(c.dim("projects: ") + c.yellow(projectsFilter.join(comma)));
-		}
+		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;
-			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 (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)));
@@ -5479,9 +5547,7 @@ class Logger {
 		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}"`));
-		}
+		if (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;
@@ -5489,35 +5555,28 @@ class Logger {
 			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;
 			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));
-		}
-		if (this.ctx.config.standalone) {
-			this.log(c.yellow(`\nVitest is running in standalone mode. Edit a test file to rerun tests.`));
-		} else {
-			this.log();
-		}
+		if (this.ctx.coverageProvider) this.log(PAD + c.dim("Coverage enabled with ") + c.yellow(this.ctx.coverageProvider.name));
+		if (this.ctx.config.standalone) this.log(c.yellow(`\nVitest is running in standalone mode. Edit a test file to rerun tests.`));
+		else this.log();
 	}
 	printBrowserBanner(project) {
-		if (!project.browser) {
-			return;
-		}
+		if (!project.browser) return;
 		const resolvedUrls = project.browser.vite.resolvedUrls;
 		const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
-		if (!origin) {
-			return;
-		}
+		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))}`;
 		this.log(c.dim(`${output}Browser runner started${providerString} ${c.dim("at")} ${c.blue(new URL("/", origin))}\n`));
 	}
 	printUnhandledErrors(errors) {
-		const errorMessage = c.red(c.bold(`\nVitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} during the test run.` + "\nThis might cause false positive tests. Resolve unhandled errors to make sure your tests are not affected."));
+		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) => {
@@ -5546,15 +5605,13 @@ class Logger {
 	addCleanupListeners() {
 		const cleanup = () => {
 			this.cleanupListeners.forEach((fn) => fn());
-			if (this.outputStream.isTTY) {
-				this.outputStream.write(SHOW_CURSOR);
-			}
+			if (this.outputStream.isTTY) this.outputStream.write(SHOW_CURSOR);
 		};
 		const onExit = (signal, exitCode) => {
 			cleanup();
-			if (process.exitCode === undefined) {
-				process.exitCode = exitCode !== undefined ? 128 + exitCode : Number(signal);
-			}
+			// 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);
 			process.exit();
 		};
 		process.once("SIGINT", onExit);
@@ -5590,9 +5647,7 @@ class VitestPackageInstaller {
 		return isPackageExists(name, options);
 	}
 	async ensureInstalled(dependency, root, version) {
-		if (process.env.VITEST_SKIP_INSTALL_CHECKS) {
-			return true;
-		}
+		if (process.env.VITEST_SKIP_INSTALL_CHECKS) return true;
 		if (process.versions.pnp) {
 			const targetRequire = createRequire(__dirname);
 			try {
@@ -5600,13 +5655,9 @@ class VitestPackageInstaller {
 				return true;
 			} catch {}
 		}
-		if (/* @__PURE__ */ isPackageExists(dependency, { paths: [root, __dirname] })) {
-			return true;
-		}
+		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;
-		}
+		if (!isTTY) return false;
 		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; });
 		const { install } = await prompts.default({
 			type: "confirm",
@@ -5615,7 +5666,8 @@ class VitestPackageInstaller {
 		});
 		if (install) {
 			const packageName = version ? `${dependency}@${version}` : dependency;
-			await (await import('./index.CK1YOQaa.js')).installPackage(packageName, { dev: true });
+			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;
@@ -5627,6 +5679,7 @@ class VitestPackageInstaller {
 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;
 	return {
 		environmentOptions: config.environmentOptions,
@@ -5667,8 +5720,8 @@ function serializeConfig(config, coreConfig, viteConfig) {
 				reportsDirectory: coverage.reportsDirectory,
 				provider: coverage.provider,
 				enabled: coverage.enabled,
-				htmlReporter: htmlReporter ? { subdir } : undefined,
-				customProviderModule: "customProviderModule" in coverage ? coverage.customProviderModule : undefined
+				htmlReporter: htmlReporter ? { subdir } : void 0,
+				customProviderModule: "customProviderModule" in coverage ? coverage.customProviderModule : void 0
 			};
 		})(config.coverage),
 		fakeTimers: config.fakeTimers,
@@ -5694,11 +5747,11 @@ function serializeConfig(config, coreConfig, viteConfig) {
 			moduleDirectories: config.deps.moduleDirectories
 		},
 		snapshotOptions: {
-			snapshotEnvironment: undefined,
+			snapshotEnvironment: void 0,
 			updateSnapshot: coreConfig.snapshotOptions.updateSnapshot,
 			snapshotFormat: {
 				...coreConfig.snapshotOptions.snapshotFormat,
-				compareKeys: undefined
+				compareKeys: void 0
 			},
 			expand: config.snapshotOptions.expand ?? coreConfig.snapshotOptions.expand
 		},
@@ -5747,25 +5800,17 @@ async function loadGlobalSetupFile(file, runner) {
 		"default",
 		"setup",
 		"teardown"
-	]) {
-		if (m[exp] != null && typeof m[exp] !== "function") {
-			throw new Error(`invalid export in globalSetup file ${file}: ${exp} must be a function`);
-		}
-	}
-	if (m.default) {
-		return {
-			file,
-			setup: m.default
-		};
-	} else 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`);
-	}
+	]) if (m[exp] != null && typeof m[exp] !== "function") throw new Error(`invalid export in globalSetup file ${file}: ${exp} must be a function`);
+	if (m.default) return {
+		file,
+		setup: m.default
+	};
+	else 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`);
 }
 
 function CoverageTransform(ctx) {
@@ -5781,12 +5826,8 @@ function MocksPlugins(options = {}) {
 	const normalizedDistDir = normalize(distDir);
 	return [hoistMocksPlugin({
 		filter(id) {
-			if (id.includes(normalizedDistDir)) {
-				return false;
-			}
-			if (options.filter) {
-				return options.filter(id);
-			}
+			if (id.includes(normalizedDistDir)) return false;
+			if (options.filter) return options.filter(id);
 			return true;
 		},
 		codeFrameGenerator(node, id, code) {
@@ -5799,12 +5840,9 @@ function generateCssFilenameHash(filepath) {
 	return hash("md5", filepath, "hex").slice(0, 6);
 }
 function generateScopedClassName(strategy, name, filename) {
-	if (strategy === "scoped") {
-		return null;
-	}
-	if (strategy === "non-scoped") {
-		return name;
-	}
+	// should be configured by Vite defaults
+	if (strategy === "scoped") return null;
+	if (strategy === "non-scoped") return name;
 	const hash = generateCssFilenameHash(filename);
 	return `_${name}_${hash}`;
 }
@@ -5823,17 +5861,23 @@ function clearScreen(logger) {
 let lastType;
 let lastMsg;
 let sameCount = 0;
+// Only initialize the timeFormatter when the timestamp option is used, and
+// reuse it across all loggers
 let timeFormatter;
 function getTimeFormatter() {
-	timeFormatter ??= new Intl.DateTimeFormat(undefined, {
+	timeFormatter ??= new Intl.DateTimeFormat(void 0, {
 		hour: "numeric",
 		minute: "numeric",
 		second: "numeric"
 	});
 	return timeFormatter;
 }
+// This is copy-pasted and needs to be synced from time to time. Ideally, Vite's `createLogger` should accept a custom `console`
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/logger.ts?rgh-link-date=2024-10-16T23%3A29%3A19Z
+// When Vitest supports only Vite 6 and above, we can use Vite's `createLogger({ console })`
+// https://github.com/vitejs/vite/pull/18379
 function createViteLogger(console, level = "info", options = {}) {
-	const loggedErrors = new WeakSet();
+	const loggedErrors = /* @__PURE__ */ new WeakSet();
 	const { prefix = "[vite]", allowClearScreen = true } = options;
 	const thresh = LogLevels[level];
 	const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
@@ -5841,45 +5885,32 @@ function createViteLogger(console, level = "info", options = {}) {
 	function format(type, msg, options = {}) {
 		if (options.timestamp) {
 			let tag = "";
-			if (type === "info") {
-				tag = c.cyan(c.bold(prefix));
-			} else if (type === "warn") {
-				tag = c.yellow(c.bold(prefix));
-			} else {
-				tag = c.red(c.bold(prefix));
-			}
+			if (type === "info") tag = c.cyan(c.bold(prefix));
+			else if (type === "warn") tag = c.yellow(c.bold(prefix));
+			else tag = c.red(c.bold(prefix));
 			const environment = options.environment ? `${options.environment} ` : "";
-			return `${c.dim(getTimeFormatter().format(new Date()))} ${tag} ${environment}${msg}`;
-		} else {
-			return msg;
-		}
+			return `${c.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${environment}${msg}`;
+		} else return msg;
 	}
 	function output(type, msg, options = {}) {
 		if (thresh >= LogLevels[type]) {
 			const method = type === "info" ? "log" : type;
-			if (options.error) {
-				loggedErrors.add(options.error);
-			}
-			if (canClearScreen) {
-				if (type === lastType && msg === lastMsg) {
-					sameCount++;
-					clear(console);
-					console[method](format(type, msg, options), c.yellow(`(x${sameCount + 1})`));
-				} else {
-					sameCount = 0;
-					lastMsg = msg;
-					lastType = type;
-					if (options.clear) {
-						clear(console);
-					}
-					console[method](format(type, msg, options));
-				}
+			if (options.error) loggedErrors.add(options.error);
+			if (canClearScreen) if (type === lastType && msg === lastMsg) {
+				sameCount++;
+				clear(console);
+				console[method](format(type, msg, options), c.yellow(`(x${sameCount + 1})`));
 			} else {
+				sameCount = 0;
+				lastMsg = msg;
+				lastType = type;
+				if (options.clear) clear(console);
 				console[method](format(type, msg, options));
 			}
+			else console[method](format(type, msg, options));
 		}
 	}
-	const warnedMessages = new Set();
+	const warnedMessages = /* @__PURE__ */ new Set();
 	const logger = {
 		hasWarned: false,
 		info(msg, opts) {
@@ -5890,9 +5921,7 @@ function createViteLogger(console, level = "info", options = {}) {
 			output("warn", msg, opts);
 		},
 		warnOnce(msg, opts) {
-			if (warnedMessages.has(msg)) {
-				return;
-			}
+			if (warnedMessages.has(msg)) return;
 			logger.hasWarned = true;
 			output("warn", msg, opts);
 			warnedMessages.add(msg);
@@ -5902,9 +5931,7 @@ function createViteLogger(console, level = "info", options = {}) {
 			output("error", msg, opts);
 		},
 		clearScreen(type) {
-			if (thresh >= LogLevels[type]) {
-				clear(console);
-			}
+			if (thresh >= LogLevels[type]) clear(console);
 		},
 		hasErrorLogged(error) {
 			return loggedErrors.has(error);
@@ -5912,13 +5939,12 @@ function createViteLogger(console, level = "info", options = {}) {
 	};
 	return logger;
 }
+// silence warning by Vite for statically not analyzable dynamic import
 function silenceImportViteIgnoreWarning(logger) {
 	return {
 		...logger,
 		warn(msg, options) {
-			if (msg.includes("The above dynamic import cannot be analyzed by Vite")) {
-				return;
-			}
+			if (msg.includes("The above dynamic import cannot be analyzed by Vite")) return;
 			logger.warn(msg, options);
 		}
 	};
@@ -5934,49 +5960,42 @@ function isCSS(id) {
 function isCSSModule(id) {
 	return cssModuleRE.test(id);
 }
+// inline css requests are expected to just return the
+// string content directly and not the proxy module
 function isInline(id) {
 	return cssInlineRE.test(id);
 }
 function getCSSModuleProxyReturn(strategy, filename) {
-	if (strategy === "non-scoped") {
-		return "style";
-	}
+	if (strategy === "non-scoped") return "style";
 	const hash = generateCssFilenameHash(filename);
 	return `\`_\${style}_${hash}\``;
 }
 function CSSEnablerPlugin(ctx) {
 	const shouldProcessCSS = (id) => {
 		const { css } = ctx.config;
-		if (typeof css === "boolean") {
-			return css;
-		}
-		if (toArray(css.exclude).some((re) => re.test(id))) {
-			return false;
-		}
-		if (toArray(css.include).some((re) => re.test(id))) {
-			return true;
-		}
+		if (typeof css === "boolean") return css;
+		if (toArray(css.exclude).some((re) => re.test(id))) return false;
+		if (toArray(css.include).some((re) => re.test(id))) return true;
 		return false;
 	};
 	return [{
 		name: "vitest:css-disable",
 		enforce: "pre",
 		transform(code, id) {
-			if (!isCSS(id)) {
-				return;
-			}
-			if (!shouldProcessCSS(id)) {
-				return { code: "" };
-			}
+			if (!isCSS(id)) return;
+			// css plugin inside Vite won't do anything if the code is empty
+			// but it will put __vite__updateStyle anyway
+			if (!shouldProcessCSS(id)) return { code: "" };
 		}
 	}, {
 		name: "vitest:css-empty-post",
 		enforce: "post",
 		transform(_, id) {
-			if (!isCSS(id) || shouldProcessCSS(id)) {
-				return;
-			}
+			if (!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), {
@@ -6475,21 +6494,24 @@ function stripLiteralDetailed(code, options) {
   return stripLiteralJsTokens(code);
 }
 
-const metaUrlLength = "import.meta.url".length;
+const metaUrlLength = 15;
 const locationString = "self.location".padEnd(metaUrlLength, " ");
+// Vite transforms new URL('./path', import.meta.url) to new URL('/path.js', import.meta.url)
+// This makes "href" equal to "http://localhost:3000/path.js" in the browser, but if we keep it like this,
+// then in tests the URL will become "file:///path.js".
+// To battle this, we replace "import.meta.url" with "self.location" in the code to keep the browser behavior.
 function NormalizeURLPlugin() {
 	return {
 		name: "vitest:normalize-url",
 		enforce: "post",
 		transform(code, id, options) {
 			const ssr = options?.ssr === true;
-			if (ssr || !code.includes("new URL") || !code.includes("import.meta.url")) {
-				return;
-			}
+			if (ssr || !code.includes("new URL") || !code.includes("import.meta.url")) return;
 			const cleanString = stripLiteral(code);
 			const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*(?:'[^']+'|"[^"]+"|`[^`]+`)\s*,\s*(?:'' \+ )?import\.meta\.url\s*(?:,\s*)?\)/g;
 			let updatedCode = code;
 			let match;
+			// eslint-disable-next-line no-cond-assign
 			while (match = assetImportMetaUrlRE.exec(cleanString)) {
 				const { 0: exp, index } = match;
 				const metaUrlIndex = index + exp.indexOf("import.meta.url");
@@ -6503,24 +6525,20 @@ function NormalizeURLPlugin() {
 	};
 }
 
-function resolveOptimizerConfig(_testOptions, viteOptions, testConfig, viteCacheDir) {
+function resolveOptimizerConfig(_testOptions, viteOptions) {
 	const testOptions = _testOptions || {};
 	const newConfig = {};
 	const [major, minor, fix] = version.split(".").map(Number);
 	const allowed = major >= 5 || major === 4 && minor >= 4 || major === 4 && minor === 3 && fix >= 2;
-	if (!allowed && testOptions?.enabled === true) {
-		console.warn(`Vitest: "deps.optimizer" is only available in Vite >= 4.3.2, current Vite version: ${version}`);
-	} else {
-		testOptions.enabled ??= false;
-	}
+	if (!allowed && testOptions?.enabled === true) console.warn(`Vitest: "deps.optimizer" is only available in Vite >= 4.3.2, current Vite version: ${version}`);
+	else testOptions.enabled ??= false;
 	if (!allowed || testOptions?.enabled !== true) {
-		newConfig.cacheDir = undefined;
+		newConfig.cacheDir = void 0;
 		newConfig.optimizeDeps = {
 			disabled: true,
 			entries: []
 		};
 	} else {
-		const root = testConfig.root ?? process.cwd();
 		const currentInclude = testOptions.include || viteOptions?.include || [];
 		const exclude = [
 			"vitest",
@@ -6531,8 +6549,6 @@ function resolveOptimizerConfig(_testOptions, viteOptions, testConfig, viteCache
 		const runtime = currentInclude.filter((n) => n.endsWith("jsx-dev-runtime") || n.endsWith("jsx-runtime"));
 		exclude.push(...runtime);
 		const include = (testOptions.include || viteOptions?.include || []).filter((n) => !exclude.includes(n));
-		const projectName = typeof testConfig.name === "string" ? testConfig.name : testConfig.name?.label;
-		newConfig.cacheDir = testConfig.cache !== false && testConfig.cache?.dir || VitestCache.resolveCacheDir(root, viteCacheDir, projectName);
 		newConfig.optimizeDeps = {
 			...viteOptions,
 			...testOptions,
@@ -6543,6 +6559,8 @@ function resolveOptimizerConfig(_testOptions, viteOptions, testConfig, viteCache
 			include
 		};
 	}
+	// `optimizeDeps.disabled` is deprecated since v5.1.0-beta.1
+	// https://github.com/vitejs/vite/pull/15184
 	if (major >= 5 && minor >= 1 || major >= 6) {
 		if (newConfig.optimizeDeps.disabled) {
 			newConfig.optimizeDeps.noDiscovery = true;
@@ -6566,14 +6584,16 @@ function deleteDefineConfig(viteConfig) {
 		try {
 			replacement = typeof val === "string" ? JSON.parse(val) : val;
 		} catch {
+			// probably means it contains reference to some variable,
+			// like this: "__VAR__": "process.env.VAR"
 			continue;
 		}
 		if (key.startsWith("import.meta.env.")) {
-			const envKey = key.slice("import.meta.env.".length);
+			const envKey = key.slice(16);
 			process.env[envKey] = replacement;
 			delete viteConfig.define[key];
 		} else if (key.startsWith("process.env.")) {
-			const envKey = key.slice("process.env.".length);
+			const envKey = key.slice(12);
 			process.env[envKey] = replacement;
 			delete viteConfig.define[key];
 		} else if (!key.includes(".")) {
@@ -6584,9 +6604,7 @@ function deleteDefineConfig(viteConfig) {
 	return defines;
 }
 function resolveFsAllow(projectRoot, rootConfigFile) {
-	if (!rootConfigFile) {
-		return [searchForWorkspaceRoot(projectRoot), rootDir];
-	}
+	if (!rootConfigFile) return [searchForWorkspaceRoot(projectRoot), rootDir];
 	return [
 		dirname(rootConfigFile),
 		searchForWorkspaceRoot(projectRoot),
@@ -6615,9 +6633,12 @@ function VitestOptimizer() {
 			order: "post",
 			handler(viteConfig) {
 				const testConfig = viteConfig.test || {};
-				const webOptimizer = resolveOptimizerConfig(testConfig.deps?.optimizer?.web, viteConfig.optimizeDeps, testConfig, viteConfig.cacheDir);
-				const ssrOptimizer = resolveOptimizerConfig(testConfig.deps?.optimizer?.ssr, viteConfig.ssr?.optimizeDeps, testConfig, viteConfig.cacheDir);
-				viteConfig.cacheDir = webOptimizer.cacheDir || ssrOptimizer.cacheDir || viteConfig.cacheDir;
+				const webOptimizer = resolveOptimizerConfig(testConfig.deps?.optimizer?.web, viteConfig.optimizeDeps);
+				const ssrOptimizer = resolveOptimizerConfig(testConfig.deps?.optimizer?.ssr, viteConfig.ssr?.optimizeDeps);
+				const root = resolve(viteConfig.root || process.cwd());
+				const name = viteConfig.test?.name;
+				const label = typeof name === "string" ? name : name?.label || "";
+				viteConfig.cacheDir = VitestCache.resolveCacheDir(resolve(root || process.cwd()), testConfig.cache != null && testConfig.cache !== false ? testConfig.cache.dir : viteConfig.cacheDir, label);
 				viteConfig.optimizeDeps = webOptimizer.optimizeDeps;
 				viteConfig.ssr ??= {};
 				viteConfig.ssr.optimizeDeps = ssrOptimizer.optimizeDeps;
@@ -6626,14 +6647,14 @@ function VitestOptimizer() {
 	};
 }
 
+// so people can reassign envs at runtime
+// import.meta.env.VITE_NAME = 'app' -> process.env.VITE_NAME = 'app'
 function SsrReplacerPlugin() {
 	return {
 		name: "vitest:ssr-replacer",
 		enforce: "pre",
 		transform(code, id) {
-			if (!/\bimport\.meta\.env\b/.test(code)) {
-				return null;
-			}
+			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);
@@ -6643,15 +6664,13 @@ function SsrReplacerPlugin() {
 				const endIndex = startIndex + env[0].length;
 				s.overwrite(startIndex, endIndex, "__vite_ssr_import_meta__.env");
 			}
-			if (s) {
-				return {
-					code: s.toString(),
-					map: s.generateMap({
-						hires: "boundary",
-						source: cleanUrl(id)
-					})
-				};
-			}
+			if (s) return {
+				code: s.toString(),
+				map: s.generateMap({
+					hires: "boundary",
+					source: cleanUrl(id)
+				})
+			};
 		}
 	};
 }
@@ -6662,7 +6681,9 @@ function VitestProjectResolver(ctx) {
 		enforce: "pre",
 		async resolveId(id, _, { ssr }) {
 			if (id === "vitest" || id.startsWith("@vitest/") || id.startsWith("vitest/")) {
-				const resolved = await ctx.server.pluginContainer.resolveId(id, undefined, {
+				// always redirect the request to the root vitest plugin since
+				// it will be the one used to run Vitest
+				const resolved = await ctx.server.pluginContainer.resolveId(id, void 0, {
 					skip: new Set([plugin]),
 					ssr
 				});
@@ -6677,12 +6698,10 @@ function VitestCoreResolver(ctx) {
 		name: "vitest:resolve-core",
 		enforce: "pre",
 		async resolveId(id) {
-			if (id === "vitest") {
-				return resolve(distDir, "index.js");
-			}
-			if (id.startsWith("@vitest/") || id.startsWith("vitest/")) {
-				return this.resolve(id, join(ctx.config.root, "index.html"), { skipSelf: true });
-			}
+			if (id === "vitest") return resolve(distDir, "index.js");
+			if (id.startsWith("@vitest/") || id.startsWith("vitest/"))
+ // ignore actual importer, we want it to be resolved relative to the root
+			return this.resolve(id, join(ctx.config.root, "index.html"), { skipSelf: true });
 		}
 	};
 }
@@ -6691,7 +6710,7 @@ function WorkspaceVitestPlugin(project, options) {
 	return [
 		{
 			name: "vitest:project",
-			enforce: "pre",
+			enforce: "post",
 			options() {
 				this.meta.watchMode = false;
 			},
@@ -6703,20 +6722,13 @@ function WorkspaceVitestPlugin(project, options) {
 					label: "",
 					...testConfig.name
 				};
-				if (!name) {
-					if (typeof options.workspacePath === "string") {
-						const dir = options.workspacePath.endsWith("/") ? options.workspacePath.slice(0, -1) : dirname(options.workspacePath);
-						const 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();
-					}
-				}
+				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");
+					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 resolveOptions = getDefaultResolveOptions();
 				const config = {
 					root,
@@ -6745,40 +6757,38 @@ function WorkspaceVitestPlugin(project, options) {
 						color
 					} }
 				};
-				if (project.vitest._options.browser && viteConfig.test?.browser) {
-					viteConfig.test.browser = mergeConfig(viteConfig.test.browser, project.vitest._options.browser);
-				}
 				config.test.defines = defines;
+				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];
-				if (viteConfig.test?.browser?.enabled) {
-					if (viteConfig.test.browser.name && !viteConfig.test.browser.instances?.length) {
-						const browser = viteConfig.test.browser.name;
-						workspaceNames.push(name ? `${name} (${browser})` : browser);
-					}
-					viteConfig.test.browser.instances?.forEach((instance) => {
-						instance.name ??= name ? `${name} (${instance.browser})` : instance.browser;
-						workspaceNames.push(instance.name);
-					});
-				}
+				const 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);
+				});
 				const filters = project.vitest.config.project;
+				// if there is `--project=...` filter, check if any of the potential projects match
+				// if projects don't match, we ignore the test project altogether
+				// if some of them match, they will later be filtered again by `resolveWorkspace`
 				if (filters.length) {
 					const hasProject = workspaceNames.some((name) => {
 						return project.vitest.matchesProjectFilter(name);
 					});
-					if (!hasProject) {
-						throw new VitestFilteredOutProjectError();
-					}
+					if (!hasProject) throw new VitestFilteredOutProjectError();
 				}
 				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) => {
-							const root = project.config.root;
-							return generateScopedClassName(classNameStrategy, name, relative(root, filename));
-						};
-					}
+					if (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);
@@ -6792,9 +6802,9 @@ function WorkspaceVitestPlugin(project, options) {
 		},
 		SsrReplacerPlugin(),
 		...CSSEnablerPlugin(project),
-		CoverageTransform(project.ctx),
+		CoverageTransform(project.vitest),
 		...MocksPlugins(),
-		VitestProjectResolver(project.ctx),
+		VitestProjectResolver(project.vitest),
 		VitestOptimizer(),
 		NormalizeURLPlugin()
 	];
@@ -6851,9 +6861,7 @@ class TestSpecification {
 	*/
 	get testModule() {
 		const task = this.project.vitest.state.idMap.get(this.taskId);
-		if (!task) {
-			return undefined;
-		}
+		if (!task) return void 0;
 		return this.project.vitest.state.getReportedEntity(task);
 	}
 	toJSON() {
@@ -6881,11 +6889,11 @@ class TestSpecification {
 }
 
 async function createViteServer(inlineConfig) {
+	// Vite prints an error (https://github.com/vitejs/vite/issues/14328)
+	// 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;
-		}
+		if (typeof args[0] === "string" && args[0].includes("WebSocket server error:")) return;
 		error(...args);
 	};
 	const server = await createServer(inlineConfig);
@@ -6937,11 +6945,11 @@ class TestProject {
 	* It is based on the root of the project (not consistent between OS) and its name.
 	*/
 	get hash() {
-		if (!this._hash) {
-			throw new Error("The server was not set. It means that `project.hash` was called before the Vite server was established.");
-		}
+		if (!this._hash) throw new Error("The server was not set. It means that `project.hash` was called before the Vite server was established.");
 		return this._hash;
 	}
+	// "provide" is a property, not a method to keep the context when destructed in the global setup,
+	// making it a method would be a breaking change, and can be done in Vitest 3 at minimum
 	/**
 	* Provide a value to the test context. This value will be available to all tests with `inject`.
 	*/
@@ -6951,15 +6959,16 @@ class TestProject {
 		} catch (err) {
 			throw new Error(`Cannot provide "${key}" because it's not serializable.`, { cause: err });
 		}
+		// casting `any` because the default type is `never` since `ProvidedContext` is empty
 		this._provided[key] = value;
 	};
 	/**
 	* Get the provided context. The project context is merged with the global context.
 	*/
 	getProvidedContext() {
-		if (this.isRootProject()) {
-			return this._provided;
-		}
+		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 {
 			...this.vitest.getRootProject().getProvidedContext(),
 			...this._provided
@@ -6983,9 +6992,8 @@ class TestProject {
 	* Vite's dev server instance. Every workspace project has its own server.
 	*/
 	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.");
-		}
+		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", {
 			configurable: true,
 			writable: true,
@@ -6997,9 +7005,13 @@ class TestProject {
 	* Resolved project configuration.
 	*/
 	get config() {
-		if (!this._config) {
-			throw new Error("The config was not set. It means that `project.config` was called before the Vite server was established.");
-		}
+		if (!this._config) throw new Error("The config was not set. It means that `project.config` was called before the Vite server was established.");
+		// checking it once should be enough
+		// Object.defineProperty(this, 'config', {
+		//   configurable: true,
+		//   writable: true,
+		//   value: this._config,
+		// })
 		return this._config;
 	}
 	/**
@@ -7044,18 +7056,12 @@ class TestProject {
 	}
 	/** @internal */
 	async _initializeGlobalSetup() {
-		if (this._globalSetups) {
-			return;
-		}
+		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`);
-			}
+			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;
 		}
 	}
@@ -7068,21 +7074,18 @@ class TestProject {
 	}
 	/** @internal */
 	async _teardownGlobalSetup() {
-		if (!this._globalSetups) {
-			return;
-		}
-		for (const globalSetupFile of [...this._globalSetups].reverse()) {
-			await globalSetupFile.teardown?.();
-		}
+		if (!this._globalSetups) return;
+		for (const globalSetupFile of [...this._globalSetups].reverse()) await globalSetupFile.teardown?.();
 	}
 	/** @deprecated use `vitest.logger` instead */
 	get logger() {
 		return this.vitest.logger;
 	}
+	// it's possible that file path was imported with different queries (?raw, ?url, etc)
 	/** @deprecated use `.vite` or `.browser.vite` directly */
 	getModulesByFilepath(file) {
 		const set = this.server.moduleGraph.getModulesByFile(file) || this.browser?.vite.moduleGraph.getModulesByFile(file);
-		return set || new Set();
+		return set || /* @__PURE__ */ new Set();
 	}
 	/** @deprecated use `.vite` or `.browser.vite` directly */
 	getModuleById(id) {
@@ -7113,18 +7116,14 @@ class TestProject {
 		};
 	}
 	async globAllTestFiles(include, exclude, includeSource, cwd) {
-		if (this.testFilesList) {
-			return this.testFilesList;
-		}
+		if (this.testFilesList) return this.testFilesList;
 		const testFiles = await this.globFiles(include, exclude, cwd);
 		if (includeSource?.length) {
 			const files = await this.globFiles(includeSource, exclude, cwd);
 			await Promise.all(files.map(async (file) => {
 				try {
 					const code = await promises.readFile(file, "utf-8");
-					if (this.isInSourceTestCode(code)) {
-						testFiles.push(file);
-					}
+					if (this.isInSourceTestCode(code)) testFiles.push(file);
 				} catch {
 					return null;
 				}
@@ -7141,9 +7140,7 @@ class TestProject {
 	}
 	/** @internal */
 	_removeCachedTestFile(testPath) {
-		if (this.testFilesList) {
-			this.testFilesList = this.testFilesList.filter((file) => file !== testPath);
-		}
+		if (this.testFilesList) this.testFilesList = this.testFilesList.filter((file) => file !== testPath);
 	}
 	/**
 	* Returns if the file is a test file. Requires `.globTestFiles()` to be called first.
@@ -7172,19 +7169,18 @@ class TestProject {
 			expandDirectories: false
 		};
 		const 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
 		return files.map((file) => slash(path.resolve(cwd, file)));
 	}
 	/**
 	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
 	*/
 	matchesTestGlob(moduleId, source) {
-		if (this._isCachedTestFile(moduleId)) {
-			return true;
-		}
+		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.exclude)) return false;
 		if (pm.isMatch(relativeId, this.config.include)) {
 			this.markTestFile(moduleId);
 			return true;
@@ -7200,27 +7196,22 @@ class TestProject {
 	}
 	/** @deprecated use `matchesTestGlob` instead */
 	async isTargetFile(id, source) {
-		return this.matchesTestGlob(id, source ? () => source : undefined);
+		return this.matchesTestGlob(id, source ? () => source : void 0);
 	}
 	isInSourceTestCode(code) {
 		return code.includes("import.meta.vitest");
 	}
 	filterFiles(testFiles, filters, dir) {
-		if (filters.length && process.platform === "win32") {
-			filters = filters.map((f) => slash(f));
-		}
-		if (filters.length) {
-			return testFiles.filter((t) => {
-				const testFile = relative(dir, t).toLocaleLowerCase();
-				return filters.some((f) => {
-					if (isAbsolute(f) && t.startsWith(f)) {
-						return true;
-					}
-					const relativePath = f.endsWith("/") ? join(relative(dir, f), "/") : relative(dir, f);
-					return testFile.includes(f.toLocaleLowerCase()) || testFile.includes(relativePath.toLocaleLowerCase());
-				});
+		if (filters.length && process.platform === "win32") filters = filters.map((f) => slash(f));
+		if (filters.length) return 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
+				if (isAbsolute(f) && t.startsWith(f)) return true;
+				const relativePath = f.endsWith("/") ? join(relative(dir, f), "/") : relative(dir, f);
+				return testFile.includes(f.toLocaleLowerCase()) || testFile.includes(relativePath.toLocaleLowerCase());
 			});
-		}
+		});
 		return testFiles;
 	}
 	_parentBrowser;
@@ -7228,9 +7219,7 @@ class TestProject {
 	_parent;
 	/** @internal */
 	_initParentBrowser = deduped(async () => {
-		if (!this.isBrowserEnabled() || this._parentBrowser) {
-			return;
-		}
+		if (!this.isBrowserEnabled() || this._parentBrowser) return;
 		await this.vitest.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.vitest.version);
 		const { createBrowserServer, distRoot } = await import('@vitest/browser');
 		let cacheDir;
@@ -7240,15 +7229,11 @@ class TestProject {
 				cacheDir = config.cacheDir;
 			}
 		}, ...MocksPlugins({ filter(id) {
-			if (id.includes(distRoot) || id.includes(cacheDir)) {
-				return false;
-			}
+			if (id.includes(distRoot) || id.includes(cacheDir)) return false;
 			return true;
 		} })], [CoverageTransform(this.vitest)]);
 		this._parentBrowser = browser;
-		if (this.config.browser.ui) {
-			setup(this.vitest, browser.vite);
-		}
+		if (this.config.browser.ui) setup(this.vitest, browser.vite);
 	});
 	/** @internal */
 	_initBrowserServer = deduped(async () => {
@@ -7263,17 +7248,15 @@ class TestProject {
 	* If the resources are needed again, create a new project.
 	*/
 	close() {
-		if (!this.closingPromise) {
-			this.closingPromise = Promise.all([
-				this.vite?.close(),
-				this.typechecker?.stop(),
-				this.browser?.close(),
-				this.clearTmpDir()
-			].filter(Boolean)).then(() => {
-				this._provided = {};
-				this._vite = undefined;
-			});
-		}
+		if (!this.closingPromise) this.closingPromise = Promise.all([
+			this.vite?.close(),
+			this.typechecker?.stop(),
+			this.browser?.close(),
+			this.clearTmpDir()
+		].filter(Boolean)).then(() => {
+			this._provided = {};
+			this._vite = void 0;
+		});
 		return this.closingPromise;
 	}
 	/**
@@ -7303,9 +7286,10 @@ class TestProject {
 		this._setHash();
 		for (const _providedKey in 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 = undefined;
+		this.closingPromise = void 0;
 		this._vite = server;
 		this.vitenode = new ViteNodeServer(server, this.config.server);
 		const node = this.vitenode;
@@ -7321,10 +7305,9 @@ class TestProject {
 		});
 	}
 	_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;
-		}
+		if (!this.vitest.configOverride) return config;
 		return deepMerge(config, this.vitest.configOverride);
 	}
 	async clearTmpDir() {
@@ -7338,18 +7321,15 @@ class TestProject {
 	}
 	/** @internal */
 	_initBrowserProvider = deduped(async () => {
-		if (!this.isBrowserEnabled() || this.browser?.provider) {
-			return;
-		}
-		if (!this.browser) {
-			await this._initBrowserServer();
-		}
+		if (!this.isBrowserEnabled() || this.browser?.provider) return;
+		if (!this.browser) await this._initBrowserServer();
 		await this.browser?.initBrowserProvider(this);
 	});
 	/** @internal */
 	_provideObject(context) {
 		for (const _providedKey in context) {
 			const providedKey = _providedKey;
+			// type is very strict here, so we cast it to any
 			this.provide(providedKey, context[providedKey]);
 		}
 	}
@@ -7380,11 +7360,9 @@ class TestProject {
 function deduped(cb) {
 	let _promise;
 	return (...args) => {
-		if (!_promise) {
-			_promise = cb(...args).finally(() => {
-				_promise = undefined;
-			});
-		}
+		if (!_promise) _promise = cb(...args).finally(() => {
+			_promise = void 0;
+		});
 		return _promise;
 	};
 }
@@ -7406,9 +7384,7 @@ async function initializeProject(workspacePath, ctx, options) {
 }
 function generateHash(str) {
 	let hash = 0;
-	if (str.length === 0) {
-		return `${hash}`;
-	}
+	if (str.length === 0) return `${hash}`;
 	for (let i = 0; i < str.length; i++) {
 		const char = str.charCodeAt(i);
 		hash = (hash << 5) - hash + char;
@@ -7419,6 +7395,8 @@ function generateHash(str) {
 
 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 = [
 		"logHeapUsage",
 		"allowOnly",
@@ -7440,9 +7418,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		"fileParallelism"
 	];
 	const cliOverrides = overridesOptions.reduce((acc, name) => {
-		if (name in cliOptions) {
-			acc[name] = cliOptions[name];
-		}
+		if (name in cliOptions) acc[name] = cliOptions[name];
 		return acc;
 	}, {});
 	const projectPromises = [];
@@ -7450,7 +7426,10 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 	const concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
 	projectConfigs.forEach((options, index) => {
 		const configRoot = workspaceConfigPath ? dirname(workspaceConfigPath) : vitest.config.root;
+		// if extends a config file, resolve the file path
 		const configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : options.extends === true ? vitest.vite.config.configFile || false : false;
+		// if `root` is configured, resolve it relative to the workspace file or vite root (like other options)
+		// if `root` is not specified, inline configs use the same root as the root project
 		const root = options.root ? resolve(configRoot, options.root) : vitest.config.root;
 		projectPromises.push(concurrent(() => initializeProject(index, vitest, {
 			...options,
@@ -7463,11 +7442,10 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		})));
 	});
 	for (const path of fileProjects) {
+		// if file leads to the root config, then we can just reuse it because we already initialized it
 		if (vitest.vite.config.configFile === path) {
 			const project = getDefaultTestProject(vitest);
-			if (project) {
-				projectPromises.push(Promise.resolve(project));
-			}
+			if (project) projectPromises.push(Promise.resolve(project));
 			continue;
 		}
 		const configFile = path.endsWith("/") ? false : path;
@@ -7478,29 +7456,23 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 			test: cliOverrides
 		})));
 	}
-	if (!projectPromises.length) {
-		throw new Error([
-			"No projects were found. Make sure your configuration is correct. ",
-			vitest.config.project.length ? `The filter matched no projects: ${vitest.config.project.join(", ")}. ` : "",
-			`The projects definition: ${JSON.stringify(projectsDefinition, null, 4)}.`
-		].join(""));
-	}
+	// pretty rare case - the glob didn't match anything and there are no inline configs
+	if (!projectPromises.length) throw new Error([
+		"No projects were found. Make sure your configuration is correct. ",
+		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 = [];
-	for (const result of resolvedProjectsPromises) {
-		if (result.status === "rejected") {
-			if (result.reason instanceof VitestFilteredOutProjectError) {
-				continue;
-			}
-			errors.push(result.reason);
-		} else {
-			resolvedProjects.push(result.value);
-		}
-	}
-	if (errors.length) {
-		throw new AggregateError(errors, "Failed to initialize projects. There were errors during projects setup. See below for more details.");
-	}
+	for (const result of resolvedProjectsPromises) if (result.status === "rejected") {
+		if (result.reason instanceof VitestFilteredOutProjectError)
+ // filter out filtered out projects
+		continue;
+		errors.push(result.reason);
+	} else resolvedProjects.push(result.value);
+	if (errors.length) throw new AggregateError(errors, "Failed to initialize projects. There were errors during projects setup. See below for more details.");
+	// project names are guaranteed to be unique
 	for (const project of resolvedProjects) {
 		const name = project.name;
 		if (names.has(name)) {
@@ -7524,11 +7496,9 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 	return resolveBrowserProjects(vitest, names, resolvedProjects);
 }
 async function resolveBrowserProjects(vitest, names, resolvedProjects) {
-	const removeProjects = new Set();
+	const removeProjects = /* @__PURE__ */ new Set();
 	resolvedProjects.forEach((project) => {
-		if (!project.config.browser.enabled) {
-			return;
-		}
+		if (!project.config.browser.enabled) return;
 		const instances = project.config.browser.instances || [];
 		const browser = project.config.browser.name;
 		if (instances.length === 0 && browser) {
@@ -7545,17 +7515,17 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			].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 newName = instance.name;
 			return vitest.matchesProjectFilter(newName);
 		});
+		// every project was filtered out
 		if (!filteredInstances.length) {
 			removeProjects.add(project);
 			return;
 		}
-		if (project.config.browser.providerOptions) {
-			vitest.logger.warn(withLabel("yellow", "Vitest", `"providerOptions"${originalName ? ` in "${originalName}" project` : ""} is ignored because it's overridden by the configs. To hide this warning, remove the "providerOptions" property from the browser configuration.`));
-		}
+		if (project.config.browser.providerOptions) vitest.logger.warn(withLabel("yellow", "Vitest", `"providerOptions"${originalName ? ` in "${originalName}" project` : ""} is ignored because it's overridden by the configs. To hide this warning, remove the "providerOptions" property from the browser configuration.`));
 		filteredInstances.forEach((config, index) => {
 			const browser = config.browser;
 			if (!browser) {
@@ -7564,16 +7534,12 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 				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;
-			if (name == null) {
-				throw new Error(`The browser configuration must have a "name" property. This is a bug in Vitest. Please, open a new issue with reproduction`);
-			}
-			if (names.has(name)) {
-				throw new Error([
-					`Cannot define a nested project for a ${browser} browser. The project name "${name}" was already defined. `,
-					"If you have multiple instances for the same browser, make sure to define a custom \"name\". ",
-					"All projects should have unique names. Make sure your configuration is correct."
-				].join(""));
-			}
+			if (name == null) throw new Error(`The browser configuration must have a "name" property. This is a bug in Vitest. Please, open a new issue with reproduction`);
+			if (names.has(name)) throw new Error([
+				`Cannot define a nested project for a ${browser} browser. The project name "${name}" was already defined. `,
+				"If you have multiple instances for the same browser, make sure to define a custom \"name\". ",
+				"All projects should have unique names. Make sure your configuration is correct."
+			].join(""));
 			names.add(name);
 			const clonedConfig = cloneConfig(project, config);
 			clonedConfig.name = name;
@@ -7588,9 +7554,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	});
 	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.`);
-		}
+		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({
 			type: "select",
@@ -7601,9 +7565,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			})),
 			message: `${message} Select a single project to run or cancel and run tests with "headless: true" option. Note that you can also start tests with --browser=name or --project=name flag.`
 		});
-		if (!projectName) {
-			throw new Error("The test run was aborted.");
-		}
+		if (!projectName) throw new Error("The test run was aborted.");
 		return resolvedProjects.filter((project) => project.name === projectName);
 	}
 	return resolvedProjects;
@@ -7623,53 +7585,51 @@ function cloneConfig(project, { browser,...config }) {
 			headless: headless ?? currentConfig.headless,
 			name: browser,
 			providerOptions: config,
-			instances: undefined
+			instances: void 0
 		}
 	}, 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 = [];
-	for (const definition of projectsDefinition) {
-		if (typeof definition === "string") {
-			const stringOption = definition.replace("<rootDir>", vitest.config.root);
-			if (!isDynamicPattern(stringOption)) {
-				const file = resolve(vitest.config.root, stringOption);
-				if (!existsSync(file)) {
-					const relativeWorkspaceConfigPath = workspaceConfigPath ? relative(vitest.config.root, workspaceConfigPath) : undefined;
-					const note = workspaceConfigPath ? `Workspace config file "${relativeWorkspaceConfigPath}"` : "Projects definition";
-					throw new Error(`${note} references a non-existing file or a directory: ${file}`);
-				}
-				const stats = await promises.stat(file);
-				if (stats.isFile()) {
-					projectsConfigFiles.push(file);
-				} else if (stats.isDirectory()) {
-					const configFile = await resolveDirectoryConfig(file);
-					if (configFile) {
-						projectsConfigFiles.push(configFile);
-					} else {
-						const directory = file[file.length - 1] === "/" ? file : `${file}/`;
-						nonConfigProjectDirectories.push(directory);
-					}
-				} else {
-					throw new TypeError(`Unexpected file type: ${file}`);
-				}
-			} else {
-				projectsGlobMatches.push(stringOption);
+	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
+		// ['./vitest.config.js']
+		if (!isDynamicPattern(stringOption)) {
+			const file = resolve(vitest.config.root, stringOption);
+			if (!existsSync(file)) {
+				const relativeWorkspaceConfigPath = workspaceConfigPath ? relative(vitest.config.root, workspaceConfigPath) : void 0;
+				const note = workspaceConfigPath ? `Workspace config file "${relativeWorkspaceConfigPath}"` : "Projects definition";
+				throw new Error(`${note} references a non-existing file or a directory: ${file}`);
 			}
-		} else if (typeof definition === "function") {
-			projectsOptions.push(await definition({
-				command: vitest.vite.config.command,
-				mode: vitest.vite.config.mode,
-				isPreview: false,
-				isSsrBuild: false
-			}));
-		} else {
-			projectsOptions.push(await definition);
-		}
-	}
+			const stats = await promises.stat(file);
+			// user can specify a config file directly
+			if (stats.isFile()) projectsConfigFiles.push(file);
+			else if (stats.isDirectory()) {
+				const configFile = await resolveDirectoryConfig(file);
+				if (configFile) projectsConfigFiles.push(configFile);
+				else {
+					const directory = file[file.length - 1] === "/" ? file : `${file}/`;
+					nonConfigProjectDirectories.push(directory);
+				}
+			} else
+ // should never happen
+			throw new TypeError(`Unexpected file type: ${file}`);
+		} else projectsGlobMatches.push(stringOption);
+	} else if (typeof definition === "function") projectsOptions.push(await definition({
+		command: vitest.vite.config.command,
+		mode: vitest.vite.config.mode,
+		isPreview: false,
+		isSsrBuild: false
+	}));
+	else projectsOptions.push(await definition);
 	if (projectsGlobMatches.length) {
 		const globOptions = {
 			absolute: true,
@@ -7685,16 +7645,13 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 		};
 		const 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
 			if (path.endsWith("/")) {
 				const configFile = await resolveDirectoryConfig(path);
-				if (configFile) {
-					projectsConfigFiles.push(configFile);
-				} else {
-					nonConfigProjectDirectories.push(path);
-				}
-			} else {
-				projectsConfigFiles.push(path);
-			}
+				if (configFile) projectsConfigFiles.push(configFile);
+				else nonConfigProjectDirectories.push(path);
+			} else projectsConfigFiles.push(path);
 		}));
 	}
 	const projectConfigFiles = Array.from(new Set(projectsConfigFiles));
@@ -7706,31 +7663,25 @@ 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);
-	}
+	if (configFile) return resolve(directory, configFile);
 	return null;
 }
 function getDefaultTestProject(vitest) {
 	const filter = vitest.config.project;
 	const project = vitest._ensureRootProject();
-	if (!filter.length) {
-		return project;
-	}
+	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;
-	}
+	if (hasProjects) return project;
 	return null;
 }
 function getPotentialProjectNames(project) {
 	const names = [project.name];
-	if (project.config.browser.instances) {
-		names.push(...project.config.browser.instances.map((i) => i.name));
-	} else if (project.config.browser.name) {
-		names.push(project.config.browser.name);
-	}
+	if (project.config.browser.instances) names.push(...project.config.browser.instances.map((i) => i.name));
+	else if (project.config.browser.name) names.push(project.config.browser.name);
 	return names;
 }
 
@@ -7741,9 +7692,7 @@ async function loadCustomReporterModule(path, runner) {
 	} catch (customReporterModuleError) {
 		throw new Error(`Failed to load custom Reporter from ${path}`, { cause: customReporterModuleError });
 	}
-	if (customReporterModule.default === null || customReporterModule.default === undefined) {
-		throw new Error(`Custom reporter loaded from ${path} was not the default export`);
-	}
+	if (customReporterModule.default === null || customReporterModule.default === void 0) throw new Error(`Custom reporter loaded from ${path} was not the default export`);
 	return customReporterModule.default;
 }
 function createReporters(reporterReferences, ctx) {
@@ -7769,14 +7718,12 @@ function createReporters(reporterReferences, ctx) {
 }
 function createBenchmarkReporters(reporterReferences, runner) {
 	const promisedReporters = reporterReferences.map(async (referenceOrInstance) => {
-		if (typeof referenceOrInstance === "string") {
-			if (referenceOrInstance in BenchmarkReportsMap) {
-				const BuiltinReporter = BenchmarkReportsMap[referenceOrInstance];
-				return new BuiltinReporter();
-			} else {
-				const CustomReporter = await loadCustomReporterModule(referenceOrInstance, runner);
-				return new CustomReporter();
-			}
+		if (typeof referenceOrInstance === "string") if (referenceOrInstance in BenchmarkReportsMap) {
+			const BuiltinReporter = BenchmarkReportsMap[referenceOrInstance];
+			return new BuiltinReporter();
+		} else {
+			const CustomReporter = await loadCustomReporterModule(referenceOrInstance, runner);
+			return new CustomReporter();
 		}
 		return referenceOrInstance;
 	});
@@ -7785,49 +7732,37 @@ function createBenchmarkReporters(reporterReferences, runner) {
 
 function parseFilter(filter) {
 	const colonIndex = filter.lastIndexOf(":");
-	if (colonIndex === -1) {
-		return { filename: filter };
-	}
+	if (colonIndex === -1) return { filename: filter };
 	const [parsedFilename, lineNumber] = [filter.substring(0, colonIndex), filter.substring(colonIndex + 1)];
-	if (lineNumber.match(/^\d+$/)) {
-		return {
-			filename: parsedFilename,
-			lineNumber: Number.parseInt(lineNumber)
-		};
-	} else if (lineNumber.match(/^\d+-\d+$/)) {
-		throw new RangeLocationFilterProvidedError(filter);
-	} else {
-		return { filename: filter };
-	}
+	if (lineNumber.match(/^\d+$/)) return {
+		filename: parsedFilename,
+		lineNumber: Number.parseInt(lineNumber)
+	};
+	else if (lineNumber.match(/^\d+-\d+$/)) throw new RangeLocationFilterProvidedError(filter);
+	else 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);
-		return [filename, testLocations.filter((l) => l !== undefined)];
+		return [filename, testLocations.filter((l) => l !== void 0)];
 	}));
 	return groupedFilters;
 }
 
 class VitestSpecifications {
-	_cachedSpecs = new Map();
+	_cachedSpecs = /* @__PURE__ */ new Map();
 	constructor(vitest) {
 		this.vitest = vitest;
 	}
 	getModuleSpecifications(moduleId) {
 		const _cached = this.getCachedSpecifications(moduleId);
-		if (_cached) {
-			return _cached;
-		}
+		if (_cached) return _cached;
 		const specs = [];
 		for (const project of this.vitest.projects) {
-			if (project._isCachedTestFile(moduleId)) {
-				specs.push(project.createSpecification(moduleId));
-			}
-			if (project._isCachedTypecheckFile(moduleId)) {
-				specs.push(project.createSpecification(moduleId, [], "typescript"));
-			}
+			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;
@@ -7839,13 +7774,13 @@ class VitestSpecifications {
 		const files = [];
 		const dir = process.cwd();
 		const parsedFilters = filters.map((f) => parseFilter(f));
-		if (!this.vitest.config.includeTaskLocation && parsedFilters.some((f) => f.lineNumber !== undefined)) {
-			throw new IncludeTaskLocationDisabledError();
-		}
+		// 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) => {
 			const { testFiles, typecheckTestFiles } = await project.globTestFiles(parsedFilters.map((f) => f.filename));
@@ -7865,18 +7800,13 @@ class VitestSpecifications {
 			});
 		}));
 		Object.entries(testLines).forEach(([filepath, loc]) => {
-			if (loc.length !== 0 && !testLocHasMatch[filepath]) {
-				throw new LocationFilterFileNotFoundError(relative(dir, filepath));
-			}
+			if (loc.length !== 0 && !testLocHasMatch[filepath]) throw new LocationFilterFileNotFoundError(relative(dir, filepath));
 		});
 		return files;
 	}
 	clearCache(moduleId) {
-		if (moduleId) {
-			this._cachedSpecs.delete(moduleId);
-		} else {
-			this._cachedSpecs.clear();
-		}
+		if (moduleId) this._cachedSpecs.delete(moduleId);
+		else this._cachedSpecs.clear();
 	}
 	getCachedSpecifications(moduleId) {
 		return this._cachedSpecs.get(moduleId);
@@ -7888,14 +7818,12 @@ class VitestSpecifications {
 		if (index === -1) {
 			specs.push(spec);
 			this._cachedSpecs.set(file, specs);
-		} else {
-			specs.splice(index, 1, spec);
-		}
+		} 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.DXfdBEfR.js');
+			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) {
@@ -7905,46 +7833,34 @@ class VitestSpecifications {
 			this.vitest.config.related = Array.from(new Set(related));
 		}
 		const related = this.vitest.config.related;
-		if (!related) {
-			return specs;
-		}
+		if (!related) return specs;
 		const forceRerunTriggers = this.vitest.config.forceRerunTriggers;
-		const matcher = forceRerunTriggers.length ? pm(forceRerunTriggers) : undefined;
-		if (matcher && related.some((file) => matcher(file))) {
-			return specs;
-		}
-		if (!this.vitest.config.watch && !related.length) {
-			return [];
-		}
+		const 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
+		if (!this.vitest.config.watch && !related.length) return [];
 		const testGraphs = await Promise.all(specs.map(async (spec) => {
 			const deps = await this.getTestDependencies(spec);
 			return [spec, deps];
 		}));
 		const runningTests = [];
-		for (const [specification, deps] of testGraphs) {
-			if (related.some((path) => path === specification.moduleId || deps.has(path))) {
-				runningTests.push(specification);
-			}
-		}
+		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);
 		return runningTests;
 	}
-	async getTestDependencies(spec, deps = new Set()) {
+	async getTestDependencies(spec, deps = /* @__PURE__ */ new Set()) {
 		const addImports = async (project, filepath) => {
-			if (deps.has(filepath)) {
-				return;
-			}
+			if (deps.has(filepath)) return;
 			deps.add(filepath);
 			const mod = project.vite.moduleGraph.getModuleById(filepath);
 			const transformed = mod?.ssrTransformResult || await project.vitenode.transformRequest(filepath);
-			if (!transformed) {
-				return;
-			}
+			if (!transformed) return;
 			const dependencies = [...transformed.deps || [], ...transformed.dynamicDeps || []];
 			await Promise.all(dependencies.map(async (dep) => {
 				const fsPath = dep.startsWith("/@fs/") ? dep.slice(isWindows ? 5 : 4) : join(project.config.root, dep);
-				if (!fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) {
-					await addImports(project, fsPath);
-				}
+				if (!fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) await addImports(project, fsPath);
 			}));
 		};
 		await addImports(spec.project, spec.moduleId);
@@ -8029,24 +7945,16 @@ class TestCase extends ReportedTaskImplementation {
 		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;
-		}
+		if (suite) this.parent = getReportedTask(project, suite);
+		else this.parent = this.module;
 		this.options = buildOptions(task);
 	}
 	/**
 	* Full name of the test including all parent suites separated with `>`.
 	*/
 	get fullName() {
-		if (this.#fullName === undefined) {
-			if (this.parent.type !== "module") {
-				this.#fullName = `${this.parent.fullName} > ${this.name}`;
-			} else {
-				this.#fullName = this.name;
-			}
-		}
+		if (this.#fullName === void 0) if (this.parent.type !== "module") this.#fullName = `${this.parent.fullName} > ${this.name}`;
+		else this.#fullName = this.name;
 		return this.#fullName;
 	}
 	/**
@@ -8059,47 +7967,44 @@ class TestCase extends ReportedTaskImplementation {
 	result() {
 		const result = this.task.result;
 		const mode = result?.state || this.task.mode;
-		if (!result && (mode === "skip" || mode === "todo")) {
-			return {
-				state: "skipped",
-				note: undefined,
-				errors: undefined
-			};
-		}
-		if (!result || result.state === "run" || result.state === "queued") {
-			return {
-				state: "pending",
-				errors: undefined
-			};
-		}
+		if (!result && (mode === "skip" || mode === "todo")) return {
+			state: "skipped",
+			note: void 0,
+			errors: void 0
+		};
+		if (!result || result.state === "run" || result.state === "queued") return {
+			state: "pending",
+			errors: void 0
+		};
 		const state = result.state === "fail" ? "failed" : result.state === "pass" ? "passed" : "skipped";
-		if (state === "skipped") {
-			return {
-				state,
-				note: result.note,
-				errors: undefined
-			};
-		}
-		if (state === "passed") {
-			return {
-				state,
-				errors: result.errors
-			};
-		}
+		if (state === "skipped") return {
+			state,
+			note: result.note,
+			errors: void 0
+		};
+		if (state === "passed") return {
+			state,
+			errors: result.errors
+		};
 		return {
 			state,
 			errors: result.errors || []
 		};
 	}
 	/**
+	* Test annotations added via the `task.annotate` API during the test execution.
+	*/
+	annotations() {
+		return [...this.task.annotations];
+	}
+	/**
 	* Useful information about the test like duration, memory usage, etc.
 	* Diagnostic is only available after the test has finished.
 	*/
 	diagnostic() {
 		const result = this.task.result;
-		if (!result || !result.startTime) {
-			return undefined;
-		}
+		// 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;
 		return {
@@ -8124,9 +8029,7 @@ class TestCollection {
 	* Returns the test or suite at a specific index.
 	*/
 	at(index) {
-		if (index < 0) {
-			index = this.size + index;
-		}
+		if (index < 0) index = this.size + index;
 		return getReportedTask(this.#project, this.#task.tasks[index]);
 	}
 	/**
@@ -8145,62 +8048,41 @@ class TestCollection {
 	* Filters all tests that are part of this collection and its children.
 	*/
 	*allTests(state) {
-		for (const child of this) {
-			if (child.type === "suite") {
-				yield* child.children.allTests(state);
-			} else if (state) {
-				const testState = child.result().state;
-				if (state === testState) {
-					yield child;
-				}
-			} else {
-				yield child;
-			}
-		}
+		for (const child of this) if (child.type === "suite") yield* child.children.allTests(state);
+		else if (state) {
+			const testState = child.result().state;
+			if (state === testState) yield child;
+		} else yield child;
 	}
 	/**
 	* Filters only the tests that are part of this collection.
 	*/
 	*tests(state) {
 		for (const child of this) {
-			if (child.type !== "test") {
-				continue;
-			}
+			if (child.type !== "test") continue;
 			if (state) {
 				const testState = child.result().state;
-				if (state === testState) {
-					yield child;
-				}
-			} else {
-				yield child;
-			}
+				if (state === testState) yield child;
+			} else yield child;
 		}
 	}
 	/**
 	* Filters only the suites that are part of this collection.
 	*/
 	*suites() {
-		for (const child of this) {
-			if (child.type === "suite") {
-				yield child;
-			}
-		}
+		for (const child of this) if (child.type === "suite") yield child;
 	}
 	/**
 	* 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);
-		}
+		for (const task of this.#task.tasks) yield getReportedTask(this.#project, task);
 	}
 }
 class SuiteImplementation extends ReportedTaskImplementation {
@@ -8245,11 +8127,8 @@ class TestSuite extends SuiteImplementation {
 		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;
-		}
+		if (suite) this.parent = getReportedTask(project, suite);
+		else this.parent = this.module;
 		this.options = buildOptions(task);
 	}
 	/**
@@ -8262,13 +8141,8 @@ class TestSuite extends SuiteImplementation {
 	* Full name of the suite including all parent suites separated with `>`.
 	*/
 	get fullName() {
-		if (this.#fullName === undefined) {
-			if (this.parent.type !== "module") {
-				this.#fullName = `${this.parent.fullName} > ${this.name}`;
-			} else {
-				this.#fullName = this.name;
-			}
-		}
+		if (this.#fullName === void 0) if (this.parent.type !== "module") this.#fullName = `${this.parent.fullName} > ${this.name}`;
+		else this.#fullName = this.name;
 		return this.#fullName;
 	}
 }
@@ -8290,9 +8164,7 @@ class TestModule extends SuiteImplementation {
 	*/
 	state() {
 		const state = this.task.result?.state;
-		if (state === "queued") {
-			return "queued";
-		}
+		if (state === "queued") return "queued";
 		return getSuiteState(this.task);
 	}
 	/**
@@ -8306,13 +8178,15 @@ class TestModule extends SuiteImplementation {
 		const environmentSetupDuration = this.task.environmentLoad || 0;
 		const duration = this.task.result?.duration || 0;
 		const heap = this.task.result?.heap;
+		const importDurations = this.task.importDurations ?? {};
 		return {
 			environmentSetupDuration,
 			prepareDuration,
 			collectDuration,
 			setupDuration,
 			duration,
-			heap
+			heap,
+			importDurations
 		};
 	}
 }
@@ -8332,56 +8206,39 @@ function storeTask(project, runnerTask, reportedTask) {
 }
 function getReportedTask(project, runnerTask) {
 	const reportedTask = project.vitest.state.getReportedEntity(runnerTask);
-	if (!reportedTask) {
-		throw new Error(`Task instance was not found for ${runnerTask.type} "${runnerTask.name}"`);
-	}
+	if (!reportedTask) throw new Error(`Task instance was not found for ${runnerTask.type} "${runnerTask.name}"`);
 	return reportedTask;
 }
 function getSuiteState(task) {
 	const mode = task.mode;
 	const 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";
-	}
+	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 isAggregateError(err) {
-	if (typeof AggregateError !== "undefined" && err instanceof AggregateError) {
-		return true;
-	}
+	if (typeof AggregateError !== "undefined" && err instanceof AggregateError) return true;
 	return err instanceof Error && "errors" in err;
 }
 class StateManager {
-	filesMap = new Map();
-	pathsSet = new Set();
-	idMap = new Map();
-	taskFileMap = new WeakMap();
-	errorsSet = new Set();
-	processTimeoutCauses = new Set();
-	reportedTasksMap = new WeakMap();
+	filesMap = /* @__PURE__ */ new Map();
+	pathsSet = /* @__PURE__ */ new Set();
+	idMap = /* @__PURE__ */ new Map();
+	taskFileMap = /* @__PURE__ */ new WeakMap();
+	errorsSet = /* @__PURE__ */ new Set();
+	processTimeoutCauses = /* @__PURE__ */ new Set();
+	reportedTasksMap = /* @__PURE__ */ new WeakMap();
 	blobs;
 	catchError(err, type) {
-		if (isAggregateError(err)) {
-			return err.errors.forEach((error) => this.catchError(error, type));
-		}
-		if (err === Object(err)) {
-			err.type = type;
-		} else {
-			err = {
-				type,
-				message: err
-			};
-		}
+		if (isAggregateError(err)) return err.errors.forEach((error) => this.catchError(error, type));
+		if (err === Object(err)) err.type = type;
+		else err = {
+			type,
+			message: err
+		};
 		const _err = err;
 		if (_err && typeof _err === "object" && _err.code === "VITEST_PENDING") {
 			const task = this.idMap.get(_err.taskId);
@@ -8414,16 +8271,11 @@ 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);
-		}
+		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) => {
-			if (f1.meta?.typecheck && f2.meta?.typecheck) {
-				return 0;
-			}
-			if (f1.meta?.typecheck) {
-				return -1;
-			}
+			// print typecheck files first
+			if (f1.meta?.typecheck && f2.meta?.typecheck) return 0;
+			if (f1.meta?.typecheck) return -1;
 			return 1;
 		});
 	}
@@ -8446,9 +8298,9 @@ class StateManager {
 			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);
-			if (currentFile) {
-				file.logs = currentFile.logs;
-			}
+			// 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);
@@ -8466,30 +8318,20 @@ class StateManager {
 				return;
 			}
 			const filtered = files.filter((file) => file.projectName !== project.config.name);
-			if (!filtered.length) {
-				this.filesMap.set(path, [fileTask]);
-			} else {
-				this.filesMap.set(path, [...filtered, fileTask]);
-			}
+			// always keep a File task, so we can associate logs with it
+			if (!filtered.length) this.filesMap.set(path, [fileTask]);
+			else this.filesMap.set(path, [...filtered, fileTask]);
 		});
 	}
 	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);
-		}
+		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 (task.type === "suite") task.tasks.forEach((task) => {
+			this.updateId(task, project);
+		});
 	}
 	getReportedEntity(task) {
 		return this.reportedTasksMap.get(task);
@@ -8500,18 +8342,15 @@ class StateManager {
 			if (task) {
 				task.result = result;
 				task.meta = meta;
-				if (result?.state === "skip") {
-					task.mode = "skip";
-				}
+				// skipped with new PendingError
+				if (result?.state === "skip") task.mode = "skip";
 			}
 		}
 	}
 	updateUserLog(log) {
 		const task = log.taskId && this.idMap.get(log.taskId);
 		if (task) {
-			if (!task.logs) {
-				task.logs = [];
-			}
+			if (!task.logs) task.logs = [];
 			task.logs.push(log);
 		}
 	}
@@ -8523,6 +8362,458 @@ class StateManager {
 	}
 }
 
+const types = {
+    'application/andrew-inset': ['ez'],
+    'application/appinstaller': ['appinstaller'],
+    'application/applixware': ['aw'],
+    'application/appx': ['appx'],
+    'application/appxbundle': ['appxbundle'],
+    'application/atom+xml': ['atom'],
+    'application/atomcat+xml': ['atomcat'],
+    'application/atomdeleted+xml': ['atomdeleted'],
+    'application/atomsvc+xml': ['atomsvc'],
+    'application/atsc-dwd+xml': ['dwd'],
+    'application/atsc-held+xml': ['held'],
+    'application/atsc-rsat+xml': ['rsat'],
+    'application/automationml-aml+xml': ['aml'],
+    'application/automationml-amlx+zip': ['amlx'],
+    'application/bdoc': ['bdoc'],
+    'application/calendar+xml': ['xcs'],
+    'application/ccxml+xml': ['ccxml'],
+    'application/cdfx+xml': ['cdfx'],
+    'application/cdmi-capability': ['cdmia'],
+    'application/cdmi-container': ['cdmic'],
+    'application/cdmi-domain': ['cdmid'],
+    'application/cdmi-object': ['cdmio'],
+    'application/cdmi-queue': ['cdmiq'],
+    'application/cpl+xml': ['cpl'],
+    'application/cu-seeme': ['cu'],
+    'application/cwl': ['cwl'],
+    'application/dash+xml': ['mpd'],
+    'application/dash-patch+xml': ['mpp'],
+    'application/davmount+xml': ['davmount'],
+    'application/dicom': ['dcm'],
+    'application/docbook+xml': ['dbk'],
+    'application/dssc+der': ['dssc'],
+    'application/dssc+xml': ['xdssc'],
+    'application/ecmascript': ['ecma'],
+    'application/emma+xml': ['emma'],
+    'application/emotionml+xml': ['emotionml'],
+    'application/epub+zip': ['epub'],
+    'application/exi': ['exi'],
+    'application/express': ['exp'],
+    'application/fdf': ['fdf'],
+    'application/fdt+xml': ['fdt'],
+    'application/font-tdpfr': ['pfr'],
+    'application/geo+json': ['geojson'],
+    'application/gml+xml': ['gml'],
+    'application/gpx+xml': ['gpx'],
+    'application/gxf': ['gxf'],
+    'application/gzip': ['gz'],
+    'application/hjson': ['hjson'],
+    'application/hyperstudio': ['stk'],
+    'application/inkml+xml': ['ink', 'inkml'],
+    'application/ipfix': ['ipfix'],
+    'application/its+xml': ['its'],
+    'application/java-archive': ['jar', 'war', 'ear'],
+    'application/java-serialized-object': ['ser'],
+    'application/java-vm': ['class'],
+    'application/javascript': ['*js'],
+    'application/json': ['json', 'map'],
+    'application/json5': ['json5'],
+    'application/jsonml+json': ['jsonml'],
+    'application/ld+json': ['jsonld'],
+    'application/lgr+xml': ['lgr'],
+    'application/lost+xml': ['lostxml'],
+    'application/mac-binhex40': ['hqx'],
+    'application/mac-compactpro': ['cpt'],
+    'application/mads+xml': ['mads'],
+    'application/manifest+json': ['webmanifest'],
+    'application/marc': ['mrc'],
+    'application/marcxml+xml': ['mrcx'],
+    'application/mathematica': ['ma', 'nb', 'mb'],
+    'application/mathml+xml': ['mathml'],
+    'application/mbox': ['mbox'],
+    'application/media-policy-dataset+xml': ['mpf'],
+    'application/mediaservercontrol+xml': ['mscml'],
+    'application/metalink+xml': ['metalink'],
+    'application/metalink4+xml': ['meta4'],
+    'application/mets+xml': ['mets'],
+    'application/mmt-aei+xml': ['maei'],
+    'application/mmt-usd+xml': ['musd'],
+    'application/mods+xml': ['mods'],
+    'application/mp21': ['m21', 'mp21'],
+    'application/mp4': ['*mp4', '*mpg4', 'mp4s', 'm4p'],
+    'application/msix': ['msix'],
+    'application/msixbundle': ['msixbundle'],
+    'application/msword': ['doc', 'dot'],
+    'application/mxf': ['mxf'],
+    'application/n-quads': ['nq'],
+    'application/n-triples': ['nt'],
+    'application/node': ['cjs'],
+    'application/octet-stream': [
+        'bin',
+        'dms',
+        'lrf',
+        'mar',
+        'so',
+        'dist',
+        'distz',
+        'pkg',
+        'bpk',
+        'dump',
+        'elc',
+        'deploy',
+        'exe',
+        'dll',
+        'deb',
+        'dmg',
+        'iso',
+        'img',
+        'msi',
+        'msp',
+        'msm',
+        'buffer',
+    ],
+    'application/oda': ['oda'],
+    'application/oebps-package+xml': ['opf'],
+    'application/ogg': ['ogx'],
+    'application/omdoc+xml': ['omdoc'],
+    'application/onenote': [
+        'onetoc',
+        'onetoc2',
+        'onetmp',
+        'onepkg',
+        'one',
+        'onea',
+    ],
+    'application/oxps': ['oxps'],
+    'application/p2p-overlay+xml': ['relo'],
+    'application/patch-ops-error+xml': ['xer'],
+    'application/pdf': ['pdf'],
+    'application/pgp-encrypted': ['pgp'],
+    'application/pgp-keys': ['asc'],
+    'application/pgp-signature': ['sig', '*asc'],
+    'application/pics-rules': ['prf'],
+    'application/pkcs10': ['p10'],
+    'application/pkcs7-mime': ['p7m', 'p7c'],
+    'application/pkcs7-signature': ['p7s'],
+    'application/pkcs8': ['p8'],
+    'application/pkix-attr-cert': ['ac'],
+    'application/pkix-cert': ['cer'],
+    'application/pkix-crl': ['crl'],
+    'application/pkix-pkipath': ['pkipath'],
+    'application/pkixcmp': ['pki'],
+    'application/pls+xml': ['pls'],
+    'application/postscript': ['ai', 'eps', 'ps'],
+    'application/provenance+xml': ['provx'],
+    'application/pskc+xml': ['pskcxml'],
+    'application/raml+yaml': ['raml'],
+    'application/rdf+xml': ['rdf', 'owl'],
+    'application/reginfo+xml': ['rif'],
+    'application/relax-ng-compact-syntax': ['rnc'],
+    'application/resource-lists+xml': ['rl'],
+    'application/resource-lists-diff+xml': ['rld'],
+    'application/rls-services+xml': ['rs'],
+    'application/route-apd+xml': ['rapd'],
+    'application/route-s-tsid+xml': ['sls'],
+    'application/route-usd+xml': ['rusd'],
+    'application/rpki-ghostbusters': ['gbr'],
+    'application/rpki-manifest': ['mft'],
+    'application/rpki-roa': ['roa'],
+    'application/rsd+xml': ['rsd'],
+    'application/rss+xml': ['rss'],
+    'application/rtf': ['rtf'],
+    'application/sbml+xml': ['sbml'],
+    'application/scvp-cv-request': ['scq'],
+    'application/scvp-cv-response': ['scs'],
+    'application/scvp-vp-request': ['spq'],
+    'application/scvp-vp-response': ['spp'],
+    'application/sdp': ['sdp'],
+    'application/senml+xml': ['senmlx'],
+    'application/sensml+xml': ['sensmlx'],
+    'application/set-payment-initiation': ['setpay'],
+    'application/set-registration-initiation': ['setreg'],
+    'application/shf+xml': ['shf'],
+    'application/sieve': ['siv', 'sieve'],
+    'application/smil+xml': ['smi', 'smil'],
+    'application/sparql-query': ['rq'],
+    'application/sparql-results+xml': ['srx'],
+    'application/sql': ['sql'],
+    'application/srgs': ['gram'],
+    'application/srgs+xml': ['grxml'],
+    'application/sru+xml': ['sru'],
+    'application/ssdl+xml': ['ssdl'],
+    'application/ssml+xml': ['ssml'],
+    'application/swid+xml': ['swidtag'],
+    'application/tei+xml': ['tei', 'teicorpus'],
+    'application/thraud+xml': ['tfi'],
+    'application/timestamped-data': ['tsd'],
+    'application/toml': ['toml'],
+    'application/trig': ['trig'],
+    'application/ttml+xml': ['ttml'],
+    'application/ubjson': ['ubj'],
+    'application/urc-ressheet+xml': ['rsheet'],
+    'application/urc-targetdesc+xml': ['td'],
+    'application/voicexml+xml': ['vxml'],
+    'application/wasm': ['wasm'],
+    'application/watcherinfo+xml': ['wif'],
+    'application/widget': ['wgt'],
+    'application/winhlp': ['hlp'],
+    'application/wsdl+xml': ['wsdl'],
+    'application/wspolicy+xml': ['wspolicy'],
+    'application/xaml+xml': ['xaml'],
+    'application/xcap-att+xml': ['xav'],
+    'application/xcap-caps+xml': ['xca'],
+    'application/xcap-diff+xml': ['xdf'],
+    'application/xcap-el+xml': ['xel'],
+    'application/xcap-ns+xml': ['xns'],
+    'application/xenc+xml': ['xenc'],
+    'application/xfdf': ['xfdf'],
+    'application/xhtml+xml': ['xhtml', 'xht'],
+    'application/xliff+xml': ['xlf'],
+    'application/xml': ['xml', 'xsl', 'xsd', 'rng'],
+    'application/xml-dtd': ['dtd'],
+    'application/xop+xml': ['xop'],
+    'application/xproc+xml': ['xpl'],
+    'application/xslt+xml': ['*xsl', 'xslt'],
+    'application/xspf+xml': ['xspf'],
+    'application/xv+xml': ['mxml', 'xhvml', 'xvml', 'xvm'],
+    'application/yang': ['yang'],
+    'application/yin+xml': ['yin'],
+    'application/zip': ['zip'],
+    'application/zip+dotlottie': ['lottie'],
+    'audio/3gpp': ['*3gpp'],
+    'audio/aac': ['adts', 'aac'],
+    'audio/adpcm': ['adp'],
+    'audio/amr': ['amr'],
+    'audio/basic': ['au', 'snd'],
+    'audio/midi': ['mid', 'midi', 'kar', 'rmi'],
+    'audio/mobile-xmf': ['mxmf'],
+    'audio/mp3': ['*mp3'],
+    'audio/mp4': ['m4a', 'mp4a', 'm4b'],
+    'audio/mpeg': ['mpga', 'mp2', 'mp2a', 'mp3', 'm2a', 'm3a'],
+    'audio/ogg': ['oga', 'ogg', 'spx', 'opus'],
+    'audio/s3m': ['s3m'],
+    'audio/silk': ['sil'],
+    'audio/wav': ['wav'],
+    'audio/wave': ['*wav'],
+    'audio/webm': ['weba'],
+    'audio/xm': ['xm'],
+    'font/collection': ['ttc'],
+    'font/otf': ['otf'],
+    'font/ttf': ['ttf'],
+    'font/woff': ['woff'],
+    'font/woff2': ['woff2'],
+    'image/aces': ['exr'],
+    'image/apng': ['apng'],
+    'image/avci': ['avci'],
+    'image/avcs': ['avcs'],
+    'image/avif': ['avif'],
+    'image/bmp': ['bmp', 'dib'],
+    'image/cgm': ['cgm'],
+    'image/dicom-rle': ['drle'],
+    'image/dpx': ['dpx'],
+    'image/emf': ['emf'],
+    'image/fits': ['fits'],
+    'image/g3fax': ['g3'],
+    'image/gif': ['gif'],
+    'image/heic': ['heic'],
+    'image/heic-sequence': ['heics'],
+    'image/heif': ['heif'],
+    'image/heif-sequence': ['heifs'],
+    'image/hej2k': ['hej2'],
+    'image/ief': ['ief'],
+    'image/jaii': ['jaii'],
+    'image/jais': ['jais'],
+    'image/jls': ['jls'],
+    'image/jp2': ['jp2', 'jpg2'],
+    'image/jpeg': ['jpg', 'jpeg', 'jpe'],
+    'image/jph': ['jph'],
+    'image/jphc': ['jhc'],
+    'image/jpm': ['jpm', 'jpgm'],
+    'image/jpx': ['jpx', 'jpf'],
+    'image/jxl': ['jxl'],
+    'image/jxr': ['jxr'],
+    'image/jxra': ['jxra'],
+    'image/jxrs': ['jxrs'],
+    'image/jxs': ['jxs'],
+    'image/jxsc': ['jxsc'],
+    'image/jxsi': ['jxsi'],
+    'image/jxss': ['jxss'],
+    'image/ktx': ['ktx'],
+    'image/ktx2': ['ktx2'],
+    'image/pjpeg': ['jfif'],
+    'image/png': ['png'],
+    'image/sgi': ['sgi'],
+    'image/svg+xml': ['svg', 'svgz'],
+    'image/t38': ['t38'],
+    'image/tiff': ['tif', 'tiff'],
+    'image/tiff-fx': ['tfx'],
+    'image/webp': ['webp'],
+    'image/wmf': ['wmf'],
+    'message/disposition-notification': ['disposition-notification'],
+    'message/global': ['u8msg'],
+    'message/global-delivery-status': ['u8dsn'],
+    'message/global-disposition-notification': ['u8mdn'],
+    'message/global-headers': ['u8hdr'],
+    'message/rfc822': ['eml', 'mime', 'mht', 'mhtml'],
+    'model/3mf': ['3mf'],
+    'model/gltf+json': ['gltf'],
+    'model/gltf-binary': ['glb'],
+    'model/iges': ['igs', 'iges'],
+    'model/jt': ['jt'],
+    'model/mesh': ['msh', 'mesh', 'silo'],
+    'model/mtl': ['mtl'],
+    'model/obj': ['obj'],
+    'model/prc': ['prc'],
+    'model/step': ['step', 'stp', 'stpnc', 'p21', '210'],
+    'model/step+xml': ['stpx'],
+    'model/step+zip': ['stpz'],
+    'model/step-xml+zip': ['stpxz'],
+    'model/stl': ['stl'],
+    'model/u3d': ['u3d'],
+    'model/vrml': ['wrl', 'vrml'],
+    'model/x3d+binary': ['*x3db', 'x3dbz'],
+    'model/x3d+fastinfoset': ['x3db'],
+    'model/x3d+vrml': ['*x3dv', 'x3dvz'],
+    'model/x3d+xml': ['x3d', 'x3dz'],
+    'model/x3d-vrml': ['x3dv'],
+    'text/cache-manifest': ['appcache', 'manifest'],
+    'text/calendar': ['ics', 'ifb'],
+    'text/coffeescript': ['coffee', 'litcoffee'],
+    'text/css': ['css'],
+    'text/csv': ['csv'],
+    'text/html': ['html', 'htm', 'shtml'],
+    'text/jade': ['jade'],
+    'text/javascript': ['js', 'mjs'],
+    'text/jsx': ['jsx'],
+    'text/less': ['less'],
+    'text/markdown': ['md', 'markdown'],
+    'text/mathml': ['mml'],
+    'text/mdx': ['mdx'],
+    'text/n3': ['n3'],
+    'text/plain': ['txt', 'text', 'conf', 'def', 'list', 'log', 'in', 'ini'],
+    'text/richtext': ['rtx'],
+    'text/rtf': ['*rtf'],
+    'text/sgml': ['sgml', 'sgm'],
+    'text/shex': ['shex'],
+    'text/slim': ['slim', 'slm'],
+    'text/spdx': ['spdx'],
+    'text/stylus': ['stylus', 'styl'],
+    'text/tab-separated-values': ['tsv'],
+    'text/troff': ['t', 'tr', 'roff', 'man', 'me', 'ms'],
+    'text/turtle': ['ttl'],
+    'text/uri-list': ['uri', 'uris', 'urls'],
+    'text/vcard': ['vcard'],
+    'text/vtt': ['vtt'],
+    'text/wgsl': ['wgsl'],
+    'text/xml': ['*xml'],
+    'text/yaml': ['yaml', 'yml'],
+    'video/3gpp': ['3gp', '3gpp'],
+    'video/3gpp2': ['3g2'],
+    'video/h261': ['h261'],
+    'video/h263': ['h263'],
+    'video/h264': ['h264'],
+    'video/iso.segment': ['m4s'],
+    'video/jpeg': ['jpgv'],
+    'video/jpm': ['*jpm', '*jpgm'],
+    'video/mj2': ['mj2', 'mjp2'],
+    'video/mp2t': ['ts', 'm2t', 'm2ts', 'mts'],
+    'video/mp4': ['mp4', 'mp4v', 'mpg4'],
+    'video/mpeg': ['mpeg', 'mpg', 'mpe', 'm1v', 'm2v'],
+    'video/ogg': ['ogv'],
+    'video/quicktime': ['qt', 'mov'],
+    'video/webm': ['webm'],
+};
+Object.freeze(types);
+
+var __classPrivateFieldGet = ({} && {}.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Mime_extensionToType, _Mime_typeToExtension, _Mime_typeToExtensions;
+class Mime {
+    constructor(...args) {
+        _Mime_extensionToType.set(this, new Map());
+        _Mime_typeToExtension.set(this, new Map());
+        _Mime_typeToExtensions.set(this, new Map());
+        for (const arg of args) {
+            this.define(arg);
+        }
+    }
+    define(typeMap, force = false) {
+        for (let [type, extensions] of Object.entries(typeMap)) {
+            type = type.toLowerCase();
+            extensions = extensions.map((ext) => ext.toLowerCase());
+            if (!__classPrivateFieldGet(this, _Mime_typeToExtensions, "f").has(type)) {
+                __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").set(type, new Set());
+            }
+            const allExtensions = __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type);
+            let first = true;
+            for (let extension of extensions) {
+                const starred = extension.startsWith('*');
+                extension = starred ? extension.slice(1) : extension;
+                allExtensions?.add(extension);
+                if (first) {
+                    __classPrivateFieldGet(this, _Mime_typeToExtension, "f").set(type, extension);
+                }
+                first = false;
+                if (starred)
+                    continue;
+                const currentType = __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(extension);
+                if (currentType && currentType != type && !force) {
+                    throw new Error(`"${type} -> ${extension}" conflicts with "${currentType} -> ${extension}". Pass \`force=true\` to override this definition.`);
+                }
+                __classPrivateFieldGet(this, _Mime_extensionToType, "f").set(extension, type);
+            }
+        }
+        return this;
+    }
+    getType(path) {
+        if (typeof path !== 'string')
+            return null;
+        const last = path.replace(/^.*[/\\]/s, '').toLowerCase();
+        const ext = last.replace(/^.*\./s, '').toLowerCase();
+        const hasPath = last.length < path.length;
+        const hasDot = ext.length < last.length - 1;
+        if (!hasDot && hasPath)
+            return null;
+        return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
+    }
+    getExtension(type) {
+        if (typeof type !== 'string')
+            return null;
+        type = type?.split?.(';')[0];
+        return ((type && __classPrivateFieldGet(this, _Mime_typeToExtension, "f").get(type.trim().toLowerCase())) ?? null);
+    }
+    getAllExtensions(type) {
+        if (typeof type !== 'string')
+            return null;
+        return __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type.toLowerCase()) ?? null;
+    }
+    _freeze() {
+        this.define = () => {
+            throw new Error('define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances');
+        };
+        Object.freeze(this);
+        for (const extensions of __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").values()) {
+            Object.freeze(extensions);
+        }
+        return this;
+    }
+    _getTestState() {
+        return {
+            types: __classPrivateFieldGet(this, _Mime_extensionToType, "f"),
+            extensions: __classPrivateFieldGet(this, _Mime_typeToExtension, "f"),
+        };
+    }
+}
+_Mime_extensionToType = new WeakMap(), _Mime_typeToExtension = new WeakMap(), _Mime_typeToExtensions = new WeakMap();
+
+var mime = new Mime(types)._freeze();
+
 class TestRun {
 	constructor(vitest) {
 		this.vitest = vitest;
@@ -8550,55 +8841,61 @@ class TestRun {
 		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;
+	}
 	async updated(update, events) {
 		this.vitest.state.updateTasks(update);
-		await this.vitest.report("onTaskUpdate", update);
-		for (const [id, event] of events) {
-			await this.reportEvent(id, event).catch((error) => {
-				this.vitest.state.catchError(serializeError(error), "Unhandled Reporter Error");
-			});
-		}
+		for (const [id, event, data] of events) await this.reportEvent(id, event, data).catch((error) => {
+			this.vitest.state.catchError(serializeError(error), "Unhandled Reporter Error");
+		});
+		// TODO: what is the order or reports here?
+		// "onTaskUpdate" in parallel with others or before all or after all?
+		// TODO: error handling - what happens if custom reporter throws an error?
+		await this.vitest.report("onTaskUpdate", update, events);
 	}
 	async end(specifications, errors, 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" : process.exitCode ? "failed" : "passed";
+		const 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);
-			}
+			if (coverage) await this.vitest.report("onCoverage", coverage);
 		}
 	}
-	async reportEvent(id, event) {
+	hasFailed(modules) {
+		if (!modules.length) return !this.vitest.config.passWithNoTests;
+		return modules.some((m) => !m.ok());
+	}
+	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);
-		}
-		if (event === "suite-prepare" && entity.type === "module") {
-			return await this.vitest.report("onTestModuleStart", entity);
-		}
+		if (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") {
-				await this.reportChildren(entity.children);
-			}
-			if (entity.type === "module") {
-				await this.vitest.report("onTestModuleEnd", entity);
-			} else {
-				await this.vitest.report("onTestSuiteResult", entity);
-			}
+			if (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
+			await this.reportChildren(entity.children);
+			if (entity.type === "module") await this.vitest.report("onTestModuleEnd", entity);
+			else await this.vitest.report("onTestSuiteResult", entity);
 			return;
 		}
-		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 === "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" ? {
@@ -8608,36 +8905,58 @@ class TestRun {
 				name: isBefore ? "beforeAll" : "afterAll",
 				entity
 			};
-			if (event.endsWith("-start")) {
-				await this.vitest.report("onHookStart", hook);
-			} else {
-				await this.vitest.report("onHookEnd", hook);
+			if (event.endsWith("-start")) await this.vitest.report("onHookStart", hook);
+			else await this.vitest.report("onHookEnd", hook);
+			// 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);
 			}
 		}
 	}
+	async resolveTestAttachment(test, annotation) {
+		const project = test.project;
+		const 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 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) {
+	// eslint-disable-next-line no-control-regex
+	return s.replace(/[\x00-\x2C\x2E\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, "-");
+}
 
 class VitestWatcher {
 	/**
 	* Modules that will be invalidated on the next run.
 	*/
-	invalidates = new Set();
+	invalidates = /* @__PURE__ */ new Set();
 	/**
 	* Test files that have changed and need to be rerun.
 	*/
-	changedTests = new Set();
+	changedTests = /* @__PURE__ */ new Set();
 	_onRerun = [];
 	constructor(vitest) {
 		this.vitest = vitest;
@@ -8655,9 +8974,7 @@ class VitestWatcher {
 	unregisterWatcher = noop;
 	registerWatcher() {
 		const watcher = this.vitest.vite.watcher;
-		if (this.vitest.config.forceRerunTriggers.length) {
-			watcher.add(this.vitest.config.forceRerunTriggers);
-		}
+		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);
@@ -8673,9 +8990,7 @@ class VitestWatcher {
 		this._onRerun.forEach((cb) => cb(file));
 	}
 	getTestFilesFromWatcherTrigger(id) {
-		if (!this.vitest.config.watchTriggerPatterns) {
-			return false;
-		}
+		if (!this.vitest.config.watchTriggerPatterns) return false;
 		let triggered = false;
 		this.vitest.config.watchTriggerPatterns.forEach((definition) => {
 			const exec = definition.pattern.exec(id);
@@ -8697,13 +9012,10 @@ class VitestWatcher {
 		this.vitest.logger.clearHighlightCache(id);
 		this.vitest.invalidateFile(id);
 		const testFiles = this.getTestFilesFromWatcherTrigger(id);
-		if (testFiles) {
-			this.scheduleRerun(id);
-		} else {
+		if (testFiles) this.scheduleRerun(id);
+		else {
 			const needsRerun = this.handleFileChanged(id);
-			if (needsRerun) {
-				this.scheduleRerun(id);
-			}
+			if (needsRerun) this.scheduleRerun(id);
 		}
 	};
 	onUnlink = (id) => {
@@ -8730,27 +9042,22 @@ class VitestWatcher {
 		let fileContent;
 		const matchingProjects = [];
 		this.vitest.projects.forEach((project) => {
-			if (project.matchesTestGlob(id, () => fileContent ??= readFileSync(id, "utf-8"))) {
-				matchingProjects.push(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 {
+			// it's possible that file was already there but watcher triggered "add" event instead
 			const needsRerun = this.handleFileChanged(id);
-			if (needsRerun) {
-				this.scheduleRerun(id);
-			}
+			if (needsRerun) this.scheduleRerun(id);
 		}
 	};
 	/**
 	* @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 (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;
@@ -8760,6 +9067,8 @@ class VitestWatcher {
 			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;
@@ -8769,30 +9078,21 @@ class VitestWatcher {
 		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;
-			}
+			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);
 				continue;
 			}
 			let rerun = false;
-			for (const mod of mods) {
-				mod.importers.forEach((i) => {
-					if (!i.file) {
-						return;
-					}
-					const needsRerun = this.handleFileChanged(i.file);
-					if (needsRerun) {
-						rerun = true;
-					}
-				});
-			}
-			if (rerun) {
-				files.push(filepath);
-			}
+			for (const mod of mods) mod.importers.forEach((i) => {
+				if (!i.file) return;
+				const needsRerun = this.handleFileChanged(i.file);
+				if (needsRerun) rerun = true;
+			});
+			if (rerun) files.push(filepath);
 		}
 		return !!files.length;
 	}
@@ -8844,11 +9144,11 @@ class Vitest {
 	resolvedProjects = [];
 	/** @internal */ _browserLastPort = defaultBrowserPort;
 	/** @internal */ _browserSessions = new BrowserSessions();
-	/** @internal */ _options = {};
+	/** @internal */ _cliOptions = {};
 	/** @internal */ reporters = [];
-	/** @internal */ vitenode = undefined;
-	/** @internal */ runner = undefined;
-	/** @internal */ _testRun = undefined;
+	/** @internal */ vitenode = void 0;
+	/** @internal */ runner = void 0;
+	/** @internal */ _testRun = void 0;
 	isFirstRun = true;
 	restartsCount = 0;
 	specifications;
@@ -8860,8 +9160,9 @@ class Vitest {
 	_cache;
 	_snapshot;
 	_workspaceConfigPath;
-	constructor(mode, options = {}) {
+	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);
@@ -8922,25 +9223,24 @@ class Vitest {
 		return this._cache;
 	}
 	/** @deprecated internal */
-	setServer(options, server, cliOptions) {
-		return this._setServer(options, server, cliOptions);
+	setServer(options, server) {
+		return this._setServer(options, server);
 	}
 	/** @internal */
-	async _setServer(options, server, cliOptions) {
-		this._options = options;
+	async _setServer(options, server) {
 		this.watcher.unregisterWatcher();
 		clearTimeout(this._rerunTimer);
 		this.restartsCount += 1;
 		this._browserLastPort = defaultBrowserPort;
 		this.pool?.close?.();
-		this.pool = undefined;
-		this.closingPromise = undefined;
+		this.pool = void 0;
+		this.closingPromise = void 0;
 		this.projects = [];
 		this.resolvedProjects = [];
-		this._workspaceConfigPath = undefined;
-		this.coverageProvider = undefined;
-		this.runningPromise = undefined;
-		this.coreWorkspaceProject = undefined;
+		this._workspaceConfigPath = void 0;
+		this.coverageProvider = void 0;
+		this.runningPromise = void 0;
+		this.coreWorkspaceProject = void 0;
 		this.specifications.clearCache();
 		this._onUserTestsRerun = [];
 		this._vite = server;
@@ -8950,9 +9250,7 @@ class Vitest {
 		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.watch) this.watcher.registerWatcher();
 		this.vitenode = new ViteNodeServer(server, this.config.server);
 		const node = this.vitenode;
 		this.runner = new ViteNodeRunner({
@@ -8966,6 +9264,7 @@ class Vitest {
 			}
 		});
 		if (this.config.watch) {
+			// hijack server restart
 			const serverRestart = server.restart;
 			server.restart = async (...args) => {
 				await Promise.all(this._onRestartListeners.map((fn) => fn()));
@@ -8973,6 +9272,7 @@ class Vitest {
 				await this.close();
 				await serverRestart(...args);
 			};
+			// since we set `server.hmr: false`, Vite does not auto restart itself
 			server.watcher.on("change", async (file) => {
 				file = normalize(file);
 				const isConfig = file === server.config.configFile || this.projects.some((p) => p.vite.config.configFile === file) || file === this._workspaceConfigPath;
@@ -8988,7 +9288,7 @@ class Vitest {
 		try {
 			await this.cache.results.readFromCache();
 		} catch {}
-		const projects = await this.resolveProjects(cliOptions);
+		const projects = await this.resolveProjects(this._cliOptions);
 		this.resolvedProjects = projects;
 		this.projects = projects;
 		await Promise.all(projects.flatMap((project) => {
@@ -8999,26 +9299,17 @@ class Vitest {
 				injectTestProjects: this.injectTestProject
 			}));
 		}));
-		if (options.browser?.enabled) {
+		if (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 (!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.`);
-			}
-		}
-		if (!this.coreWorkspaceProject) {
-			this.coreWorkspaceProject = TestProject._createBasicProject(this);
-		}
-		if (this.config.testNamePattern) {
-			this.configOverride.testNamePattern = this.config.testNamePattern;
+			if (filter) throw new Error(`No projects matched the filter "${filter}".`);
+			else throw 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()));
 	}
@@ -9029,7 +9320,7 @@ class Vitest {
 	*/
 	injectTestProject = async (config) => {
 		const currentNames = new Set(this.projects.map((p) => p.name));
-		const projects = await resolveProjects(this, this._options, undefined, Array.isArray(config) ? config : [config], currentNames);
+		const projects = await resolveProjects(this, this._cliOptions, void 0, Array.isArray(config) ? config : [config], currentNames);
 		this.projects.push(...projects);
 		return projects;
 	};
@@ -9047,9 +9338,7 @@ class Vitest {
 	}
 	/** @internal */
 	_ensureRootProject() {
-		if (this.coreWorkspaceProject) {
-			return this.coreWorkspaceProject;
-		}
+		if (this.coreWorkspaceProject) return this.coreWorkspaceProject;
 		this.coreWorkspaceProject = TestProject._createBasicProject(this);
 		return this.coreWorkspaceProject;
 	}
@@ -9061,9 +9350,7 @@ class Vitest {
 	* Return project that has the root (or "global") config.
 	*/
 	getRootProject() {
-		if (!this.coreWorkspaceProject) {
-			throw new Error(`Root project is not initialized. This means that the Vite server was not established yet and the the workspace config is not resolved.`);
-		}
+		if (!this.coreWorkspaceProject) throw new Error(`Root project is not initialized. This means that the Vite server was not established yet and the the workspace config is not resolved.`);
 		return this.coreWorkspaceProject;
 	}
 	/**
@@ -9076,9 +9363,7 @@ class Vitest {
 	}
 	getProjectByName(name) {
 		const project = this.projects.find((p) => p.name === name) || this.coreWorkspaceProject || this.projects[0];
-		if (!project) {
-			throw new Error(`Project "${name}" was not found.`);
-		}
+		if (!project) throw new Error(`Project "${name}" was not found.`);
 		return project;
 	}
 	/**
@@ -9089,46 +9374,39 @@ class Vitest {
 		return this.runner.executeId(moduleId);
 	}
 	async resolveWorkspaceConfigPath() {
-		if (typeof this.config.workspace === "string") {
-			return this.config.workspace;
-		}
+		if (typeof this.config.workspace === "string") return this.config.workspace;
 		const configDir = this.vite.config.configFile ? dirname(this.vite.config.configFile) : this.config.root;
 		const rootFiles = await promises.readdir(configDir);
 		const workspaceConfigName = workspacesFiles.find((configFile) => {
 			return rootFiles.includes(configFile);
 		});
-		if (!workspaceConfigName) {
-			return undefined;
-		}
+		if (!workspaceConfigName) return void 0;
 		return join(configDir, workspaceConfigName);
 	}
 	async resolveProjects(cliOptions) {
-		const names = new Set();
+		const names = /* @__PURE__ */ new Set();
 		if (this.config.projects) {
-			if (typeof this.config.workspace !== "undefined") {
-				this.logger.warn("Both `config.projects` and `config.workspace` are defined. Ignoring the `workspace` option.");
-			}
-			return resolveProjects(this, cliOptions, undefined, this.config.projects, names);
+			if (typeof this.config.workspace !== "undefined") this.logger.warn("Both `config.projects` and `config.workspace` are defined. Ignoring the `workspace` option.");
+			return resolveProjects(this, cliOptions, void 0, this.config.projects, names);
 		}
 		if (Array.isArray(this.config.workspace)) {
 			this.logger.deprecate("The `workspace` option is deprecated and will be removed in the next major. To hide this warning, rename `workspace` option to `projects`.");
-			return resolveProjects(this, cliOptions, undefined, this.config.workspace, names);
+			return resolveProjects(this, cliOptions, void 0, this.config.workspace, names);
 		}
 		const workspaceConfigPath = await this.resolveWorkspaceConfigPath();
 		this._workspaceConfigPath = workspaceConfigPath;
+		// user doesn't have a workspace config, return default project
 		if (!workspaceConfigPath) {
+			// user can filter projects with --project flag, `getDefaultTestProject`
+			// returns the project only if it matches the filter
 			const project = getDefaultTestProject(this);
-			if (!project) {
-				return [];
-			}
+			if (!project) return [];
 			return resolveBrowserProjects(this, new Set([project.name]), [project]);
 		}
 		const configFile = this.vite.config.configFile ? resolve(this.vite.config.root, this.vite.config.configFile) : "the root config file";
 		this.logger.deprecate(`The workspace file is deprecated and will be removed in the next major. Please, use the \`projects\` field in ${configFile} instead.`);
 		const workspaceModule = await this.import(workspaceConfigPath);
-		if (!workspaceModule.default || !Array.isArray(workspaceModule.default)) {
-			throw new TypeError(`Workspace config file "${workspaceConfigPath}" must export a default array of project paths.`);
-		}
+		if (!workspaceModule.default || !Array.isArray(workspaceModule.default)) throw new TypeError(`Workspace config file "${workspaceConfigPath}" must export a default array of project paths.`);
 		return resolveProjects(this, cliOptions, workspaceConfigPath, workspaceModule.default, names);
 	}
 	/**
@@ -9139,9 +9417,7 @@ class Vitest {
 		return this.specifications.globTestSpecifications(filters);
 	}
 	async initCoverageProvider() {
-		if (this.coverageProvider !== undefined) {
-			return;
-		}
+		if (this.coverageProvider !== void 0) return;
 		this.coverageProvider = await getCoverageProvider(this.config.coverage, this.runner);
 		if (this.coverageProvider) {
 			await this.coverageProvider.initialize(this);
@@ -9153,9 +9429,7 @@ class Vitest {
 	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
 	*/
 	async mergeReports(directory) {
-		if (this.reporters.some((r) => r instanceof BlobReporter)) {
-			throw new Error("Cannot merge reports when `--reporter=blob` is used. Remove blob reporter from the config first.");
-		}
+		if (this.reporters.some((r) => r instanceof BlobReporter)) throw new Error("Cannot merge reports when `--reporter=blob` is used. Remove blob reporter from the config first.");
 		const { files, errors, coverages, executionTimes } = await readBlobs(this.version, directory || this.config.mergeReports, this.projects);
 		this.state.blobs = {
 			files,
@@ -9168,17 +9442,12 @@ class Vitest {
 		const specifications = [];
 		for (const file of files) {
 			const project = this.getProjectByName(file.projectName || "");
-			const specification = project.createSpecification(file.filepath, undefined, file.pool);
+			const 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);
-		}
-		if (hasFailed(files)) {
-			process.exitCode = 1;
-		}
+		for (const file of files) await this._reportFileTask(file);
 		this._checkUnhandledErrors(errors);
 		await this._testRun.end(specifications, errors).catch(noop);
 		await this.initCoverageProvider();
@@ -9195,24 +9464,19 @@ class Vitest {
 		await this._testRun.collected(project, [file]).catch(noop);
 		const logs = [];
 		const { packs, events } = convertTasksToEvents(file, (task) => {
-			if (task.logs) {
-				logs.push(...task.logs);
-			}
+			if (task.logs) logs.push(...task.logs);
 		});
 		logs.sort((log1, log2) => log1.time - log2.time);
-		for (const log of logs) {
-			await this._testRun.log(log).catch(noop);
-		}
+		for (const log of logs) await this._testRun.log(log).catch(noop);
 		await this._testRun.updated(packs, events).catch(noop);
 	}
 	async collect(filters) {
 		const files = await this.specifications.getRelevantTestSpecifications(filters);
-		if (!files.length) {
-			return {
-				testModules: [],
-				unhandledErrors: []
-			};
-		}
+		// if run with --changed, don't exit if no tests are found
+		if (!files.length) return {
+			testModules: [],
+			unhandledErrors: []
+		};
 		return this.collectTests(files);
 	}
 	/** @deprecated use `getRelevantTestSpecifications` instead */
@@ -9241,33 +9505,27 @@ class Vitest {
 		} finally {
 			await this.report("onInit", this);
 		}
-		this.filenamePattern = filters && filters?.length > 0 ? filters : undefined;
+		this.filenamePattern = filters && filters?.length > 0 ? filters : void 0;
 		const files = await this.specifications.getRelevantTestSpecifications(filters);
+		// if run with --changed, don't exit if no tests are found
 		if (!files.length) {
-			const throwAnError = !this.config.watch || !(this.config.changed || this.config.related?.length);
 			await this._testRun.start([]);
 			const coverage = await this.coverageProvider?.generateCoverage?.({ allTestsRun: true });
-			if (throwAnError) {
-				const exitCode = this.config.passWithNoTests ? 0 : 1;
-				process.exitCode = exitCode;
-			}
 			await this._testRun.end([], [], coverage);
+			// Report coverage for uncovered files
 			await this.reportCoverage(coverage, true);
-			if (throwAnError) {
-				throw new FilesNotFoundError(this.mode);
-			}
+			if (!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 (this.config.watch) {
-			await this.report("onWatcherStart");
-		}
+		if (this.config.watch) await this.report("onWatcherStart");
 		return testModules;
 	}
 	/**
@@ -9281,10 +9539,9 @@ class Vitest {
 		} 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 (this.config.watch) await this.report("onWatcherStart");
 	}
 	/**
 	* @deprecated remove when vscode extension supports "getModuleSpecifications"
@@ -9326,7 +9583,7 @@ class Vitest {
 	* @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
 	*/
 	async rerunTestSpecifications(specifications, allTestsRun = false) {
-		this.configOverride.testNamePattern = undefined;
+		this.configOverride.testNamePattern = void 0;
 		const files = specifications.map((spec) => spec.moduleId);
 		await Promise.all([this.report("onWatcherRerun", files, "rerun test"), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
 		const result = await this.runTestSpecifications(specifications, allTestsRun);
@@ -9335,21 +9592,19 @@ class Vitest {
 	}
 	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 () => {
 			try {
-				if (!this.pool) {
-					this.pool = createPool(this);
-				}
+				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.isFirstRun && this.config.coverage.cleanOnRerun) await this.coverageProvider?.clean();
 				await this.initializeGlobalSetup(specs);
 				try {
 					await this.pool.runTests(specs, invalidates);
@@ -9357,9 +9612,6 @@ class Vitest {
 					this.state.catchError(err, "Unhandled Error");
 				}
 				const files = this.state.getFiles();
-				if (hasFailed(files)) {
-					process.exitCode = 1;
-				}
 				this.cache.results.updateResults(files);
 				try {
 					await this.cache.results.writeToCache();
@@ -9369,6 +9621,7 @@ 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);
@@ -9376,10 +9629,11 @@ class Vitest {
 				await this.reportCoverage(coverage, allTestsRun);
 			}
 		})().finally(() => {
-			this.runningPromise = undefined;
+			this.runningPromise = void 0;
 			this.isFirstRun = false;
+			// all subsequent runs will treat this as a fresh run
 			this.config.changed = false;
-			this.config.related = undefined;
+			this.config.related = void 0;
 		});
 		return await this.runningPromise;
 	}
@@ -9390,13 +9644,13 @@ 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 () => {
-			if (!this.pool) {
-				this.pool = createPool(this);
-			}
+			if (!this.pool) this.pool = createPool(this);
 			const invalidates = Array.from(this.watcher.invalidates);
 			this.watcher.invalidates.clear();
 			this.snapshot.clear();
@@ -9408,17 +9662,18 @@ class Vitest {
 				this.state.catchError(err, "Unhandled Error");
 			}
 			const files = this.state.getFiles();
-			if (hasFailed(files)) {
-				process.exitCode = 1;
-			}
+			// can only happen if there was a syntax error in describe block
+			// or there was an error importing a file
+			if (hasFailed(files)) process.exitCode = 1;
 			return {
 				testModules: this.state.getTestModules(),
 				unhandledErrors: this.state.getUnhandledErrors()
 			};
 		})().finally(() => {
-			this.runningPromise = undefined;
+			this.runningPromise = void 0;
+			// all subsequent runs will treat this as a fresh run
 			this.config.changed = false;
-			this.config.related = undefined;
+			this.config.related = void 0;
 		});
 		return await this.runningPromise;
 	}
@@ -9437,18 +9692,12 @@ class Vitest {
 	async initializeGlobalSetup(paths) {
 		const projects = new Set(paths.map((spec) => spec.project));
 		const coreProject = this.getRootProject();
-		if (!projects.has(coreProject)) {
-			projects.add(coreProject);
-		}
-		for (const project of projects) {
-			await project._initializeGlobalSetup();
-		}
+		if (!projects.has(coreProject)) projects.add(coreProject);
+		for (const project of projects) await project._initializeGlobalSetup();
 	}
 	/** @internal */
 	async rerunFiles(files = this.state.getFilepaths(), trigger, allTestsRun = true, resetTestNamePattern = false) {
-		if (resetTestNamePattern) {
-			this.configOverride.testNamePattern = undefined;
-		}
+		if (resetTestNamePattern) this.configOverride.testNamePattern = void 0;
 		if (this.filenamePattern) {
 			const filteredFiles = await this.globTestSpecifications(this.filenamePattern);
 			files = files.filter((file) => filteredFiles.some((f) => f.moduleId === file));
@@ -9462,37 +9711,30 @@ class Vitest {
 	/** @internal */
 	async rerunTask(id) {
 		const task = this.state.idMap.get(id);
-		if (!task) {
-			throw new Error(`Task ${id} was not found`);
-		}
+		if (!task) throw new Error(`Task ${id} was not found`);
 		const taskNamePattern = task.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 		await this.changeNamePattern(taskNamePattern, [task.file.filepath], "tasks" in task ? "rerun suite" : "rerun test");
 	}
 	/** @internal */
 	async changeProjectName(pattern) {
-		if (pattern === "") {
-			this.configOverride.project = undefined;
-		} else {
-			this.configOverride.project = [pattern];
-		}
+		if (pattern === "") this.configOverride.project = void 0;
+		else this.configOverride.project = [pattern];
 		await this.vite.restart();
 	}
 	/** @internal */
 	async changeNamePattern(pattern, files = this.state.getFilepaths(), trigger) {
-		if (pattern === "") {
-			this.filenamePattern = undefined;
-		}
-		const testNamePattern = pattern ? new RegExp(pattern) : undefined;
+		// 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;
-		if (testNamePattern) {
-			files = files.filter((filepath) => {
-				const files = this.state.getFiles([filepath]);
-				return !files.length || files.some((file) => {
-					const tasks = getTasks(file);
-					return !tasks.length || tasks.some((task) => testNamePattern.test(task.name));
-				});
+		// filter only test files that have tests matching the pattern
+		if (testNamePattern) files = files.filter((filepath) => {
+			const files = this.state.getFiles([filepath]);
+			return !files.length || files.some((file) => {
+				const tasks = getTasks(file);
+				return !tasks.length || tasks.some((task) => testNamePattern.test(task.name));
 			});
-		}
+		});
 		await this.rerunFiles(files, trigger, pattern === "");
 	}
 	/** @internal */
@@ -9510,6 +9752,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();
 		try {
@@ -9544,52 +9787,46 @@ class Vitest {
 	* This method doesn't run any tests.
 	*/
 	setGlobalTestNamePattern(pattern) {
-		if (pattern instanceof RegExp) {
-			this.configOverride.testNamePattern = pattern;
-		} else {
-			this.configOverride.testNamePattern = pattern ? new RegExp(pattern) : undefined;
-		}
+		if (pattern instanceof RegExp) this.configOverride.testNamePattern = pattern;
+		else this.configOverride.testNamePattern = pattern ? new RegExp(pattern) : void 0;
 	}
 	/**
 	* Resets the global test name pattern. This method doesn't run any tests.
 	*/
 	resetGlobalTestNamePattern() {
-		this.configOverride.testNamePattern = undefined;
+		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);
-		if (this.restartsCount !== currentCount) {
-			return;
-		}
+		// server restarted
+		if (this.restartsCount !== currentCount) return;
 		this._rerunTimer = setTimeout(async () => {
 			if (this.watcher.changedTests.size === 0) {
 				this.watcher.invalidates.clear();
 				return;
 			}
-			if (this.restartsCount !== currentCount) {
-				return;
-			}
+			// server restarted
+			if (this.restartsCount !== currentCount) return;
 			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));
-				if (files.length === 0) {
-					return;
-				}
+				// A file that does not match the current filename pattern was changed
+				if (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;
-				}
+				if (this._onFilterWatchedSpecification.length === 0) return true;
 				return this._onFilterWatchedSpecification.every((fn) => fn(specification));
 			});
 			await Promise.all([this.report("onWatcherRerun", files, triggerLabel), ...this._onUserTestsRerun.map((fn) => fn(specifications))]);
@@ -9616,24 +9853,17 @@ class Vitest {
 	}
 	/** @internal */
 	_checkUnhandledErrors(errors) {
-		if (errors.length && !this.config.dangerouslyIgnoreUnhandledErrors) {
-			process.exitCode = 1;
-		}
+		if (errors.length && !this.config.dangerouslyIgnoreUnhandledErrors) process.exitCode = 1;
 	}
 	async reportCoverage(coverage, allTestsRun) {
 		if (this.state.getCountOfFailedTests() > 0) {
 			await this.coverageProvider?.onTestFailure?.();
-			if (!this.config.coverage.reportOnFailure) {
-				return;
-			}
+			if (!this.config.coverage.reportOnFailure) return;
 		}
 		if (this.coverageProvider) {
 			await this.coverageProvider.reportCoverage(coverage, { allTestsRun });
-			for (const reporter of this.reporters) {
-				if (reporter instanceof WebSocketReporter) {
-					reporter.onFinishedReportCoverage();
-				}
-			}
+			// notify coverage iframe reload
+			for (const reporter of this.reporters) if (reporter instanceof WebSocketReporter) reporter.onFinishedReportCoverage();
 		}
 	}
 	/**
@@ -9641,35 +9871,26 @@ class Vitest {
 	* This can only be called once; the closing promise is cached until the server restarts.
 	*/
 	async close() {
-		if (!this.closingPromise) {
-			this.closingPromise = (async () => {
-				const teardownProjects = [...this.projects];
-				if (this.coreWorkspaceProject && !teardownProjects.includes(this.coreWorkspaceProject)) {
-					teardownProjects.push(this.coreWorkspaceProject);
-				}
-				for (const project of teardownProjects.reverse()) {
-					await project._teardownGlobalSetup();
-				}
-				const closePromises = this.projects.map((w) => w.close());
-				if (this.coreWorkspaceProject && !this.projects.includes(this.coreWorkspaceProject)) {
-					closePromises.push(this.coreWorkspaceProject.close().then(() => this._vite = undefined));
-				}
-				if (this.pool) {
-					closePromises.push((async () => {
-						await this.pool?.close?.();
-						this.pool = undefined;
-					})());
-				}
-				closePromises.push(...this._onClose.map((fn) => fn()));
-				return Promise.allSettled(closePromises).then((results) => {
-					results.forEach((r) => {
-						if (r.status === "rejected") {
-							this.logger.error("error during close", r.reason);
-						}
-					});
+		if (!this.closingPromise) this.closingPromise = (async () => {
+			const teardownProjects = [...this.projects];
+			if (this.coreWorkspaceProject && !teardownProjects.includes(this.coreWorkspaceProject)) teardownProjects.push(this.coreWorkspaceProject);
+			// do teardown before closing the server
+			for (const project of teardownProjects.reverse()) await project._teardownGlobalSetup();
+			const closePromises = this.projects.map((w) => w.close());
+			// close the core workspace server only once
+			// 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;
+			})());
+			closePromises.push(...this._onClose.map((fn) => fn()));
+			return Promise.allSettled(closePromises).then((results) => {
+				results.forEach((r) => {
+					if (r.status === "rejected") this.logger.error("error during close", r.reason);
 				});
-			})();
-		}
+			});
+		})();
 		return this.closingPromise;
 	}
 	/**
@@ -9683,31 +9904,23 @@ class Vitest {
 				this.state.getProcessTimeoutCauses().forEach((cause) => console.warn(cause));
 				if (!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`);
-					} else {
-						console.warn("Tests closed successfully but something prevents the main process from exiting");
-					}
-					if (!this.reporters.some((r) => r instanceof HangingProcessReporter)) {
-						console.warn("You can try to identify the cause by enabling \"hanging-process\" reporter. See https://vitest.dev/config/#reporters");
-					}
+					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`);
+					else console.warn("Tests closed successfully but something prevents the main process from exiting");
+					if (!this.reporters.some((r) => r instanceof HangingProcessReporter)) console.warn("You can try to identify the cause by enabling \"hanging-process\" reporter. See https://vitest.dev/config/#reporters");
 				}
 				process.exit();
 			});
 		}, this.config.teardownTimeout).unref();
 		await this.close();
-		if (force) {
-			process.exit();
-		}
+		if (force) process.exit();
 	}
 	/** @internal */
 	async report(name, ...args) {
 		await Promise.all(this.reporters.map((r) => r[name]?.(
 			// @ts-expect-error let me go
 			...args
-)));
+		)));
 	}
 	/** @internal */
 	async _globTestFilepaths() {
@@ -9730,6 +9943,7 @@ class Vitest {
 	getModuleProjects(filepath) {
 		return this.projects.filter((project) => {
 			return project.getModulesByFilepath(filepath).size;
+			// TODO: reevaluate || project.browser?.moduleGraph.getModulesByFile(id)?.size
 		});
 	}
 	/**
@@ -9780,10 +9994,9 @@ class Vitest {
 	* Check if the project with a given name should be included.
 	*/
 	matchesProjectFilter(name) {
-		const projects = this._config?.project || this._options?.project;
-		if (!projects || !projects.length) {
-			return true;
-		}
+		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) => {
 			const regexp = wildcardPatternToRegExp(project);
 			return regexp.test(name);
@@ -9791,16 +10004,14 @@ class Vitest {
 	}
 }
 function assert(condition, property, name = property) {
-	if (!condition) {
-		throw new Error(`The ${name} was not set. It means that \`vitest.${property}\` was called before the Vite server was established. Await the Vitest promise before accessing \`vitest.${property}\`.`);
-	}
+	if (!condition) throw new Error(`The ${name} was not set. It means that \`vitest.${property}\` was called before the Vite server was established. Await the Vitest promise before accessing \`vitest.${property}\`.`);
 }
 
-async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
+async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(options))) {
 	const userConfig = deepMerge({}, options);
 	async function UIPlugin() {
-		await ctx.packageInstaller.ensureInstalled("@vitest/ui", options.root || process.cwd(), ctx.version);
-		return (await import('@vitest/ui')).default(ctx);
+		await vitest.packageInstaller.ensureInstalled("@vitest/ui", options.root || process.cwd(), vitest.version);
+		return (await import('@vitest/ui')).default(vitest);
 	}
 	return [
 		{
@@ -9810,17 +10021,21 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
 				this.meta.watchMode = false;
 			},
 			async config(viteConfig) {
-				if (options.watch) {
-					options = deepMerge({}, userConfig);
-				}
+				if (options.watch)
+ // Earlier runs have overwritten values of the `options`.
+				// Reset it back to initial user config before setting up the server again.
+				options = deepMerge({}, userConfig);
+				// preliminary merge of options to be able to create server options for vite
+				// however to allow vitest plugins to modify vitest config values
+				// this is repeated in configResolved where the config is final
 				const testConfig = deepMerge({}, configDefaults, removeUndefinedValues(viteConfig.test ?? {}), options);
 				testConfig.api = resolveApiServerConfig(testConfig, defaultPort);
+				// store defines for globalThis to make them
+				// reassignable when running in worker in src/runtime/setup.ts
 				const defines = deleteDefineConfig(viteConfig);
 				options.defines = defines;
 				let open = false;
-				if (testConfig.ui && testConfig.open) {
-					open = testConfig.uiBase ?? "/__vitest__/";
-				}
+				if (testConfig.ui && testConfig.open) open = testConfig.uiBase ?? "/__vitest__/";
 				const resolveOptions = getDefaultResolveOptions();
 				const config = {
 					root: viteConfig.test?.root || options.root,
@@ -9838,7 +10053,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
 						...testConfig.api,
 						open,
 						hmr: false,
-						ws: testConfig.api?.middlewareMode ? false : undefined,
+						ws: testConfig.api?.middlewareMode ? false : void 0,
 						preTransformRequests: false,
 						fs: { allow: resolveFsAllow(options.root || process.cwd(), testConfig.config) }
 					},
@@ -9856,95 +10071,81 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
 						deps: testConfig.deps ?? viteConfig.test?.deps
 					}
 				};
-				if (ctx.configOverride.project) {
-					options.project = ctx.configOverride.project;
-				}
-				config.customLogger = createViteLogger(ctx.logger, viteConfig.logLevel || "warn", { allowClearScreen: false });
+				// inherit so it's available in VitestOptimizer
+				// I cannot wait to rewrite all of this in Vitest 4
+				if (options.cache != null) config.test.cache = options.cache;
+				if (vitest.configOverride.project)
+ // project filter was set by the user, so we need to filter the project
+				options.project = vitest.configOverride.project;
+				config.customLogger = createViteLogger(vitest.logger, viteConfig.logLevel || "warn", { allowClearScreen: false });
 				config.customLogger = silenceImportViteIgnoreWarning(config.customLogger);
+				// we want inline dependencies to be resolved by analyser plugin so module graph is populated correctly
 				if (viteConfig.ssr?.noExternal !== true) {
 					const inline = testConfig.server?.deps?.inline;
-					if (inline === true) {
-						config.ssr = { noExternal: true };
-					} else {
+					if (inline === true) config.ssr = { noExternal: true };
+					else {
 						const noExternal = viteConfig.ssr?.noExternal;
-						const noExternalArray = typeof noExternal !== "undefined" ? toArray(noExternal) : undefined;
+						const noExternalArray = typeof noExternal !== "undefined" ? toArray(noExternal) : void 0;
+						// filter the same packages
 						const uniqueInline = inline && noExternalArray ? inline.filter((dep) => !noExternalArray.includes(dep)) : inline;
 						config.ssr = { noExternal: uniqueInline };
 					}
 				}
-				if (process.platform === "darwin" && process.env.VITE_TEST_WATCHER_DEBUG) {
-					const watch = config.server.watch;
-					if (watch) {
-						watch.useFsEvents = false;
-						watch.usePolling = false;
-					}
-				}
+				// chokidar fsevents is unstable on macos when emitting "ready" event
+				if (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) => {
-							const root = ctx.config.root || options.root || process.cwd();
-							return generateScopedClassName(classNameStrategy, name, relative(root, filename));
-						};
-					}
+					if (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));
+					};
 				}
 				return config;
 			},
 			async configResolved(viteConfig) {
 				const viteConfigTest = viteConfig.test || {};
-				if (viteConfigTest.watch === false) {
-					viteConfigTest.run = true;
-				}
-				if ("alias" in viteConfigTest) {
-					delete viteConfigTest.alias;
-				}
+				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);
+				// 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];
-				}
-				if (!options.watch) {
-					viteConfig.server.watch = null;
-				}
+				for (const name in envs) process.env[name] ??= envs[name];
+				// don't watch files in run mode
+				if (!options.watch) viteConfig.server.watch = null;
 				Object.defineProperty(viteConfig, "_vitest", {
 					value: options,
 					enumerable: false,
 					configurable: true
 				});
 				const originalName = options.name;
-				if (options.browser?.enabled && options.browser?.instances) {
-					options.browser.instances.forEach((instance) => {
-						instance.name ??= originalName ? `${originalName} (${instance.browser})` : instance.browser;
-					});
-				}
+				if (options.browser?.instances) options.browser.instances.forEach((instance) => {
+					instance.name ??= originalName ? `${originalName} (${instance.browser})` : instance.browser;
+				});
 			},
 			configureServer: {
 				order: "post",
 				async handler(server) {
-					if (options.watch && process.env.VITE_TEST_WATCHER_DEBUG) {
-						server.watcher.on("ready", () => {
-							console.log("[debug] watcher is ready");
-						});
-					}
-					await ctx._setServer(options, server, userConfig);
-					if (options.api && options.watch) {
-						(await Promise.resolve().then(function () { return setup$1; })).setup(ctx);
-					}
-					if (!options.watch) {
-						await server.watcher.close();
-					}
+					if (options.watch && false);
+					await vitest._setServer(options, server);
+					if (options.api && options.watch) (await Promise.resolve().then(function () { return setup$1; })).setup(vitest);
+					// #415, in run mode we don't need the watcher, close it would improve the performance
+					if (!options.watch) await server.watcher.close();
 				}
 			}
 		},
 		SsrReplacerPlugin(),
-		...CSSEnablerPlugin(ctx),
-		CoverageTransform(ctx),
-		VitestCoreResolver(ctx),
+		...CSSEnablerPlugin(vitest),
+		CoverageTransform(vitest),
+		VitestCoreResolver(vitest),
 		options.ui ? await UIPlugin() : null,
 		...MocksPlugins(),
 		VitestOptimizer(),
@@ -9952,29 +10153,24 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
 	].filter(notNullish);
 }
 function removeUndefinedValues(obj) {
-	for (const key in Object.keys(obj)) {
-		if (obj[key] === undefined) {
-			delete obj[key];
-		}
-	}
+	for (const key in Object.keys(obj)) if (obj[key] === void 0) delete obj[key];
 	return obj;
 }
 
 async function createVitest(mode, options, viteOverrides = {}, vitestOptions = {}) {
-	const ctx = new Vitest(mode, 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 });
 	options.config = configPath;
+	const { browser: _removeBrowser,...restOptions } = options;
 	const config = {
 		configFile: configPath,
 		configLoader: options.configLoader,
 		mode: options.mode || mode,
-		plugins: await VitestPlugin(options, ctx)
+		plugins: await VitestPlugin(restOptions, ctx)
 	};
 	const server = await createViteServer(mergeConfig(config, mergeConfig(viteOverrides, { root: options.root })));
-	if (ctx.config.api?.port) {
-		await server.listen();
-	}
+	if (ctx.config.api?.port) await server.listen();
 	return ctx;
 }
 
@@ -9983,7 +10179,7 @@ const SELECTION_MAX_INDEX = 7;
 const ESC = "\x1B[";
 class WatchFilter {
 	filterRL;
-	currentKeyword = undefined;
+	currentKeyword = void 0;
 	message;
 	results = [];
 	selectionIndex = -1;
@@ -9999,9 +10195,7 @@ class WatchFilter {
 			escapeCodeTimeout: 50
 		});
 		readline.emitKeypressEvents(this.stdin, this.filterRL);
-		if (this.stdin.isTTY) {
-			this.stdin.setRawMode(true);
-		}
+		if (this.stdin.isTTY) this.stdin.setRawMode(true);
 	}
 	async filter(filterFunc) {
 		this.write(this.promptLine());
@@ -10020,57 +10214,41 @@ class WatchFilter {
 		return async (str, key) => {
 			switch (true) {
 				case key.sequence === "":
-					if (this.currentKeyword && this.currentKeyword?.length > 1) {
-						this.currentKeyword = this.currentKeyword?.slice(0, -1);
-					} else {
-						this.currentKeyword = undefined;
-					}
+					if (this.currentKeyword && this.currentKeyword?.length > 1) this.currentKeyword = this.currentKeyword?.slice(0, -1);
+					else this.currentKeyword = void 0;
 					break;
 				case key?.ctrl && key?.name === "c":
 				case key?.name === "escape":
 					this.write(`${ESC}1G${ESC}0J`);
-					onSubmit(undefined);
+					onSubmit(void 0);
 					return;
 				case key?.name === "enter":
 				case key?.name === "return":
 					onSubmit(this.results[this.selectionIndex] || this.currentKeyword || "");
-					this.currentKeyword = undefined;
+					this.currentKeyword = void 0;
 					break;
 				case key?.name === "up":
-					if (this.selectionIndex && this.selectionIndex > 0) {
-						this.selectionIndex--;
-					} else {
-						this.selectionIndex = -1;
-					}
+					if (this.selectionIndex && this.selectionIndex > 0) this.selectionIndex--;
+					else this.selectionIndex = -1;
 					break;
 				case key?.name === "down":
-					if (this.selectionIndex < this.results.length - 1) {
-						this.selectionIndex++;
-					} else if (this.selectionIndex >= this.results.length - 1) {
-						this.selectionIndex = this.results.length - 1;
-					}
+					if (this.selectionIndex < this.results.length - 1) this.selectionIndex++;
+					else if (this.selectionIndex >= this.results.length - 1) this.selectionIndex = this.results.length - 1;
 					break;
 				case !key?.ctrl && !key?.meta:
-					if (this.currentKeyword === undefined) {
-						this.currentKeyword = str;
-					} else {
-						this.currentKeyword += str || "";
-					}
+					if (this.currentKeyword === void 0) this.currentKeyword = str;
+					else this.currentKeyword += str || "";
 					break;
 			}
-			if (this.currentKeyword) {
-				this.results = await filterFunc(this.currentKeyword);
-			}
+			if (this.currentKeyword) this.results = await filterFunc(this.currentKeyword);
 			this.render();
 		};
 	}
 	render() {
 		let printStr = this.promptLine();
-		if (!this.currentKeyword) {
-			printStr += "\nPlease input filter pattern";
-		} else if (this.currentKeyword && this.results.length === 0) {
-			printStr += "\nPattern matches no results";
-		} else {
+		if (!this.currentKeyword) printStr += "\nPlease input filter pattern";
+		else if (this.currentKeyword && this.results.length === 0) printStr += "\nPattern matches no results";
+		else {
 			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) {
@@ -10078,12 +10256,9 @@ class WatchFilter {
 				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 += "\n" + `${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");
-			}
+				if (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);
@@ -10100,6 +10275,7 @@ class WatchFilter {
 		const lines = str.split(/\r?\n/);
 		for (const line of lines) {
 			const columns = "columns" in this.stdout ? this.stdout.columns : 80;
+			// 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`);
@@ -10109,12 +10285,8 @@ class WatchFilter {
 	}
 	close() {
 		this.filterRL.close();
-		if (this.onKeyPress) {
-			this.stdin.removeListener("keypress", this.onKeyPress);
-		}
-		if (this.stdin.isTTY) {
-			this.stdin.setRawMode(false);
-		}
+		if (this.onKeyPress) this.stdin.removeListener("keypress", this.onKeyPress);
+		if (this.stdin.isTTY) this.stdin.setRawMode(false);
 	}
 	restoreCursor() {
 		const cursortPos = this.keywordOffset() + (this.currentKeyword?.length || 0);
@@ -10154,6 +10326,8 @@ ${keys.map((i) => c.dim("  press ") + c.reset([i[0]].flat().map(c.bold).join(",
 function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 	let latestFilename = "";
 	async function _keypressHandler(str, key) {
+		// 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"));
@@ -10162,6 +10336,7 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 			}
 			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");
@@ -10169,39 +10344,30 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 		}
 		const name = key?.name;
 		if (ctx.runningPromise) {
-			if (cancelKeys.includes(name)) {
-				await ctx.cancelCurrentRun("keyboard-input");
-			}
+			if (cancelKeys.includes(name)) await ctx.cancelCurrentRun("keyboard-input");
 			return;
 		}
-		if (name === "q") {
-			return ctx.exit(true);
-		}
-		if (name === "h") {
-			return printShortcutsHelp();
-		}
-		if (name === "u") {
-			return ctx.updateSnapshot();
-		}
+		// quit
+		if (name === "q") return ctx.exit(true);
+		// help
+		if (name === "h") return printShortcutsHelp();
+		// update snapshot
+		if (name === "u") return ctx.updateSnapshot();
+		// rerun all tests
 		if (name === "a" || name === "return") {
 			const files = await ctx._globTestFilepaths();
 			return ctx.changeNamePattern("", files, "rerun all tests");
 		}
-		if (name === "r") {
-			return ctx.rerunFiles();
-		}
-		if (name === "f") {
-			return ctx.rerunFailed();
-		}
-		if (name === "w") {
-			return inputProjectName();
-		}
-		if (name === "t") {
-			return inputNamePattern();
-		}
-		if (name === "p") {
-			return inputFilePattern();
-		}
+		// rerun current pattern tests
+		if (name === "r") return ctx.rerunFiles();
+		// rerun only failed tests
+		if (name === "f") return ctx.rerunFailed();
+		// change project filter
+		if (name === "w") return inputProjectName();
+		// change testNamePattern
+		if (name === "t") return inputNamePattern();
+		// change fileNamePattern
+		if (name === "p") return inputFilePattern();
 		if (name === "b") {
 			await ctx._initBrowserServers();
 			ctx.projects.forEach((project) => {
@@ -10224,15 +10390,15 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 				const reg = new RegExp(str);
 				return tests.map((test) => test.name).filter((testName) => testName.match(reg));
 			} catch {
+				// `new RegExp` may throw error when input is invalid regexp
 				return [];
 			}
 		});
 		on();
-		if (typeof filter === "undefined") {
-			return;
-		}
+		if (typeof filter === "undefined") return;
 		const files = ctx.state.getFilepaths();
-		const cliFiles = ctx.config.standalone && !files.length ? await ctx._globTestFilepaths() : undefined;
+		// 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;
 		await ctx.changeNamePattern(filter?.trim() || "", cliFiles, "change pattern");
 	}
 	async function inputProjectName() {
@@ -10254,12 +10420,10 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 			return files.map((file) => relative(ctx.config.root, file[1]));
 		});
 		on();
-		if (typeof filter === "undefined") {
-			return;
-		}
+		if (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)) : undefined);
+		await ctx.changeFilenamePattern(latestFilename, filter && lastResults.length ? lastResults.map((i) => resolve(ctx.config.root, i)) : void 0);
 	}
 	let rl;
 	function on() {
@@ -10269,18 +10433,14 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 			escapeCodeTimeout: 50
 		});
 		readline.emitKeypressEvents(stdin, rl);
-		if (stdin.isTTY) {
-			stdin.setRawMode(true);
-		}
+		if (stdin.isTTY) stdin.setRawMode(true);
 		stdin.on("keypress", keypressHandler);
 	}
 	function off() {
 		rl?.close();
-		rl = undefined;
+		rl = void 0;
 		stdin.removeListener("keypress", keypressHandler);
-		if (stdin.isTTY) {
-			stdin.setRawMode(false);
-		}
+		if (stdin.isTTY) stdin.setRawMode(false);
 	}
 	on();
 	return function cleanup() {
@@ -10309,28 +10469,17 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
 	const stdin = vitestOptions?.stdin || process.stdin;
 	const stdout = vitestOptions?.stdout || process.stdout;
 	let stdinCleanup;
-	if (stdin.isTTY && ctx.config.watch) {
-		stdinCleanup = registerConsoleShortcuts(ctx, stdin, stdout);
-	}
+	if (stdin.isTTY && ctx.config.watch) stdinCleanup = registerConsoleShortcuts(ctx, stdin, stdout);
 	ctx.onAfterSetServer(() => {
-		if (ctx.config.standalone) {
-			ctx.init();
-		} else {
-			ctx.start(cliFilters);
-		}
+		if (ctx.config.standalone) ctx.init();
+		else ctx.start(cliFilters);
 	});
 	try {
-		if (ctx.config.mergeReports) {
-			await ctx.mergeReports();
-		} else if (ctx.config.standalone) {
-			await ctx.init();
-		} else {
-			await ctx.start(cliFilters);
-		}
+		if (ctx.config.mergeReports) await ctx.mergeReports();
+		else if (ctx.config.standalone) await ctx.init();
+		else await ctx.start(cliFilters);
 	} catch (e) {
-		if (e instanceof FilesNotFoundError) {
-			return ctx;
-		}
+		if (e instanceof FilesNotFoundError) return ctx;
 		if (e instanceof GitNotFoundError) {
 			ctx.logger.error(e.message);
 			return ctx;
@@ -10347,9 +10496,7 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
 		ctx.logger.error("\n\n");
 		return ctx;
 	}
-	if (ctx.shouldKeepServer()) {
-		return ctx;
-	}
+	if (ctx.shouldKeepServer()) return ctx;
 	stdinCleanup?.();
 	await ctx.close();
 	return ctx;
@@ -10358,9 +10505,8 @@ async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions) {
 	process.env.TEST = "true";
 	process.env.VITEST = "true";
 	process.env.NODE_ENV ??= "test";
-	if (options.run) {
-		options.watch = false;
-	}
+	if (options.run) options.watch = 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);
@@ -10378,24 +10524,16 @@ function processCollected(ctx, files, options) {
 			ctx.logger.printError(error, { project: suite.project });
 		});
 	});
-	if (errorsPrinted) {
-		return;
-	}
-	if (typeof options.json !== "undefined") {
-		return processJsonOutput(files, options);
-	}
+	if (errorsPrinted) return;
+	if (typeof options.json !== "undefined") return processJsonOutput(files, options);
 	return formatCollectedAsString(files).forEach((test) => console.log(test));
 }
 function outputFileList(files, options) {
-	if (typeof options.json !== "undefined") {
-		return outputJsonFileList(files, options);
-	}
+	if (typeof options.json !== "undefined") return outputJsonFileList(files, options);
 	formatFilesAsString(files, options).map((file) => console.log(file));
 }
 function outputJsonFileList(files, options) {
-	if (typeof options.json === "boolean") {
-		return console.log(JSON.stringify(formatFilesAsJSON(files), null, 2));
-	}
+	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 });
@@ -10405,25 +10543,19 @@ function outputJsonFileList(files, options) {
 function formatFilesAsJSON(files) {
 	return files.map((file) => {
 		const result = { file: file.moduleId };
-		if (file.project.name) {
-			result.projectName = file.project.name;
-		}
+		if (file.project.name) result.projectName = file.project.name;
 		return result;
 	});
 }
 function formatFilesAsString(files, options) {
 	return files.map((file) => {
 		let name = relative(options.root || process.cwd(), file.moduleId);
-		if (file.project.name) {
-			name = `[${file.project.name}] ${name}`;
-		}
+		if (file.project.name) name = `[${file.project.name}] ${name}`;
 		return name;
 	});
 }
 function processJsonOutput(files, options) {
-	if (typeof options.json === "boolean") {
-		return console.log(JSON.stringify(formatCollectedAsJSON(files), null, 2));
-	}
+	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 });
@@ -10433,28 +10565,20 @@ function processJsonOutput(files, options) {
 function forEachSuite(modules, callback) {
 	modules.forEach((testModule) => {
 		callback(testModule);
-		for (const suite of testModule.children.allSuites()) {
-			callback(suite);
-		}
+		for (const suite of testModule.children.allSuites()) callback(suite);
 	});
 }
 function formatCollectedAsJSON(files) {
 	const results = [];
 	files.forEach((file) => {
 		for (const test of file.children.allTests()) {
-			if (test.result().state === "skipped") {
-				continue;
-			}
+			if (test.result().state === "skipped") continue;
 			const result = {
 				name: test.fullName,
 				file: test.module.moduleId
 			};
-			if (test.project.name) {
-				result.projectName = test.project.name;
-			}
-			if (test.location) {
-				result.location = test.location;
-			}
+			if (test.project.name) result.projectName = test.project.name;
+			if (test.location) result.location = test.location;
 			results.push(result);
 		}
 	});
@@ -10464,9 +10588,7 @@ function formatCollectedAsString(testModules) {
 	const results = [];
 	testModules.forEach((testModule) => {
 		for (const test of testModule.children.allTests()) {
-			if (test.result().state === "skipped") {
-				continue;
-			}
+			if (test.result().state === "skipped") continue;
 			const fullName = `${test.module.task.name} > ${test.fullName}`;
 			results.push((test.project.name ? `[${test.project.name}] ` : "") + fullName);
 		}
@@ -10479,15 +10601,9 @@ 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] === "." || env[0] === "/") {
-		return null;
-	}
+	if (env === "node") return null;
+	if (env in envPackageNames) return envPackageNames[env];
+	if (env[0] === "." || env[0] === "/") return null;
 	return `vitest-environment-${env}`;
 }