vitest 3.2.0-beta.2 → 3.2.0

package/dist/chunks/{coverage.OGU09Jbh.js → coverage.EIiagJJP.js}

@@ -1,34 +1,34 @@
 import fs, { statSync, realpathSync, promises as promises$1, mkdirSync, existsSync, readdirSync, writeFileSync } from 'node:fs';
-import { relative, resolve, dirname, isAbsolute, join as join$1, normalize } from 'pathe';
+import { isAbsolute, join as join$1, dirname as dirname$1, resolve as resolve$1, relative, normalize } from 'pathe';
 import pm from 'picomatch';
 import c from 'tinyrainbow';
-import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.DSxsTG0h.js';
+import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.B7q_naMc.js';
 import crypto from 'node:crypto';
-import { slash, createDefer, shuffle, toArray } from '@vitest/utils';
+import { createDefer, shuffle, toArray } from '@vitest/utils';
 import { builtinModules, createRequire } from 'node:module';
-import path, { win32, dirname as dirname$1, join, resolve as resolve$1 } from 'node:path';
+import path, { win32, dirname, join, resolve } from 'node:path';
 import process$1 from 'node:process';
-import fsPromises, { writeFile, rename, stat, unlink } from 'node:fs/promises';
+import fs$1, { writeFile, rename, stat, unlink } from 'node:fs/promises';
 import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
 import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
-import { e as extraInlineDeps, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.BZZyIeIE.js';
-import { a as isWindows } from './env.Dq0hM4Xv.js';
+import { version, mergeConfig } from 'vite';
+import { e as extraInlineDeps, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.DnKduX2e.js';
+import { a as isWindows } from './env.D4Lgay0q.js';
 import * as nodeos from 'node:os';
 import nodeos__default from 'node:os';
 import { isatty } from 'node:tty';
-import { version } from 'vite';
 import EventEmitter from 'node:events';
 import { c as createBirpc } from './index.CJ0plNrh.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.DnTrplSJ.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.DRKU1-1g.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';
-import { slash as slash$1 } from 'vite-node/utils';
+import { slash } from 'vite-node/utils';
 import { isCI, provider } from 'std-env';
-import { r as resolveCoverageProviderModule } from './coverage.0iPg4Wrz.js';
+import { r as resolveCoverageProviderModule } from './coverage.DVF1vEu8.js';
 
 function groupBy(collection, iteratee) {
 	return collection.reduce((acc, item) => {
@@ -39,150 +39,24 @@ function groupBy(collection, iteratee) {
 	}, {});
 }
 function stdout() {
+	// @ts-expect-error Node.js maps process.stdout to console._stdout
+	// eslint-disable-next-line no-console
 	return console._stdout || process.stdout;
 }
 function escapeRegExp(s) {
+	// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
 	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function wildcardPatternToRegExp(pattern) {
 	const negated = pattern.startsWith("!");
-	if (negated) {
-		pattern = pattern.slice(1);
-	}
+	if (negated) pattern = pattern.slice(1);
 	let regexp = `${pattern.split("*").map(escapeRegExp).join(".*")}$`;
-	if (negated) {
-		regexp = `(?!${regexp})`;
-	}
+	if (negated) regexp = `(?!${regexp})`;
 	return new RegExp(`^${regexp}`, "i");
 }
 
 const hash = crypto.hash ?? ((algorithm, data, outputEncoding) => crypto.createHash(algorithm).update(data).digest(outputEncoding));
 
-class FilesStatsCache {
-	cache = 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 = new Map();
-	workspacesKeyMap = 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 || "[]");
-		if (Number(version.split(".")[1]) >= 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;
-			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/vitest");
-		return projectName ? resolve(root, baseDir, hash("md5", projectName, "hex")) : resolve(root, baseDir);
-	}
-}
-
 const JOIN_LEADING_SLASH_RE = /^\.?\//;
 function withTrailingSlash(input = "", respectQueryAndFragment) {
   {
@@ -2363,7 +2237,7 @@ async function findUp$1(name, {
 	while (directory) {
 		const filePath = isAbsoluteName ? name : path.join(directory, name);
 		try {
-			const stats = await fsPromises.stat(filePath); // eslint-disable-line no-await-in-loop
+			const stats = await fs$1.stat(filePath); // eslint-disable-line no-await-in-loop
 			if ((type === 'file' && stats.isFile()) || (type === 'directory' && stats.isDirectory())) {
 				return filePath;
 			}
@@ -2453,7 +2327,7 @@ const getPackageInfo = quansync(function* (name, options = {}) {
   return {
     name,
     version: packageJson.version,
-    rootPath: dirname$1(packageJsonPath),
+    rootPath: dirname(packageJsonPath),
     packageJsonPath,
     packageJson
   };
@@ -2477,7 +2351,7 @@ function searchPackageJSON(dir) {
   while (true) {
     if (!dir)
       return;
-    const newDir = dirname$1(dir);
+    const newDir = dirname(dir);
     if (newDir === dir)
       return;
     dir = newDir;
@@ -2517,32 +2391,29 @@ const envsOrder = [
 	"edge-runtime"
 ];
 function getTransformMode(patterns, filename) {
-	if (patterns.web && pm.isMatch(filename, patterns.web)) {
-		return "web";
-	}
-	if (patterns.ssr && pm.isMatch(filename, patterns.ssr)) {
-		return "ssr";
-	}
-	return undefined;
+	if (patterns.web && pm.isMatch(filename, patterns.web)) return "web";
+	if (patterns.ssr && pm.isMatch(filename, patterns.ssr)) return "ssr";
+	return void 0;
 }
 async function groupFilesByEnv(files) {
 	const filesWithEnv = await Promise.all(files.map(async ({ moduleId: filepath, project, testLines }) => {
 		const code = await promises$1.readFile(filepath, "utf-8");
+		// 1. Check for control comments in the file
 		let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
+		// 2. Check for globals
 		if (!env) {
-			for (const [glob, target] of project.config.environmentMatchGlobs || []) {
-				if (pm.isMatch(filepath, glob, { cwd: project.config.root })) {
-					env = target;
-					break;
-				}
+			for (const [glob, target] of project.config.environmentMatchGlobs || []) if (pm.isMatch(filepath, glob, { cwd: project.config.root })) {
+				env = target;
+				break;
 			}
 		}
+		// 3. Fallback to global env
 		env ||= project.config.environment || "node";
 		const transformMode = getTransformMode(project.config.testTransformMode, filepath);
 		let envOptionsJson = code.match(/@(?:vitest|jest)-environment-options\s+(.+)/)?.[1];
-		if (envOptionsJson?.endsWith("*/")) {
-			envOptionsJson = envOptionsJson.slice(0, -2);
-		}
+		if (envOptionsJson?.endsWith("*/"))
+ // Trim closing Docblock characters the above regex might have captured
+		envOptionsJson = envOptionsJson.slice(0, -2);
 		const envOptions = JSON.parse(envOptionsJson || "null");
 		const envKey = env === "happy-dom" ? "happyDOM" : env;
 		const environment = {
@@ -2562,8 +2433,8 @@ async function groupFilesByEnv(files) {
 	return groupBy(filesWithEnv, ({ environment }) => environment.name);
 }
 
-const created = new Set();
-const promises = new Map();
+const created = /* @__PURE__ */ new Set();
+const promises = /* @__PURE__ */ new Map();
 function createMethodsRPC(project, options = {}) {
 	const ctx = project.vitest;
 	const cacheFs = options.cacheFs ?? false;
@@ -2577,9 +2448,7 @@ function createMethodsRPC(project, options = {}) {
 		async getSourceMap(id, force) {
 			if (force) {
 				const mod = project.vite.moduleGraph.getModuleById(id);
-				if (mod) {
-					project.vite.moduleGraph.invalidateModule(mod);
-				}
+				if (mod) project.vite.moduleGraph.invalidateModule(mod);
 			}
 			const r = await project.vitenode.transformRequest(id);
 			return r?.map;
@@ -2587,15 +2456,9 @@ function createMethodsRPC(project, options = {}) {
 		async fetch(id, transformMode) {
 			const result = await project.vitenode.fetchResult(id, transformMode).catch(handleRollupError);
 			const code = result.code;
-			if (!cacheFs || result.externalize) {
-				return result;
-			}
-			if ("id" in result && typeof result.id === "string") {
-				return { id: result.id };
-			}
-			if (code == null) {
-				throw new Error(`Failed to fetch module ${id}`);
-			}
+			if (!cacheFs || result.externalize) return result;
+			if ("id" in result && typeof result.id === "string") return { id: result.id };
+			if (code == null) throw new Error(`Failed to fetch module ${id}`);
 			const dir = join$1(project.tmpDir, transformMode);
 			const name = hash("sha1", id, "hex");
 			const tmp = join$1(dir, name);
@@ -2619,35 +2482,26 @@ function createMethodsRPC(project, options = {}) {
 			return project.vitenode.transformModule(id, environment).catch(handleRollupError);
 		},
 		async onQueued(file) {
-			if (options.collect) {
-				ctx.state.collectFiles(project, [file]);
-			} else {
-				await ctx._testRun.enqueued(project, file);
-			}
+			if (options.collect) ctx.state.collectFiles(project, [file]);
+			else await ctx._testRun.enqueued(project, file);
 		},
 		async onCollected(files) {
-			if (options.collect) {
-				ctx.state.collectFiles(project, files);
-			} else {
-				await ctx._testRun.collected(project, files);
-			}
+			if (options.collect) ctx.state.collectFiles(project, files);
+			else await ctx._testRun.collected(project, files);
 		},
 		onAfterSuiteRun(meta) {
 			ctx.coverageProvider?.onAfterSuiteRun(meta);
 		},
+		async onTaskAnnotate(testId, annotation) {
+			return ctx._testRun.annotate(testId, annotation);
+		},
 		async onTaskUpdate(packs, events) {
-			if (options.collect) {
-				ctx.state.updateTasks(packs);
-			} else {
-				await ctx._testRun.updated(packs, events);
-			}
+			if (options.collect) ctx.state.updateTasks(packs);
+			else await ctx._testRun.updated(packs, events);
 		},
 		async onUserConsoleLog(log) {
-			if (options.collect) {
-				ctx.state.updateUserLog(log);
-			} else {
-				await ctx._testRun.log(log);
-			}
+			if (options.collect) ctx.state.updateUserLog(log);
+			else await ctx._testRun.log(log);
 		},
 		onUnhandledError(err, type) {
 			ctx.state.catchError(err, type);
@@ -2660,21 +2514,22 @@ function createMethodsRPC(project, options = {}) {
 		}
 	};
 }
+// serialize rollup error on server to preserve details as a test error
 function handleRollupError(e) {
-	if (e instanceof Error && ("plugin" in e || "frame" in e || "id" in e)) {
-		throw {
-			name: e.name,
-			message: e.message,
-			stack: e.stack,
-			cause: e.cause,
-			__vitest_rollup_error__: {
-				plugin: e.plugin,
-				id: e.id,
-				loc: e.loc,
-				frame: e.frame
-			}
-		};
-	}
+	if (e instanceof Error && ("plugin" in e || "frame" in e || "id" in e))
+ // eslint-disable-next-line no-throw-literal
+	throw {
+		name: e.name,
+		message: e.message,
+		stack: e.stack,
+		cause: e.cause,
+		__vitest_rollup_error__: {
+			plugin: e.plugin,
+			id: e.id,
+			loc: e.loc,
+			frame: e.frame
+		}
+	};
 	throw e;
 }
 /**
@@ -2692,30 +2547,28 @@ function handleRollupError(e) {
 * Added in https://github.com/vitest-dev/vitest/pull/7531
 */
 async function atomicWriteFile(realFilePath, data) {
-	const dir = dirname(realFilePath);
+	const dir = dirname$1(realFilePath);
 	const tmpFilePath = join$1(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 	try {
 		await writeFile(tmpFilePath, data, "utf-8");
 		await rename(tmpFilePath, realFilePath);
 	} finally {
 		try {
-			if (await stat(tmpFilePath)) {
-				await unlink(tmpFilePath);
-			}
+			if (await stat(tmpFilePath)) await unlink(tmpFilePath);
 		} catch {}
 	}
 }
 
 function createChildProcessChannel$1(project, collect = false) {
 	const emitter = new EventEmitter();
-	const cleanup = () => emitter.removeAllListeners();
 	const events = {
 		message: "message",
 		response: "response"
 	};
 	const channel = {
 		onMessage: (callback) => emitter.on(events.message, callback),
-		postMessage: (message) => emitter.emit(events.response, message)
+		postMessage: (message) => emitter.emit(events.response, message),
+		onClose: () => emitter.removeAllListeners()
 	};
 	const rpc = createBirpc(createMethodsRPC(project, {
 		cacheFs: true,
@@ -2734,34 +2587,30 @@ function createChildProcessChannel$1(project, collect = false) {
 			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
 		}
 	});
-	project.ctx.onCancel((reason) => rpc.onCancel(reason));
-	return {
-		channel,
-		cleanup
-	};
+	project.vitest.onCancel((reason) => rpc.onCancel(reason));
+	return channel;
 }
-function createForksPool(ctx, { execArgv, env }) {
+function createForksPool(vitest, { execArgv, env }) {
 	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-	const poolOptions = ctx.config.poolOptions?.forks ?? {};
-	const maxThreads = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount;
-	const minThreads = poolOptions.minForks ?? ctx.config.minWorkers ?? threadsCount;
-	const worker = resolve$1(ctx.distPath, "workers/forks.js");
+	const threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const poolOptions = vitest.config.poolOptions?.forks ?? {};
+	const maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount;
+	const minThreads = poolOptions.minForks ?? vitest.config.minWorkers ?? threadsCount;
+	const worker = resolve(vitest.distPath, "workers/forks.js");
 	const options = {
 		runtime: "child_process",
-		filename: resolve$1(ctx.distPath, "worker.js"),
+		filename: resolve(vitest.distPath, "worker.js"),
+		teardown: "teardown",
 		maxThreads,
 		minThreads,
 		env,
 		execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
-		terminateTimeout: ctx.config.teardownTimeout,
+		terminateTimeout: vitest.config.teardownTimeout,
 		concurrentTasksPerWorker: 1
 	};
 	const isolated = poolOptions.isolate ?? true;
-	if (isolated) {
-		options.isolateWorkers = true;
-	}
-	if (poolOptions.singleFork || !ctx.config.fileParallelism) {
+	if (isolated) options.isolateWorkers = true;
+	if (poolOptions.singleFork || !vitest.config.fileParallelism) {
 		options.maxThreads = 1;
 		options.minThreads = 1;
 	}
@@ -2770,8 +2619,8 @@ function createForksPool(ctx, { execArgv, env }) {
 		let id = 0;
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
-			ctx.state.clearFiles(project, paths);
-			const { channel, cleanup } = createChildProcessChannel$1(project, name === "collect");
+			vitest.state.clearFiles(project, paths);
+			const channel = createChildProcessChannel$1(project, name === "collect");
 			const workerId = ++id;
 			const data = {
 				pool: "forks",
@@ -2790,24 +2639,18 @@ function createForksPool(ctx, { execArgv, env }) {
 					channel
 				});
 			} catch (error) {
-				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-					ctx.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}.`);
-				} else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-					ctx.state.cancelFiles(paths, project);
-				} else {
-					throw error;
-				}
-			} finally {
-				cleanup();
+				// Worker got stuck and won't terminate - this may cause process to hang
+				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) vitest.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}.`);
+				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
+				else throw error;
 			}
 		}
 		return async (specs, invalidates) => {
-			ctx.onCancel(() => pool.cancelPendingTasks());
-			const configs = new WeakMap();
+			// Cancel pending tasks from pool when possible
+			vitest.onCancel(() => pool.cancelPendingTasks());
+			const configs = /* @__PURE__ */ new WeakMap();
 			const getConfig = (project) => {
-				if (configs.has(project)) {
-					return configs.get(project);
-				}
+				if (configs.has(project)) return configs.get(project);
 				const _config = project.getSerializableConfig();
 				const config = wrapSerializableConfig(_config);
 				configs.set(project, config);
@@ -2819,31 +2662,32 @@ function createForksPool(ctx, { execArgv, env }) {
 				const filesByEnv = await groupFilesByEnv(multipleForks);
 				const files = Object.values(filesByEnv).flat();
 				const results = [];
-				if (isolated) {
-					results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
-				} else {
+				if (isolated) results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+				else {
+					// When isolation is disabled, we still need to isolate environments and workspace projects from each other.
+					// Tasks are still running parallel but environments are isolated between tasks.
 					const grouped = groupBy(files, ({ project, environment }) => project.name + environment.name + JSON.stringify(environment.options));
 					for (const group of Object.values(grouped)) {
+						// Push all files to pool's queue
 						results.push(...await Promise.allSettled(group.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+						// Once all tasks are running or finished, recycle worker for isolation.
+						// On-going workers will run in the previous environment.
 						await new Promise((resolve) => pool.queueSize === 0 ? resolve() : pool.once("drain", resolve));
 						await pool.recycleWorkers();
 					}
 				}
 				const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-				if (errors.length > 0) {
-					throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
-				}
+				if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
 			}
 			if (singleFork.length) {
 				const filesByEnv = await groupFilesByEnv(singleFork);
 				const envs = envsOrder.concat(Object.keys(filesByEnv).filter((env) => !envsOrder.includes(env)));
 				for (const env of envs) {
 					const files = filesByEnv[env];
-					if (!files?.length) {
-						continue;
-					}
+					if (!files?.length) continue;
 					const filesByOptions = groupBy(files, ({ project, environment }) => project.name + JSON.stringify(environment.options));
 					for (const files of Object.values(filesByOptions)) {
+						// Always run environments isolated between each other
 						await pool.recycleWorkers();
 						const filenames = files.map((f) => f.file);
 						await runFiles(files[0].project, getConfig(files[0].project), filenames, files[0].environment, invalidates);
@@ -2876,34 +2720,33 @@ function createWorkerChannel$1(project, collect) {
 			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
 		}
 	});
-	project.ctx.onCancel((reason) => rpc.onCancel(reason));
+	project.vitest.onCancel((reason) => rpc.onCancel(reason));
 	return {
 		workerPort,
 		port
 	};
 }
-function createThreadsPool(ctx, { execArgv, env }) {
+function createThreadsPool(vitest, { execArgv, env }) {
 	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-	const poolOptions = ctx.config.poolOptions?.threads ?? {};
-	const maxThreads = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount;
-	const minThreads = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount;
-	const worker = resolve$1(ctx.distPath, "workers/threads.js");
+	const threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const poolOptions = vitest.config.poolOptions?.threads ?? {};
+	const maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount;
+	const minThreads = poolOptions.minThreads ?? vitest.config.minWorkers ?? threadsCount;
+	const worker = resolve(vitest.distPath, "workers/threads.js");
 	const options = {
-		filename: resolve$1(ctx.distPath, "worker.js"),
+		filename: resolve(vitest.distPath, "worker.js"),
+		teardown: "teardown",
 		useAtomics: poolOptions.useAtomics ?? false,
 		maxThreads,
 		minThreads,
 		env,
 		execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
-		terminateTimeout: ctx.config.teardownTimeout,
+		terminateTimeout: vitest.config.teardownTimeout,
 		concurrentTasksPerWorker: 1
 	};
 	const isolated = poolOptions.isolate ?? true;
-	if (isolated) {
-		options.isolateWorkers = true;
-	}
-	if (poolOptions.singleThread || !ctx.config.fileParallelism) {
+	if (isolated) options.isolateWorkers = true;
+	if (poolOptions.singleThread || !vitest.config.fileParallelism) {
 		options.maxThreads = 1;
 		options.minThreads = 1;
 	}
@@ -2912,8 +2755,12 @@ function createThreadsPool(ctx, { execArgv, env }) {
 		let id = 0;
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
-			ctx.state.clearFiles(project, paths);
+			vitest.state.clearFiles(project, paths);
 			const { workerPort, port } = createWorkerChannel$1(project, name === "collect");
+			const onClose = () => {
+				port.close();
+				workerPort.close();
+			};
 			const workerId = ++id;
 			const data = {
 				pool: "threads",
@@ -2930,29 +2777,23 @@ function createThreadsPool(ctx, { execArgv, env }) {
 			try {
 				await pool.run(data, {
 					transferList: [workerPort],
-					name
+					name,
+					channel: { onClose }
 				});
 			} catch (error) {
-				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-					ctx.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}. \nSee https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`);
-				} else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-					ctx.state.cancelFiles(paths, project);
-				} else {
-					throw error;
-				}
-			} finally {
-				port.close();
-				workerPort.close();
+				// Worker got stuck and won't terminate - this may cause process to hang
+				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) vitest.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}. \nSee https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`);
+				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
+				else throw error;
 			}
 		}
 		return async (specs, invalidates) => {
-			ctx.onCancel(() => pool.cancelPendingTasks());
-			const configs = new WeakMap();
+			// Cancel pending tasks from pool when possible
+			vitest.onCancel(() => pool.cancelPendingTasks());
+			const configs = /* @__PURE__ */ new WeakMap();
 			const getConfig = (project) => {
-				if (configs.has(project)) {
-					return configs.get(project);
-				}
-				const config = project.getSerializableConfig();
+				if (configs.has(project)) return configs.get(project);
+				const config = project.serializedConfig;
 				configs.set(project, config);
 				return config;
 			};
@@ -2962,31 +2803,32 @@ function createThreadsPool(ctx, { execArgv, env }) {
 				const filesByEnv = await groupFilesByEnv(multipleThreads);
 				const files = Object.values(filesByEnv).flat();
 				const results = [];
-				if (isolated) {
-					results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
-				} else {
+				if (isolated) results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+				else {
+					// When isolation is disabled, we still need to isolate environments and workspace projects from each other.
+					// Tasks are still running parallel but environments are isolated between tasks.
 					const grouped = groupBy(files, ({ project, environment }) => project.name + environment.name + JSON.stringify(environment.options));
 					for (const group of Object.values(grouped)) {
+						// Push all files to pool's queue
 						results.push(...await Promise.allSettled(group.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+						// Once all tasks are running or finished, recycle worker for isolation.
+						// On-going workers will run in the previous environment.
 						await new Promise((resolve) => pool.queueSize === 0 ? resolve() : pool.once("drain", resolve));
 						await pool.recycleWorkers();
 					}
 				}
 				const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-				if (errors.length > 0) {
-					throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
-				}
+				if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
 			}
 			if (singleThreads.length) {
 				const filesByEnv = await groupFilesByEnv(singleThreads);
 				const envs = envsOrder.concat(Object.keys(filesByEnv).filter((env) => !envsOrder.includes(env)));
 				for (const env of envs) {
 					const files = filesByEnv[env];
-					if (!files?.length) {
-						continue;
-					}
+					if (!files?.length) continue;
 					const filesByOptions = groupBy(files, ({ project, environment }) => project.name + JSON.stringify(environment.options));
 					for (const files of Object.values(filesByOptions)) {
+						// Always run environments isolated between each other
 						await pool.recycleWorkers();
 						const filenames = files.map((f) => f.file);
 						await runFiles(files[0].project, getConfig(files[0].project), filenames, files[0].environment, invalidates);
@@ -3004,15 +2846,13 @@ function createThreadsPool(ctx, { execArgv, env }) {
 }
 
 function createTypecheckPool(vitest) {
-	const promisesMap = new WeakMap();
-	const rerunTriggered = new WeakSet();
+	const promisesMap = /* @__PURE__ */ new WeakMap();
+	const rerunTriggered = /* @__PURE__ */ new WeakSet();
 	async function onParseEnd(project, { files, sourceErrors }) {
 		const checker = project.typechecker;
 		const { packs, events } = checker.getTestPacksAndEvents();
 		await vitest._testRun.updated(packs, events);
-		if (!project.config.typecheck.ignoreSourceErrors) {
-			sourceErrors.forEach((error) => vitest.state.catchError(error, "Unhandled Source Error"));
-		}
+		if (!project.config.typecheck.ignoreSourceErrors) sourceErrors.forEach((error) => vitest.state.catchError(error, "Unhandled Source Error"));
 		const processError = !hasFailed(files) && !sourceErrors.length && checker.getExitCode();
 		if (processError) {
 			const error = new Error(checker.getOutput());
@@ -3021,6 +2861,7 @@ function createTypecheckPool(vitest) {
 		}
 		promisesMap.get(project)?.resolve();
 		rerunTriggered.delete(project);
+		// triggered by TSC watcher, not Vitest watcher, so we need to emulate what Vitest does in this case
 		if (vitest.config.watch && !vitest.runningPromise) {
 			await vitest.report("onFinished", files, []);
 			await vitest.report("onWatcherStart", files, [...project.config.typecheck.ignoreSourceErrors ? [] : sourceErrors, ...vitest.state.getUnhandledErrors()]);
@@ -3028,16 +2869,12 @@ function createTypecheckPool(vitest) {
 	}
 	async function createWorkspaceTypechecker(project, files) {
 		const checker = project.typechecker ?? new Typechecker(project);
-		if (project.typechecker) {
-			return checker;
-		}
+		if (project.typechecker) return checker;
 		project.typechecker = checker;
 		checker.setFiles(files);
 		checker.onParseStart(async () => {
 			const files = checker.getTestFiles();
-			for (const file of files) {
-				await vitest._testRun.enqueued(project, file);
-			}
+			for (const file of files) await vitest._testRun.enqueued(project, file);
 			await vitest._testRun.collected(project, files);
 		});
 		checker.onParseEnd((result) => onParseEnd(project, result));
@@ -3049,9 +2886,7 @@ function createTypecheckPool(vitest) {
 			}
 			await checker.collectTests();
 			const testFiles = checker.getTestFiles();
-			for (const file of testFiles) {
-				await vitest._testRun.enqueued(project, file);
-			}
+			for (const file of testFiles) await vitest._testRun.enqueued(project, file);
 			await vitest._testRun.collected(project, testFiles);
 			const { packs, events } = checker.getTestPacksAndEvents();
 			await vitest._testRun.updated(packs, events);
@@ -3059,9 +2894,7 @@ function createTypecheckPool(vitest) {
 		return checker;
 	}
 	async function startTypechecker(project, files) {
-		if (project.typechecker) {
-			return project.typechecker;
-		}
+		if (project.typechecker) return;
 		const checker = await createWorkspaceTypechecker(project, files);
 		await checker.collectTests();
 		await checker.start();
@@ -3085,6 +2918,7 @@ function createTypecheckPool(vitest) {
 			const project = specsByProject[name][0].project;
 			const files = specsByProject[name].map((spec) => spec.moduleId);
 			const promise = createDefer();
+			// check that watcher actually triggered rerun
 			const _p = new Promise((resolve) => {
 				const _i = setInterval(() => {
 					if (!project.typechecker || rerunTriggered.has(project)) {
@@ -3100,16 +2934,14 @@ function createTypecheckPool(vitest) {
 			const triggered = await _p;
 			if (project.typechecker && !triggered) {
 				const testFiles = project.typechecker.getTestFiles();
-				for (const file of testFiles) {
-					await vitest._testRun.enqueued(project, file);
-				}
+				for (const file of testFiles) await vitest._testRun.enqueued(project, file);
 				await vitest._testRun.collected(project, testFiles);
 				await onParseEnd(project, project.typechecker.getResult());
 				continue;
 			}
 			promises.push(promise);
 			promisesMap.set(project, promise);
-			startTypechecker(project, files);
+			promises.push(startTypechecker(project, files));
 		}
 		await Promise.all(promises);
 	}
@@ -3131,16 +2963,12 @@ function getDefaultThreadsCount(config) {
 function getWorkerMemoryLimit(config, pool) {
 	if (pool === "vmForks") {
 		const opts = config.poolOptions?.vmForks ?? {};
-		if (opts.memoryLimit) {
-			return opts.memoryLimit;
-		}
+		if (opts.memoryLimit) return opts.memoryLimit;
 		const workers = opts.maxForks ?? getDefaultThreadsCount(config);
 		return 1 / workers;
 	} else {
 		const opts = config.poolOptions?.vmThreads ?? {};
-		if (opts.memoryLimit) {
-			return opts.memoryLimit;
-		}
+		if (opts.memoryLimit) return opts.memoryLimit;
 		const workers = opts.maxThreads ?? getDefaultThreadsCount(config);
 		return 1 / workers;
 	}
@@ -3152,51 +2980,36 @@ function getWorkerMemoryLimit(config, pool) {
 * @param percentageReference The reference value to use when a '%' value is supplied.
 */
 function stringToBytes(input, percentageReference) {
-	if (input === null || input === undefined) {
-		return input;
-	}
-	if (typeof input === "string") {
-		if (Number.isNaN(Number.parseFloat(input.slice(-1)))) {
-			let [, numericString, trailingChars] = input.match(/(.*?)([^0-9.-]+)$/) || [];
-			if (trailingChars && numericString) {
-				const numericValue = Number.parseFloat(numericString);
-				trailingChars = trailingChars.toLowerCase();
-				switch (trailingChars) {
-					case "%":
-						input = numericValue / 100;
-						break;
-					case "kb":
-					case "k": return numericValue * 1e3;
-					case "kib": return numericValue * 1024;
-					case "mb":
-					case "m": return numericValue * 1e3 * 1e3;
-					case "mib": return numericValue * 1024 * 1024;
-					case "gb":
-					case "g": return numericValue * 1e3 * 1e3 * 1e3;
-					case "gib": return numericValue * 1024 * 1024 * 1024;
-				}
-			}
-		} else {
-			input = Number.parseFloat(input);
-		}
-	}
-	if (typeof input === "number") {
-		if (input <= 1 && input > 0) {
-			if (percentageReference) {
-				return Math.floor(input * percentageReference);
-			} else {
-				throw new Error("For a percentage based memory limit a percentageReference must be supplied");
+	if (input === null || input === void 0) return input;
+	if (typeof input === "string") if (Number.isNaN(Number.parseFloat(input.slice(-1)))) {
+		let [, numericString, trailingChars] = input.match(/(.*?)([^0-9.-]+)$/) || [];
+		if (trailingChars && numericString) {
+			const numericValue = Number.parseFloat(numericString);
+			trailingChars = trailingChars.toLowerCase();
+			switch (trailingChars) {
+				case "%":
+					input = numericValue / 100;
+					break;
+				case "kb":
+				case "k": return numericValue * 1e3;
+				case "kib": return numericValue * 1024;
+				case "mb":
+				case "m": return numericValue * 1e3 * 1e3;
+				case "mib": return numericValue * 1024 * 1024;
+				case "gb":
+				case "g": return numericValue * 1e3 * 1e3 * 1e3;
+				case "gib": return numericValue * 1024 * 1024 * 1024;
 			}
-		} else if (input > 1) {
-			return Math.floor(input);
-		} else {
-			throw new Error("Unexpected numerical input for \"memoryLimit\"");
 		}
-	}
+	} else input = Number.parseFloat(input);
+	if (typeof input === "number") if (input <= 1 && input > 0) if (percentageReference) return Math.floor(input * percentageReference);
+	else throw new Error("For a percentage based memory limit a percentageReference must be supplied");
+	else if (input > 1) return Math.floor(input);
+	else throw new Error("Unexpected numerical input for \"memoryLimit\"");
 	return null;
 }
 
-const suppressWarningsPath$1 = resolve$1(rootDir, "./suppress-warnings.cjs");
+const suppressWarningsPath$1 = resolve(rootDir, "./suppress-warnings.cjs");
 function createChildProcessChannel(project, collect) {
 	const emitter = new EventEmitter();
 	const cleanup = () => emitter.removeAllListeners();
@@ -3225,22 +3038,22 @@ function createChildProcessChannel(project, collect) {
 			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
 		}
 	});
-	project.ctx.onCancel((reason) => rpc.onCancel(reason));
+	project.vitest.onCancel((reason) => rpc.onCancel(reason));
 	return {
 		channel,
 		cleanup
 	};
 }
-function createVmForksPool(ctx, { execArgv, env }) {
+function createVmForksPool(vitest, { execArgv, env }) {
 	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-	const poolOptions = ctx.config.poolOptions?.vmForks ?? {};
-	const maxThreads = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount;
-	const minThreads = poolOptions.maxForks ?? ctx.config.minWorkers ?? threadsCount;
-	const worker = resolve$1(ctx.distPath, "workers/vmForks.js");
+	const threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const poolOptions = vitest.config.poolOptions?.vmForks ?? {};
+	const maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount;
+	const minThreads = poolOptions.maxForks ?? vitest.config.minWorkers ?? threadsCount;
+	const worker = resolve(vitest.distPath, "workers/vmForks.js");
 	const options = {
 		runtime: "child_process",
-		filename: resolve$1(ctx.distPath, "worker.js"),
+		filename: resolve(vitest.distPath, "worker.js"),
 		maxThreads,
 		minThreads,
 		env,
@@ -3252,11 +3065,11 @@ function createVmForksPool(ctx, { execArgv, env }) {
 			...poolOptions.execArgv ?? [],
 			...execArgv
 		],
-		terminateTimeout: ctx.config.teardownTimeout,
+		terminateTimeout: vitest.config.teardownTimeout,
 		concurrentTasksPerWorker: 1,
-		maxMemoryLimitBeforeRecycle: getMemoryLimit$1(ctx.config) || undefined
+		maxMemoryLimitBeforeRecycle: getMemoryLimit$1(vitest.config) || void 0
 	};
-	if (poolOptions.singleFork || !ctx.config.fileParallelism) {
+	if (poolOptions.singleFork || !vitest.config.fileParallelism) {
 		options.maxThreads = 1;
 		options.minThreads = 1;
 	}
@@ -3265,7 +3078,7 @@ function createVmForksPool(ctx, { execArgv, env }) {
 		let id = 0;
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
-			ctx.state.clearFiles(project, paths);
+			vitest.state.clearFiles(project, paths);
 			const { channel, cleanup } = createChildProcessChannel(project, name === "collect");
 			const workerId = ++id;
 			const data = {
@@ -3285,25 +3098,21 @@ function createVmForksPool(ctx, { execArgv, env }) {
 					channel
 				});
 			} catch (error) {
-				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-					ctx.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}.`);
-				} else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-					ctx.state.cancelFiles(paths, project);
-				} else {
-					throw error;
-				}
+				// Worker got stuck and won't terminate - this may cause process to hang
+				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) vitest.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}.`);
+				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
+				else throw error;
 			} finally {
 				cleanup();
 			}
 		}
 		return async (specs, invalidates) => {
-			ctx.onCancel(() => pool.cancelPendingTasks());
-			const configs = new Map();
+			// Cancel pending tasks from pool when possible
+			vitest.onCancel(() => pool.cancelPendingTasks());
+			const configs = /* @__PURE__ */ new Map();
 			const getConfig = (project) => {
-				if (configs.has(project)) {
-					return configs.get(project);
-				}
-				const _config = project.getSerializableConfig();
+				if (configs.has(project)) return configs.get(project);
+				const _config = project.serializedConfig;
 				const config = wrapSerializableConfig(_config);
 				configs.set(project, config);
 				return config;
@@ -3312,9 +3121,7 @@ function createVmForksPool(ctx, { execArgv, env }) {
 			const promises = Object.values(filesByEnv).flat();
 			const results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)));
 			const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-			if (errors.length > 0) {
-				throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
-			}
+			if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
 		};
 	};
 	return {
@@ -3327,16 +3134,14 @@ function createVmForksPool(ctx, { execArgv, env }) {
 function getMemoryLimit$1(config) {
 	const memory = nodeos.totalmem();
 	const limit = getWorkerMemoryLimit(config, "vmForks");
-	if (typeof memory === "number") {
-		return stringToBytes(limit, config.watch ? memory / 2 : memory);
-	}
-	if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") {
-		return stringToBytes(limit);
-	}
+	if (typeof memory === "number") return stringToBytes(limit, config.watch ? memory / 2 : memory);
+	// If totalmem is not supported we cannot resolve percentage based values like 0.5, "50%"
+	if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") return stringToBytes(limit);
+	// just ignore "memoryLimit" value because we cannot detect memory limit
 	return null;
 }
 
-const suppressWarningsPath = resolve$1(rootDir, "./suppress-warnings.cjs");
+const suppressWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
 function createWorkerChannel(project, collect) {
 	const channel = new MessageChannel();
 	const port = channel.port2;
@@ -3353,21 +3158,21 @@ function createWorkerChannel(project, collect) {
 			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
 		}
 	});
-	project.ctx.onCancel((reason) => rpc.onCancel(reason));
+	project.vitest.onCancel((reason) => rpc.onCancel(reason));
 	return {
 		workerPort,
 		port
 	};
 }
-function createVmThreadsPool(ctx, { execArgv, env }) {
+function createVmThreadsPool(vitest, { execArgv, env }) {
 	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-	const poolOptions = ctx.config.poolOptions?.vmThreads ?? {};
-	const maxThreads = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount;
-	const minThreads = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount;
-	const worker = resolve$1(ctx.distPath, "workers/vmThreads.js");
+	const threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const poolOptions = vitest.config.poolOptions?.vmThreads ?? {};
+	const maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount;
+	const minThreads = poolOptions.minThreads ?? vitest.config.minWorkers ?? threadsCount;
+	const worker = resolve(vitest.distPath, "workers/vmThreads.js");
 	const options = {
-		filename: resolve$1(ctx.distPath, "worker.js"),
+		filename: resolve(vitest.distPath, "worker.js"),
 		useAtomics: poolOptions.useAtomics ?? false,
 		maxThreads,
 		minThreads,
@@ -3380,11 +3185,11 @@ function createVmThreadsPool(ctx, { execArgv, env }) {
 			...poolOptions.execArgv ?? [],
 			...execArgv
 		],
-		terminateTimeout: ctx.config.teardownTimeout,
+		terminateTimeout: vitest.config.teardownTimeout,
 		concurrentTasksPerWorker: 1,
-		maxMemoryLimitBeforeRecycle: getMemoryLimit(ctx.config) || undefined
+		maxMemoryLimitBeforeRecycle: getMemoryLimit(vitest.config) || void 0
 	};
-	if (poolOptions.singleThread || !ctx.config.fileParallelism) {
+	if (poolOptions.singleThread || !vitest.config.fileParallelism) {
 		options.maxThreads = 1;
 		options.minThreads = 1;
 	}
@@ -3393,7 +3198,7 @@ function createVmThreadsPool(ctx, { execArgv, env }) {
 		let id = 0;
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
-			ctx.state.clearFiles(project, paths);
+			vitest.state.clearFiles(project, paths);
 			const { workerPort, port } = createWorkerChannel(project, name === "collect");
 			const workerId = ++id;
 			const data = {
@@ -3414,25 +3219,21 @@ function createVmThreadsPool(ctx, { execArgv, env }) {
 					name
 				});
 			} catch (error) {
-				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-					ctx.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}. \nSee https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`);
-				} else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-					ctx.state.cancelFiles(paths, project);
-				} else {
-					throw error;
-				}
+				// Worker got stuck and won't terminate - this may cause process to hang
+				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) vitest.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}. \nSee https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`);
+				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
+				else throw error;
 			} finally {
 				port.close();
 				workerPort.close();
 			}
 		}
 		return async (specs, invalidates) => {
-			ctx.onCancel(() => pool.cancelPendingTasks());
-			const configs = new Map();
+			// Cancel pending tasks from pool when possible
+			vitest.onCancel(() => pool.cancelPendingTasks());
+			const configs = /* @__PURE__ */ new Map();
 			const getConfig = (project) => {
-				if (configs.has(project)) {
-					return configs.get(project);
-				}
+				if (configs.has(project)) return configs.get(project);
 				const config = project.serializedConfig;
 				configs.set(project, config);
 				return config;
@@ -3441,9 +3242,7 @@ function createVmThreadsPool(ctx, { execArgv, env }) {
 			const promises = Object.values(filesByEnv).flat();
 			const results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)));
 			const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-			if (errors.length > 0) {
-				throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
-			}
+			if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
 		};
 	};
 	return {
@@ -3456,12 +3255,10 @@ function createVmThreadsPool(ctx, { execArgv, env }) {
 function getMemoryLimit(config) {
 	const memory = nodeos.totalmem();
 	const limit = getWorkerMemoryLimit(config, "vmThreads");
-	if (typeof memory === "number") {
-		return stringToBytes(limit, config.watch ? memory / 2 : memory);
-	}
-	if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") {
-		return stringToBytes(limit);
-	}
+	if (typeof memory === "number") return stringToBytes(limit, config.watch ? memory / 2 : memory);
+	// If totalmem is not supported we cannot resolve percentage based values like 0.5, "50%"
+	if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") return stringToBytes(limit);
+	// just ignore "memoryLimit" value because we cannot detect memory limit
 	return null;
 }
 
@@ -3474,19 +3271,13 @@ const builtinPools = [
 	"typescript"
 ];
 function getDefaultPoolName(project) {
-	if (project.config.browser.enabled) {
-		return "browser";
-	}
+	if (project.config.browser.enabled) return "browser";
 	return project.config.pool;
 }
 function getFilePoolName(project, file) {
 	for (const [glob, pool] of project.config.poolMatchGlobs) {
-		if (pool === "browser") {
-			throw new Error("Since Vitest 0.31.0 \"browser\" pool is not supported in \"poolMatchGlobs\". You can create a project to run some of your tests in browser in parallel. Read more: https://vitest.dev/guide/projects");
-		}
-		if (pm.isMatch(file, glob, { cwd: project.config.root })) {
-			return pool;
-		}
+		if (pool === "browser") throw new Error("Since Vitest 0.31.0 \"browser\" pool is not supported in \"poolMatchGlobs\". You can create a project to run some of your tests in browser in parallel. Read more: https://vitest.dev/guide/projects");
+		if (pm.isMatch(file, glob, { cwd: project.config.root })) return pool;
 	}
 	return getDefaultPoolName(project);
 }
@@ -3499,6 +3290,8 @@ function createPool(ctx) {
 		vmForks: null,
 		typescript: null
 	};
+	// in addition to resolve.conditions Vite also adds production/development,
+	// see: https://github.com/vitejs/vite/blob/af2aa09575229462635b7cbb6d248ca853057ba2/packages/vite/src/node/plugins/resolve.ts#L1056-L1080
 	const viteMajor = Number(version.split(".")[0]);
 	const potentialConditions = new Set(viteMajor >= 6 ? ctx.vite.config.ssr.resolve?.conditions ?? [] : [
 		"production",
@@ -3506,19 +3299,15 @@ function createPool(ctx) {
 		...ctx.vite.config.resolve.conditions
 	]);
 	const conditions = [...potentialConditions].filter((condition) => {
-		if (condition === "production") {
-			return ctx.vite.config.isProduction;
-		}
-		if (condition === "development") {
-			return !ctx.vite.config.isProduction;
-		}
+		if (condition === "production") return ctx.vite.config.isProduction;
+		if (condition === "development") return !ctx.vite.config.isProduction;
 		return true;
 	}).map((condition) => {
-		if (viteMajor >= 6 && condition === "development|production") {
-			return ctx.vite.config.isProduction ? "production" : "development";
-		}
+		if (viteMajor >= 6 && condition === "development|production") return ctx.vite.config.isProduction ? "production" : "development";
 		return condition;
 	}).flatMap((c) => ["--conditions", c]);
+	// Instead of passing whole process.execArgv to the workers, pick allowed options.
+	// Some options may crash worker, e.g. --prof, --title. nodejs/node#41103
 	const execArgv = process.execArgv.filter((execArg) => execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"));
 	async function executeTests(method, files, invalidate) {
 		const options = {
@@ -3533,35 +3322,22 @@ function createPool(ctx) {
 				...ctx.config.env
 			}
 		};
-		if (isWindows) {
-			for (const name in options.env) {
-				options.env[name.toUpperCase()] = options.env[name];
-			}
-		}
-		const poolConcurrentPromises = new Map();
-		const customPools = new Map();
+		// env are case-insensitive on Windows, but spawned processes don't support it
+		if (isWindows) for (const name in options.env) options.env[name.toUpperCase()] = options.env[name];
+		const poolConcurrentPromises = /* @__PURE__ */ new Map();
+		const customPools = /* @__PURE__ */ new Map();
 		async function resolveCustomPool(filepath) {
-			if (customPools.has(filepath)) {
-				return customPools.get(filepath);
-			}
+			if (customPools.has(filepath)) return customPools.get(filepath);
 			const pool = await ctx.runner.executeId(filepath);
-			if (typeof pool.default !== "function") {
-				throw new TypeError(`Custom pool "${filepath}" must export a function as default export`);
-			}
+			if (typeof pool.default !== "function") throw new TypeError(`Custom pool "${filepath}" must export a function as default export`);
 			const poolInstance = await pool.default(ctx, options);
-			if (typeof poolInstance?.name !== "string") {
-				throw new TypeError(`Custom pool "${filepath}" should return an object with "name" property`);
-			}
-			if (typeof poolInstance?.[method] !== "function") {
-				throw new TypeError(`Custom pool "${filepath}" should return an object with "${method}" method`);
-			}
+			if (typeof poolInstance?.name !== "string") throw new TypeError(`Custom pool "${filepath}" should return an object with "name" property`);
+			if (typeof poolInstance?.[method] !== "function") throw new TypeError(`Custom pool "${filepath}" should return an object with "${method}" method`);
 			customPools.set(filepath, poolInstance);
 			return poolInstance;
 		}
 		function getConcurrentPool(pool, fn) {
-			if (poolConcurrentPromises.has(pool)) {
-				return poolConcurrentPromises.get(pool);
-			}
+			if (poolConcurrentPromises.has(pool)) return poolConcurrentPromises.get(pool);
 			const promise = fn().finally(() => {
 				poolConcurrentPromises.delete(pool);
 			});
@@ -3578,7 +3354,7 @@ function createPool(ctx) {
 			});
 		}
 		const groupedSpecifications = {};
-		const groups = new Set();
+		const groups = /* @__PURE__ */ new Set();
 		const factories = {
 			vmThreads: () => createVmThreadsPool(ctx, options),
 			vmForks: () => createVmForksPool(ctx, options),
@@ -3595,17 +3371,13 @@ function createPool(ctx) {
 		const Sequencer = ctx.config.sequence.sequencer;
 		const sequencer = new Sequencer(ctx);
 		async function sortSpecs(specs) {
-			if (ctx.config.shard) {
-				specs = await sequencer.shard(specs);
-			}
+			if (ctx.config.shard) specs = await sequencer.shard(specs);
 			return sequencer.sort(specs);
 		}
 		const sortedGroups = Array.from(groups).sort();
 		for (const group of sortedGroups) {
 			const specifications = groupedSpecifications[group];
-			if (!specifications?.length) {
-				continue;
-			}
+			if (!specifications?.length) continue;
 			const filesByPool = {
 				forks: [],
 				threads: [],
@@ -3620,9 +3392,7 @@ function createPool(ctx) {
 			});
 			await Promise.all(Object.entries(filesByPool).map(async (entry) => {
 				const [pool, files] = entry;
-				if (!files.length) {
-					return null;
-				}
+				if (!files.length) return null;
 				const specs = await sortSpecs(files);
 				if (pool in factories) {
 					const factory = factories[pool];
@@ -3654,6 +3424,7 @@ class BaseSequencer {
 	constructor(ctx) {
 		this.ctx = ctx;
 	}
+	// async so it can be extended by other sequelizers
 	async shard(files) {
 		const { config } = this.ctx;
 		const { index, count } = config.shard;
@@ -3661,7 +3432,7 @@ class BaseSequencer {
 		const shardStart = shardSize * (index - 1);
 		const shardEnd = shardSize * index;
 		return [...files].map((spec) => {
-			const fullPath = resolve(slash$1(config.root), slash$1(spec.moduleId));
+			const fullPath = resolve$1(slash(config.root), slash(spec.moduleId));
 			const specPath = fullPath?.slice(config.root.length);
 			return {
 				spec,
@@ -3669,6 +3440,7 @@ class BaseSequencer {
 			};
 		}).sort((a, b) => a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0).slice(shardStart, shardEnd).map(({ spec }) => spec);
 	}
+	// async so it can be extended by other sequelizers
 	async sort(files) {
 		const cache = this.ctx.cache;
 		return [...files].sort((a, b) => {
@@ -3679,17 +3451,15 @@ class BaseSequencer {
 			if (!aState || !bState) {
 				const statsA = cache.getFileStats(keyA);
 				const statsB = cache.getFileStats(keyB);
-				if (!statsA || !statsB) {
-					return !statsA && statsB ? -1 : !statsB && statsA ? 1 : 0;
-				}
+				// run unknown first
+				if (!statsA || !statsB) return !statsA && statsB ? -1 : !statsB && statsA ? 1 : 0;
+				// run larger files first
 				return statsB.size - statsA.size;
 			}
-			if (aState.failed && !bState.failed) {
-				return -1;
-			}
-			if (!aState.failed && bState.failed) {
-				return 1;
-			}
+			// run failed first
+			if (aState.failed && !bState.failed) return -1;
+			if (!aState.failed && bState.failed) return 1;
+			// run longer first
 			return bState.duration - aState.duration;
 		});
 	}
@@ -3703,22 +3473,14 @@ class RandomSequencer extends BaseSequencer {
 }
 
 function resolvePath(path, root) {
-	return normalize(/* @__PURE__ */ resolveModule(path, { paths: [root] }) ?? resolve(root, path));
+	return normalize(/* @__PURE__ */ resolveModule(path, { paths: [root] }) ?? resolve$1(root, path));
 }
 function parseInspector(inspect) {
-	if (typeof inspect === "boolean" || inspect === undefined) {
-		return {};
-	}
-	if (typeof inspect === "number") {
-		return { port: inspect };
-	}
-	if (inspect.match(/https?:\//)) {
-		throw new Error(`Inspector host cannot be a URL. Use "host:port" instead of "${inspect}"`);
-	}
+	if (typeof inspect === "boolean" || inspect === void 0) return {};
+	if (typeof inspect === "number") return { port: inspect };
+	if (inspect.match(/https?:\//)) throw new Error(`Inspector host cannot be a URL. Use "host:port" instead of "${inspect}"`);
 	const [host, port] = inspect.split(":");
-	if (!port) {
-		return { host };
-	}
+	if (!port) return { host };
 	return {
 		host,
 		port: Number(port) || defaultInspectPort
@@ -3726,51 +3488,28 @@ function parseInspector(inspect) {
 }
 function resolveApiServerConfig(options, defaultPort) {
 	let api;
-	if (options.ui && !options.api) {
-		api = { port: defaultPort };
-	} else if (options.api === true) {
-		api = { port: defaultPort };
-	} else if (typeof options.api === "number") {
-		api = { port: options.api };
-	}
-	if (typeof options.api === "object") {
-		if (api) {
-			if (options.api.port) {
-				api.port = options.api.port;
-			}
-			if (options.api.strictPort) {
-				api.strictPort = options.api.strictPort;
-			}
-			if (options.api.host) {
-				api.host = options.api.host;
-			}
-		} else {
-			api = { ...options.api };
-		}
-	}
+	if (options.ui && !options.api) api = { port: defaultPort };
+	else if (options.api === true) api = { port: defaultPort };
+	else if (typeof options.api === "number") api = { port: options.api };
+	if (typeof options.api === "object") if (api) {
+		if (options.api.port) api.port = options.api.port;
+		if (options.api.strictPort) api.strictPort = options.api.strictPort;
+		if (options.api.host) api.host = options.api.host;
+	} else api = { ...options.api };
 	if (api) {
-		if (!api.port && !api.middlewareMode) {
-			api.port = defaultPort;
-		}
-	} else {
-		api = { middlewareMode: true };
-	}
+		if (!api.port && !api.middlewareMode) api.port = defaultPort;
+	} else api = { middlewareMode: true };
 	return api;
 }
 function resolveInlineWorkerOption(value) {
-	if (typeof value === "string" && value.trim().endsWith("%")) {
-		return getWorkersCountByPercentage(value);
-	} else {
-		return Number(value);
-	}
+	if (typeof value === "string" && value.trim().endsWith("%")) return getWorkersCountByPercentage(value);
+	else return Number(value);
 }
 function resolveConfig$1(vitest, options, viteConfig) {
 	const mode = vitest.mode;
 	const logger = vitest.logger;
 	if (options.dom) {
-		if (viteConfig.test?.environment != null && viteConfig.test.environment !== "happy-dom") {
-			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} Your config.test.environment ("${viteConfig.test.environment}") conflicts with --dom flag ("happy-dom"), ignoring "${viteConfig.test.environment}"`));
-		}
+		if (viteConfig.test?.environment != null && viteConfig.test.environment !== "happy-dom") logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} Your config.test.environment ("${viteConfig.test.environment}") conflicts with --dom flag ("happy-dom"), ignoring "${viteConfig.test.environment}"`));
 		options.environment = "happy-dom";
 	}
 	const resolved = {
@@ -3782,7 +3521,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.project = toArray(resolved.project);
 	resolved.provide ??= {};
 	resolved.name = typeof options.name === "string" ? options.name : options.name?.label || "";
-	resolved.color = typeof options.name !== "string" ? options.name?.color : undefined;
+	resolved.color = typeof options.name !== "string" ? options.name?.color : void 0;
 	const inspector = resolved.inspect || resolved.inspectBrk;
 	resolved.inspector = {
 		...resolved.inspector,
@@ -3790,43 +3529,28 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		enabled: !!inspector,
 		waitForDebugger: options.inspector?.waitForDebugger ?? !!resolved.inspectBrk
 	};
-	if (viteConfig.base !== "/") {
-		resolved.base = viteConfig.base;
-	}
+	if (viteConfig.base !== "/") resolved.base = viteConfig.base;
 	resolved.clearScreen = resolved.clearScreen ?? viteConfig.clearScreen ?? true;
 	if (options.shard) {
-		if (resolved.watch) {
-			throw new Error("You cannot use --shard option with enabled watch");
-		}
+		if (resolved.watch) throw new Error("You cannot use --shard option with enabled watch");
 		const [indexString, countString] = options.shard.split("/");
 		const index = Math.abs(Number.parseInt(indexString, 10));
 		const count = Math.abs(Number.parseInt(countString, 10));
-		if (Number.isNaN(count) || count <= 0) {
-			throw new Error("--shard <count> must be a positive number");
-		}
-		if (Number.isNaN(index) || index <= 0 || index > count) {
-			throw new Error("--shard <index> must be a positive number less then <count>");
-		}
+		if (Number.isNaN(count) || count <= 0) throw new Error("--shard <count> must be a positive number");
+		if (Number.isNaN(index) || index <= 0 || index > count) throw new Error("--shard <index> must be a positive number less then <count>");
 		resolved.shard = {
 			index,
 			count
 		};
 	}
-	if (resolved.standalone && !resolved.watch) {
-		throw new Error(`Vitest standalone mode requires --watch`);
-	}
-	if (resolved.mergeReports && resolved.watch) {
-		throw new Error(`Cannot merge reports with --watch enabled`);
-	}
-	if (resolved.maxWorkers) {
-		resolved.maxWorkers = resolveInlineWorkerOption(resolved.maxWorkers);
-	}
-	if (resolved.minWorkers) {
-		resolved.minWorkers = resolveInlineWorkerOption(resolved.minWorkers);
-	}
-	resolved.browser ??= {};
+	if (resolved.standalone && !resolved.watch) throw new Error(`Vitest standalone mode requires --watch`);
+	if (resolved.mergeReports && resolved.watch) throw new Error(`Cannot merge reports with --watch enabled`);
+	if (resolved.maxWorkers) resolved.maxWorkers = resolveInlineWorkerOption(resolved.maxWorkers);
+	if (resolved.minWorkers) resolved.minWorkers = resolveInlineWorkerOption(resolved.minWorkers);
+	// run benchmark sequentially by default
 	resolved.fileParallelism ??= mode !== "benchmark";
 	if (!resolved.fileParallelism) {
+		// ignore user config, parallelism cannot be implemented without limiting workers
 		resolved.maxWorkers = 1;
 		resolved.minWorkers = 1;
 	}
@@ -3842,65 +3566,53 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			throw new Error(`You cannot use ${inspectOption} without "--no-file-parallelism", "poolOptions.threads.singleThread" or "poolOptions.forks.singleFork"`);
 		}
 	}
+	// apply browser CLI options only if the config already has the browser config and not disabled manually
+	if (vitest._cliOptions.browser && resolved.browser && (resolved.browser.enabled !== false || vitest._cliOptions.browser.enabled)) resolved.browser = mergeConfig(resolved.browser, vitest._cliOptions.browser);
+	resolved.browser ??= {};
 	const browser = resolved.browser;
-	if (browser.enabled && viteConfig.test?.browser) {
-		if (!browser.name && !browser.instances) {
-			throw new Error(`Vitest Browser Mode requires "browser.name" (deprecated) or "browser.instances" options, none were set.`);
-		}
+	if (browser.enabled) {
+		if (!browser.name && !browser.instances) throw new Error(`Vitest Browser Mode requires "browser.name" (deprecated) or "browser.instances" options, none were set.`);
 		const instances = browser.instances;
-		if (browser.name && browser.instances) {
-			browser.instances = browser.instances.filter((instance) => instance.browser === browser.name);
-		}
-		if (browser.instances && !browser.instances.length) {
-			throw new Error([`"browser.instances" was set in the config, but the array is empty. Define at least one browser config.`, browser.name && instances?.length ? ` The "browser.name" was set to "${browser.name}" which filtered all configs (${instances.map((c) => c.browser).join(", ")}). Did you mean to use another name?` : ""].join(""));
-		}
+		if (browser.name && browser.instances)
+ // --browser=chromium filters configs to a single one
+		browser.instances = browser.instances.filter((instance) => instance.browser === browser.name);
+		if (browser.instances && !browser.instances.length) throw new Error([`"browser.instances" was set in the config, but the array is empty. Define at least one browser config.`, browser.name && instances?.length ? ` The "browser.name" was set to "${browser.name}" which filtered all configs (${instances.map((c) => c.browser).join(", ")}). Did you mean to use another name?` : ""].join(""));
 	}
 	const playwrightChromiumOnly = isPlaywrightChromiumOnly(vitest, resolved);
+	// Browser-mode "Playwright + Chromium" only features:
 	if (browser.enabled && !playwrightChromiumOnly) {
 		const browserConfig = { browser: {
 			provider: browser.provider,
 			name: browser.name,
 			instances: browser.instances?.map((i) => ({ browser: i.browser }))
 		} };
-		if (resolved.coverage.enabled && resolved.coverage.provider === "v8") {
-			throw new Error(`@vitest/coverage-v8 does not work with\n${JSON.stringify(browserConfig, null, 2)}\n` + `\nUse either:\n${JSON.stringify({ browser: {
-				provider: "playwright",
-				instances: [{ browser: "chromium" }]
-			} }, null, 2)}` + `\n\n...or change your coverage provider to:\n${JSON.stringify({ coverage: { provider: "istanbul" } }, null, 2)}\n`);
-		}
+		if (resolved.coverage.enabled && resolved.coverage.provider === "v8") throw new Error(`@vitest/coverage-v8 does not work with\n${JSON.stringify(browserConfig, null, 2)}\n\nUse either:\n${JSON.stringify({ browser: {
+			provider: "playwright",
+			instances: [{ browser: "chromium" }]
+		} }, null, 2)}\n\n...or change your coverage provider to:\n${JSON.stringify({ coverage: { provider: "istanbul" } }, null, 2)}\n`);
 		if (resolved.inspect || resolved.inspectBrk) {
 			const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
-			throw new Error(`${inspectOption} does not work with\n${JSON.stringify(browserConfig, null, 2)}\n` + `\nUse either:\n${JSON.stringify({ browser: {
+			throw new Error(`${inspectOption} does not work with\n${JSON.stringify(browserConfig, null, 2)}\n\nUse either:\n${JSON.stringify({ browser: {
 				provider: "playwright",
 				instances: [{ browser: "chromium" }]
-			} }, null, 2)}` + `\n\n...or disable ${inspectOption}\n`);
+			} }, null, 2)}\n\n...or disable ${inspectOption}\n`);
 		}
 	}
 	resolved.coverage.reporter = resolveCoverageReporters(resolved.coverage.reporter);
 	if (resolved.coverage.enabled && resolved.coverage.reportsDirectory) {
-		const reportsDirectory = resolve(resolved.root, resolved.coverage.reportsDirectory);
-		if (reportsDirectory === resolved.root || reportsDirectory === process.cwd()) {
-			throw new Error(`You cannot set "coverage.reportsDirectory" as ${reportsDirectory}. Vitest needs to be able to remove this directory before test run`);
-		}
-	}
-	if (resolved.coverage.enabled && resolved.coverage.provider === "custom" && resolved.coverage.customProviderModule) {
-		resolved.coverage.customProviderModule = resolvePath(resolved.coverage.customProviderModule, resolved.root);
+		const reportsDirectory = resolve$1(resolved.root, resolved.coverage.reportsDirectory);
+		if (reportsDirectory === resolved.root || reportsDirectory === process.cwd()) throw new Error(`You cannot set "coverage.reportsDirectory" as ${reportsDirectory}. Vitest needs to be able to remove this directory before test run`);
 	}
+	if (resolved.coverage.enabled && resolved.coverage.provider === "custom" && resolved.coverage.customProviderModule) resolved.coverage.customProviderModule = resolvePath(resolved.coverage.customProviderModule, resolved.root);
 	resolved.expect ??= {};
 	resolved.deps ??= {};
 	resolved.deps.moduleDirectories ??= [];
 	resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map((dir) => {
-		if (!dir.startsWith("/")) {
-			dir = `/${dir}`;
-		}
-		if (!dir.endsWith("/")) {
-			dir += "/";
-		}
+		if (!dir.startsWith("/")) dir = `/${dir}`;
+		if (!dir.endsWith("/")) dir += "/";
 		return normalize(dir);
 	});
-	if (!resolved.deps.moduleDirectories.includes("/node_modules/")) {
-		resolved.deps.moduleDirectories.push("/node_modules/");
-	}
+	if (!resolved.deps.moduleDirectories.includes("/node_modules/")) resolved.deps.moduleDirectories.push("/node_modules/");
 	resolved.deps.optimizer ??= {};
 	resolved.deps.optimizer.ssr ??= {};
 	resolved.deps.optimizer.ssr.enabled ??= true;
@@ -3912,6 +3624,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.deps.web.transformGlobPattern ??= [];
 	resolved.setupFiles = toArray(resolved.setupFiles || []).map((file) => resolvePath(file, resolved.root));
 	resolved.globalSetup = toArray(resolved.globalSetup || []).map((file) => resolvePath(file, resolved.root));
+	// override original exclude array for cases where user re-uses same object in test.exclude
 	resolved.coverage.exclude = [
 		...resolved.coverage.exclude,
 		...resolved.setupFiles.map((file) => `${resolved.coverage.allowExternal ? "**/" : ""}${relative(resolved.root, file)}`),
@@ -3926,27 +3639,21 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		"fallbackCJS"
 	];
 	deprecatedDepsOptions.forEach((option) => {
-		if (resolved.deps[option] === undefined) {
-			return;
-		}
-		if (option === "fallbackCJS") {
-			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. Use "server.deps.${option}" instead`));
-		} else {
+		if (resolved.deps[option] === void 0) return;
+		if (option === "fallbackCJS") logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. Use "server.deps.${option}" instead`));
+		else {
 			const transformMode = resolved.environment === "happy-dom" || resolved.environment === "jsdom" ? "web" : "ssr";
 			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. If you rely on vite-node directly, use "server.deps.${option}" instead. Otherwise, consider using "deps.optimizer.${transformMode}.${option === "external" ? "exclude" : "include"}"`));
 		}
-		if (resolved.server.deps[option] === undefined) {
-			resolved.server.deps[option] = resolved.deps[option];
-		}
+		if (resolved.server.deps[option] === void 0) resolved.server.deps[option] = resolved.deps[option];
 	});
-	if (resolved.cliExclude) {
-		resolved.exclude.push(...resolved.cliExclude);
-	}
+	if (resolved.cliExclude) resolved.exclude.push(...resolved.cliExclude);
+	// vitenode will try to import such file with native node,
+	// but then our mocker will not work properly
 	if (resolved.server.deps.inline !== true) {
 		const ssrOptions = viteConfig.ssr;
-		if (ssrOptions?.noExternal === true && resolved.server.deps.inline == null) {
-			resolved.server.deps.inline = true;
-		} else {
+		if (ssrOptions?.noExternal === true && resolved.server.deps.inline == null) resolved.server.deps.inline = true;
+		else {
 			resolved.server.deps.inline ??= [];
 			resolved.server.deps.inline.push(...extraInlineDeps);
 		}
@@ -3955,16 +3662,11 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.server.deps.inlineFiles.push(...resolved.setupFiles);
 	resolved.server.deps.moduleDirectories ??= [];
 	resolved.server.deps.moduleDirectories.push(...resolved.deps.moduleDirectories);
-	if (resolved.runner) {
-		resolved.runner = resolvePath(resolved.runner, resolved.root);
-	}
-	if (resolved.snapshotEnvironment) {
-		resolved.snapshotEnvironment = resolvePath(resolved.snapshotEnvironment, resolved.root);
-	}
-	resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : undefined;
-	if (resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) {
-		resolved.snapshotFormat.plugins = [];
-	}
+	if (resolved.runner) resolved.runner = resolvePath(resolved.runner, resolved.root);
+	resolved.attachmentsDir = resolve$1(resolved.root, resolved.attachmentsDir ?? ".vitest-attachments");
+	if (resolved.snapshotEnvironment) resolved.snapshotEnvironment = resolvePath(resolved.snapshotEnvironment, resolved.root);
+	resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
+	if (resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) resolved.snapshotFormat.plugins = [];
 	const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
 	resolved.snapshotOptions = {
 		expand: resolved.expandSnapshotDiff ?? false,
@@ -3976,97 +3678,73 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.snapshotSerializers ??= [];
 	resolved.snapshotSerializers = resolved.snapshotSerializers.map((file) => resolvePath(file, resolved.root));
 	resolved.forceRerunTriggers.push(...resolved.snapshotSerializers);
-	if (options.resolveSnapshotPath) {
-		delete resolved.resolveSnapshotPath;
-	}
+	if (options.resolveSnapshotPath) delete resolved.resolveSnapshotPath;
 	resolved.pool ??= "threads";
-	if (process.env.VITEST_MAX_THREADS) {
-		resolved.poolOptions = {
-			...resolved.poolOptions,
-			threads: {
-				...resolved.poolOptions?.threads,
-				maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
-			},
-			vmThreads: {
-				...resolved.poolOptions?.vmThreads,
-				maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
-			}
-		};
-	}
-	if (process.env.VITEST_MIN_THREADS) {
-		resolved.poolOptions = {
-			...resolved.poolOptions,
-			threads: {
-				...resolved.poolOptions?.threads,
-				minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-			},
-			vmThreads: {
-				...resolved.poolOptions?.vmThreads,
-				minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-			}
-		};
-	}
-	if (process.env.VITEST_MAX_FORKS) {
-		resolved.poolOptions = {
-			...resolved.poolOptions,
-			forks: {
-				...resolved.poolOptions?.forks,
-				maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
-			},
-			vmForks: {
-				...resolved.poolOptions?.vmForks,
-				maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
-			}
-		};
-	}
-	if (process.env.VITEST_MIN_FORKS) {
-		resolved.poolOptions = {
-			...resolved.poolOptions,
-			forks: {
-				...resolved.poolOptions?.forks,
-				minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-			},
-			vmForks: {
-				...resolved.poolOptions?.vmForks,
-				minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-			}
-		};
-	}
+	if (process.env.VITEST_MAX_THREADS) resolved.poolOptions = {
+		...resolved.poolOptions,
+		threads: {
+			...resolved.poolOptions?.threads,
+			maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
+		},
+		vmThreads: {
+			...resolved.poolOptions?.vmThreads,
+			maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
+		}
+	};
+	if (process.env.VITEST_MIN_THREADS) resolved.poolOptions = {
+		...resolved.poolOptions,
+		threads: {
+			...resolved.poolOptions?.threads,
+			minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
+		},
+		vmThreads: {
+			...resolved.poolOptions?.vmThreads,
+			minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
+		}
+	};
+	if (process.env.VITEST_MAX_FORKS) resolved.poolOptions = {
+		...resolved.poolOptions,
+		forks: {
+			...resolved.poolOptions?.forks,
+			maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
+		},
+		vmForks: {
+			...resolved.poolOptions?.vmForks,
+			maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
+		}
+	};
+	if (process.env.VITEST_MIN_FORKS) resolved.poolOptions = {
+		...resolved.poolOptions,
+		forks: {
+			...resolved.poolOptions?.forks,
+			minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
+		},
+		vmForks: {
+			...resolved.poolOptions?.vmForks,
+			minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
+		}
+	};
 	const poolThreadsOptions = [
 		["threads", "minThreads"],
 		["threads", "maxThreads"],
 		["vmThreads", "minThreads"],
 		["vmThreads", "maxThreads"]
 	];
-	for (const [poolOptionKey, workerOptionKey] of poolThreadsOptions) {
-		if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) {
-			resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-		}
-	}
+	for (const [poolOptionKey, workerOptionKey] of poolThreadsOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
 	const poolForksOptions = [
 		["forks", "minForks"],
 		["forks", "maxForks"],
 		["vmForks", "minForks"],
 		["vmForks", "maxForks"]
 	];
-	for (const [poolOptionKey, workerOptionKey] of poolForksOptions) {
-		if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) {
-			resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-		}
-	}
-	if (typeof resolved.workspace === "string") {
-		resolved.workspace = typeof options.workspace === "string" && options.workspace[0] === "." ? resolve(process.cwd(), options.workspace) : resolvePath(resolved.workspace, resolved.root);
-	}
-	if (!builtinPools.includes(resolved.pool)) {
-		resolved.pool = resolvePath(resolved.pool, resolved.root);
-	}
-	if (resolved.poolMatchGlobs) {
-		logger.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "poolMatchGlobs" is deprecated. Use "workspace" to define different configurations instead.`));
-	}
+	for (const [poolOptionKey, workerOptionKey] of poolForksOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
+	if (typeof resolved.workspace === "string")
+ // if passed down from the CLI and it's relative, resolve relative to CWD
+	resolved.workspace = typeof options.workspace === "string" && options.workspace[0] === "." ? resolve$1(process.cwd(), options.workspace) : resolvePath(resolved.workspace, resolved.root);
+	if (!builtinPools.includes(resolved.pool)) resolved.pool = resolvePath(resolved.pool, resolved.root);
+	if (resolved.poolMatchGlobs) logger.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "poolMatchGlobs" is deprecated. Use "workspace" to define different configurations instead.`));
 	resolved.poolMatchGlobs = (resolved.poolMatchGlobs || []).map(([glob, pool]) => {
-		if (!builtinPools.includes(pool)) {
-			pool = resolvePath(pool, resolved.root);
-		}
+		if (!builtinPools.includes(pool)) pool = resolvePath(pool, resolved.root);
 		return [glob, pool];
 	});
 	if (mode === "benchmark") {
@@ -4074,92 +3752,81 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			...benchmarkConfigDefaults,
 			...resolved.benchmark
 		};
+		// override test config
 		resolved.coverage.enabled = false;
 		resolved.typecheck.enabled = false;
 		resolved.include = resolved.benchmark.include;
 		resolved.exclude = resolved.benchmark.exclude;
 		resolved.includeSource = resolved.benchmark.includeSource;
 		const reporters = Array.from(new Set([...toArray(resolved.benchmark.reporters), ...toArray(options.reporter)])).filter(Boolean);
-		if (reporters.length) {
-			resolved.benchmark.reporters = reporters;
-		} else {
-			resolved.benchmark.reporters = ["default"];
-		}
-		if (options.outputFile) {
-			resolved.benchmark.outputFile = options.outputFile;
-		}
-		if (options.compare) {
-			resolved.benchmark.compare = options.compare;
-		}
-		if (options.outputJson) {
-			resolved.benchmark.outputJson = options.outputJson;
-		}
+		if (reporters.length) resolved.benchmark.reporters = reporters;
+		else resolved.benchmark.reporters = ["default"];
+		if (options.outputFile) resolved.benchmark.outputFile = options.outputFile;
+		// --compare from cli
+		if (options.compare) resolved.benchmark.compare = options.compare;
+		if (options.outputJson) resolved.benchmark.outputJson = options.outputJson;
 	}
 	if (typeof resolved.diff === "string") {
 		resolved.diff = resolvePath(resolved.diff, resolved.root);
 		resolved.forceRerunTriggers.push(resolved.diff);
 	}
+	// the server has been created, we don't need to override vite.server options
 	const api = resolveApiServerConfig(options, defaultPort);
 	resolved.api = {
 		...api,
 		token: crypto.randomUUID()
 	};
-	if (options.related) {
-		resolved.related = toArray(options.related).map((file) => resolve(resolved.root, file));
-	}
-	if (options.reporters) {
-		if (!Array.isArray(options.reporters)) {
-			if (typeof options.reporters === "string") {
-				resolved.reporters = [[options.reporters, {}]];
-			} else {
-				resolved.reporters = [options.reporters];
-			}
-		} else {
-			resolved.reporters = [];
-			for (const reporter of options.reporters) {
-				if (Array.isArray(reporter)) {
-					resolved.reporters.push([reporter[0], reporter[1] || {}]);
-				} else if (typeof reporter === "string") {
-					resolved.reporters.push([reporter, {}]);
-				} else {
-					resolved.reporters.push(reporter);
-				}
-			}
-		}
+	if (options.related) resolved.related = toArray(options.related).map((file) => resolve$1(resolved.root, file));
+	/*
+	* Reporters can be defined in many different ways:
+	* { reporter: 'json' }
+	* { reporter: { onFinish() { method() } } }
+	* { reporter: ['json', { onFinish() { method() } }] }
+	* { reporter: [[ 'json' ]] }
+	* { reporter: [[ 'json' ], 'html'] }
+	* { reporter: [[ 'json', { outputFile: 'test.json' } ], 'html'] }
+	*/
+	if (options.reporters) if (!Array.isArray(options.reporters))
+ // Reporter name, e.g. { reporters: 'json' }
+	if (typeof options.reporters === "string") resolved.reporters = [[options.reporters, {}]];
+	else resolved.reporters = [options.reporters];
+	else {
+		resolved.reporters = [];
+		for (const reporter of options.reporters) if (Array.isArray(reporter))
+ // Reporter with options, e.g. { reporters: [ [ 'json', { outputFile: 'test.json' } ] ] }
+		resolved.reporters.push([reporter[0], reporter[1] || {}]);
+		else if (typeof reporter === "string")
+ // Reporter name in array, e.g. { reporters: ["html", "json"]}
+		resolved.reporters.push([reporter, {}]);
+		else
+ // Inline reporter, e.g. { reporter: [{ onFinish() { method() } }] }
+		resolved.reporters.push(reporter);
 	}
 	if (mode !== "benchmark") {
+		// @ts-expect-error "reporter" is from CLI, should be absolute to the running directory
+		// it is passed down as "vitest --reporter ../reporter.js"
 		const reportersFromCLI = resolved.reporter;
 		const cliReporters = toArray(reportersFromCLI || []).map((reporter) => {
-			if (/^\.\.?\//.test(reporter)) {
-				return resolve(process.cwd(), reporter);
-			}
+			// ./reporter.js || ../reporter.js, but not .reporters/reporter.js
+			if (/^\.\.?\//.test(reporter)) return resolve$1(process.cwd(), reporter);
 			return reporter;
 		});
-		if (cliReporters.length) {
-			resolved.reporters = Array.from(new Set(toArray(cliReporters))).filter(Boolean).map((reporter) => [reporter, {}]);
-		}
+		if (cliReporters.length) resolved.reporters = Array.from(new Set(toArray(cliReporters))).filter(Boolean).map((reporter) => [reporter, {}]);
 	}
 	if (!resolved.reporters.length) {
 		resolved.reporters.push(["default", {}]);
-		if (process.env.GITHUB_ACTIONS === "true") {
-			resolved.reporters.push(["github-actions", {}]);
-		}
-	}
-	if (resolved.changed) {
-		resolved.passWithNoTests ??= true;
+		// also enable github-actions reporter as a default
+		if (process.env.GITHUB_ACTIONS === "true") resolved.reporters.push(["github-actions", {}]);
 	}
+	if (resolved.changed) resolved.passWithNoTests ??= true;
 	resolved.css ??= {};
 	if (typeof resolved.css === "object") {
 		resolved.css.modules ??= {};
 		resolved.css.modules.classNameStrategy ??= "stable";
 	}
 	if (resolved.cache !== false) {
-		let cacheDir = VitestCache.resolveCacheDir("", viteConfig.cacheDir, resolved.name);
-		if (resolved.cache && resolved.cache.dir) {
-			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "cache.dir" is deprecated, use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir\/vitest"`));
-			cacheDir = VitestCache.resolveCacheDir(resolved.root, resolved.cache.dir, resolved.name);
-		}
-		resolved.cache = { dir: cacheDir };
+		if (resolved.cache && typeof resolved.cache.dir === "string") vitest.logger.deprecate(`"cache.dir" is deprecated, use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir\/vitest"`);
+		resolved.cache = { dir: viteConfig.cacheDir };
 	}
 	resolved.sequence ??= {};
 	if (resolved.sequence.shuffle && typeof resolved.sequence.shuffle === "object") {
@@ -4167,36 +3834,28 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		resolved.sequence.sequencer ??= files ? RandomSequencer : BaseSequencer;
 		resolved.sequence.shuffle = tests;
 	}
-	if (!resolved.sequence?.sequencer) {
-		resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
-	}
+	if (!resolved.sequence?.sequencer)
+ // CLI flag has higher priority
+	resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
 	resolved.sequence.groupOrder ??= 0;
 	resolved.sequence.hooks ??= "stack";
-	if (resolved.sequence.sequencer === RandomSequencer) {
-		resolved.sequence.seed ??= Date.now();
-	}
+	if (resolved.sequence.sequencer === RandomSequencer) resolved.sequence.seed ??= Date.now();
 	resolved.typecheck = {
 		...configDefaults.typecheck,
 		...resolved.typecheck
 	};
-	if (resolved.environmentMatchGlobs) {
-		logger.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "environmentMatchGlobs" is deprecated. Use "workspace" to define different configurations instead.`));
-	}
-	resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve(resolved.root, i[0]), i[1]]);
+	if (resolved.environmentMatchGlobs) logger.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "environmentMatchGlobs" is deprecated. Use "workspace" to define different configurations instead.`));
+	resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve$1(resolved.root, i[0]), i[1]]);
 	resolved.typecheck ??= {};
 	resolved.typecheck.enabled ??= false;
-	if (resolved.typecheck.enabled) {
-		logger.console.warn(c.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."));
-	}
-	resolved.browser ??= {};
+	if (resolved.typecheck.enabled) logger.console.warn(c.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."));
 	resolved.browser.enabled ??= false;
 	resolved.browser.headless ??= isCI;
 	resolved.browser.isolate ??= true;
 	resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark";
+	// disable in headless mode by default, and if CI is detected
 	resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI;
-	if (resolved.browser.screenshotDirectory) {
-		resolved.browser.screenshotDirectory = resolve(resolved.root, resolved.browser.screenshotDirectory);
-	}
+	if (resolved.browser.screenshotDirectory) resolved.browser.screenshotDirectory = resolve$1(resolved.root, resolved.browser.screenshotDirectory);
 	const isPreview = resolved.browser.provider === "preview";
 	if (isPreview && resolved.browser.screenshotFailures === true) {
 		console.warn(c.yellow([
@@ -4205,34 +3864,23 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			`Set "browser.screenshotFailures" to false or remove it from the config to suppress this warning.`
 		].join("")));
 		resolved.browser.screenshotFailures = false;
-	} else {
-		resolved.browser.screenshotFailures ??= !isPreview && !resolved.browser.ui;
-	}
+	} else resolved.browser.screenshotFailures ??= !isPreview && !resolved.browser.ui;
 	resolved.browser.viewport ??= {};
 	resolved.browser.viewport.width ??= 414;
 	resolved.browser.viewport.height ??= 896;
 	resolved.browser.locators ??= {};
 	resolved.browser.locators.testIdAttribute ??= "data-testid";
-	if (resolved.browser.enabled && provider === "stackblitz") {
-		resolved.browser.provider = "preview";
-	}
+	if (resolved.browser.enabled && provider === "stackblitz") resolved.browser.provider = "preview";
 	resolved.browser.api = resolveApiServerConfig(resolved.browser, defaultBrowserPort) || { port: defaultBrowserPort };
+	// enable includeTaskLocation by default in UI mode
 	if (resolved.browser.enabled) {
-		if (resolved.browser.ui) {
-			resolved.includeTaskLocation ??= true;
-		}
-	} else if (resolved.ui) {
-		resolved.includeTaskLocation ??= true;
-	}
+		if (resolved.browser.ui) resolved.includeTaskLocation ??= true;
+	} else if (resolved.ui) resolved.includeTaskLocation ??= true;
 	const htmlReporter = toArray(resolved.reporters).some((reporter) => {
-		if (Array.isArray(reporter)) {
-			return reporter[0] === "html";
-		}
+		if (Array.isArray(reporter)) return reporter[0] === "html";
 		return false;
 	});
-	if (htmlReporter) {
-		resolved.includeTaskLocation ??= true;
-	}
+	if (htmlReporter) resolved.includeTaskLocation ??= true;
 	resolved.testTransformMode ??= {};
 	resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3;
 	resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4;
@@ -4242,38 +3890,27 @@ function isBrowserEnabled(config) {
 	return Boolean(config.browser?.enabled);
 }
 function resolveCoverageReporters(configReporters) {
-	if (!Array.isArray(configReporters)) {
-		return [[configReporters, {}]];
-	}
+	// E.g. { reporter: "html" }
+	if (!Array.isArray(configReporters)) return [[configReporters, {}]];
 	const resolvedReporters = [];
-	for (const reporter of configReporters) {
-		if (Array.isArray(reporter)) {
-			resolvedReporters.push([reporter[0], reporter[1] || {}]);
-		} else {
-			resolvedReporters.push([reporter, {}]);
-		}
-	}
+	for (const reporter of configReporters) if (Array.isArray(reporter))
+ // E.g. { reporter: [ ["html", { skipEmpty: true }], ["lcov"], ["json", { file: "map.json" }] ]}
+	resolvedReporters.push([reporter[0], reporter[1] || {}]);
+	else
+ // E.g. { reporter: ["html", "json"]}
+	resolvedReporters.push([reporter, {}]);
 	return resolvedReporters;
 }
 function isPlaywrightChromiumOnly(vitest, config) {
 	const browser = config.browser;
-	if (!browser || browser.provider !== "playwright" || !browser.enabled) {
-		return false;
-	}
-	if (browser.name) {
-		return browser.name === "chromium";
-	}
-	if (!browser.instances) {
-		return false;
-	}
+	if (!browser || browser.provider !== "playwright" || !browser.enabled) return false;
+	if (browser.name) return browser.name === "chromium";
+	if (!browser.instances) return false;
 	for (const instance of browser.instances) {
 		const name = instance.name || (config.name ? `${config.name} (${instance.browser})` : instance.browser);
-		if (!vitest.matchesProjectFilter(name)) {
-			continue;
-		}
-		if (instance.browser !== "chromium") {
-			return false;
-		}
+		// browser config is filtered out
+		if (!vitest.matchesProjectFilter(name)) continue;
+		if (instance.browser !== "chromium") return false;
 	}
 	return true;
 }
@@ -4289,9 +3926,7 @@ const DEFAULT_PROJECT = Symbol.for("default-project");
 let uniqueId = 0;
 async function getCoverageProvider(options, loader) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
-	if (coverageModule) {
-		return coverageModule.getProvider();
-	}
+	if (coverageModule) return coverageModule.getProvider();
 	return null;
 }
 class BaseCoverageProvider {
@@ -4299,20 +3934,20 @@ class BaseCoverageProvider {
 	name;
 	version;
 	options;
-	coverageFiles = new Map();
+	coverageFiles = /* @__PURE__ */ new Map();
 	pendingPromises = [];
 	coverageFilesDirectory;
 	_initialize(ctx) {
 		this.ctx = ctx;
-		if (ctx.version !== this.version) {
-			ctx.logger.warn(c.yellow(`Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.` + "\nRunning mixed versions is not supported and may lead into bugs" + "\nUpdate your dependencies and make sure the versions match."));
-		}
+		if (ctx.version !== this.version) ctx.logger.warn(c.yellow(`Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.
+Running mixed versions is not supported and may lead into bugs
+Update your dependencies and make sure the versions match.`));
 		const config = ctx.config.coverage;
 		this.options = {
 			...coverageConfigDefaults,
 			...config,
 			provider: this.name,
-			reportsDirectory: resolve(ctx.config.root, config.reportsDirectory || coverageConfigDefaults.reportsDirectory),
+			reportsDirectory: resolve$1(ctx.config.root, config.reportsDirectory || coverageConfigDefaults.reportsDirectory),
 			reporter: resolveCoverageReporters(config.reporter || coverageConfigDefaults.reporter),
 			thresholds: config.thresholds && {
 				...config.thresholds,
@@ -4324,7 +3959,7 @@ class BaseCoverageProvider {
 		};
 		const shard = this.ctx.config.shard;
 		const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
-		this.coverageFilesDirectory = resolve(this.options.reportsDirectory, tempDirectory);
+		this.coverageFilesDirectory = resolve$1(this.options.reportsDirectory, tempDirectory);
 	}
 	createCoverageMap() {
 		throw new Error("BaseReporter's createCoverageMap was not overwritten");
@@ -4339,31 +3974,23 @@ class BaseCoverageProvider {
 		return this.options;
 	}
 	async clean(clean = true) {
-		if (clean && existsSync(this.options.reportsDirectory)) {
-			await promises$1.rm(this.options.reportsDirectory, {
-				recursive: true,
-				force: true,
-				maxRetries: 10
-			});
-		}
-		if (existsSync(this.coverageFilesDirectory)) {
-			await promises$1.rm(this.coverageFilesDirectory, {
-				recursive: true,
-				force: true,
-				maxRetries: 10
-			});
-		}
+		if (clean && existsSync(this.options.reportsDirectory)) await promises$1.rm(this.options.reportsDirectory, {
+			recursive: true,
+			force: true,
+			maxRetries: 10
+		});
+		if (existsSync(this.coverageFilesDirectory)) await promises$1.rm(this.coverageFilesDirectory, {
+			recursive: true,
+			force: true,
+			maxRetries: 10
+		});
 		await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true });
-		this.coverageFiles = new Map();
+		this.coverageFiles = /* @__PURE__ */ new Map();
 		this.pendingPromises = [];
 	}
 	onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }) {
-		if (!coverage) {
-			return;
-		}
-		if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
-			throw new Error(`Invalid transform mode: ${transformMode}`);
-		}
+		if (!coverage) return;
+		if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") throw new Error(`Invalid transform mode: ${transformMode}`);
 		let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
 		if (!entry) {
 			entry = {
@@ -4374,7 +4001,8 @@ class BaseCoverageProvider {
 			this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
 		}
 		const testFilenames = testFiles.join();
-		const filename = resolve(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
+		const filename = resolve$1(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
+		// If there's a result from previous run, overwrite it
 		entry[transformMode][testFilenames] = filename;
 		const promise = promises$1.writeFile(filename, JSON.stringify(coverage), "utf-8");
 		this.pendingPromises.push(promise);
@@ -4384,51 +4012,43 @@ class BaseCoverageProvider {
 		const total = this.pendingPromises.length;
 		await Promise.all(this.pendingPromises);
 		this.pendingPromises = [];
-		for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
-			for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
-				const filenames = Object.values(coverageByTestfiles);
-				const project = this.ctx.getProjectByName(projectName);
-				for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
-					if (onDebug.enabled) {
-						index += chunk.length;
-						onDebug(`Reading coverage results ${index}/${total}`);
-					}
-					await Promise.all(chunk.map(async (filename) => {
-						const contents = await promises$1.readFile(filename, "utf-8");
-						const coverage = JSON.parse(contents);
-						onFileRead(coverage);
-					}));
+		for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
+			const filenames = Object.values(coverageByTestfiles);
+			const project = this.ctx.getProjectByName(projectName);
+			for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
+				if (onDebug.enabled) {
+					index += chunk.length;
+					onDebug(`Reading coverage results ${index}/${total}`);
 				}
-				await onFinished(project, transformMode);
+				await Promise.all(chunk.map(async (filename) => {
+					const contents = await promises$1.readFile(filename, "utf-8");
+					const coverage = JSON.parse(contents);
+					onFileRead(coverage);
+				}));
 			}
+			await onFinished(project, transformMode);
 		}
 	}
 	async cleanAfterRun() {
-		this.coverageFiles = new Map();
+		this.coverageFiles = /* @__PURE__ */ new Map();
 		await promises$1.rm(this.coverageFilesDirectory, { recursive: true });
-		if (readdirSync(this.options.reportsDirectory).length === 0) {
-			await promises$1.rm(this.options.reportsDirectory, { recursive: true });
-		}
+		// Remove empty reports directory, e.g. when only text-reporter is used
+		if (readdirSync(this.options.reportsDirectory).length === 0) await promises$1.rm(this.options.reportsDirectory, { recursive: true });
 	}
 	async onTestFailure() {
-		if (!this.options.reportOnFailure) {
-			await this.cleanAfterRun();
-		}
+		if (!this.options.reportOnFailure) await this.cleanAfterRun();
 	}
 	async reportCoverage(coverageMap, { allTestsRun }) {
 		await this.generateReports(coverageMap || this.createCoverageMap(), allTestsRun);
+		// In watch mode we need to preserve the previous results if cleanOnRerun is disabled
 		const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
-		if (!keepResults) {
-			await this.cleanAfterRun();
-		}
+		if (!keepResults) await this.cleanAfterRun();
 	}
 	async reportThresholds(coverageMap, allTestsRun) {
 		const resolvedThresholds = this.resolveThresholds(coverageMap);
 		this.checkThresholds(resolvedThresholds);
 		if (this.options.thresholds?.autoUpdate && allTestsRun) {
-			if (!this.ctx.server.config.configFile) {
-				throw new Error("Missing configurationFile. The \"coverage.thresholds.autoUpdate\" can only be enabled when configuration file is used.");
-			}
+			if (!this.ctx.server.config.configFile) throw new Error("Missing configurationFile. The \"coverage.thresholds.autoUpdate\" can only be enabled when configuration file is used.");
 			const configFilePath = this.ctx.server.config.configFile;
 			const configModule = await this.parseConfigModule(configFilePath);
 			await this.updateThresholds({
@@ -4448,9 +4068,7 @@ class BaseCoverageProvider {
 		const files = coverageMap.files();
 		const globalCoverageMap = this.createCoverageMap();
 		for (const key of Object.keys(this.options.thresholds)) {
-			if (key === "perFile" || key === "autoUpdate" || key === "100" || THRESHOLD_KEYS.includes(key)) {
-				continue;
-			}
+			if (key === "perFile" || key === "autoUpdate" || key === "100" || THRESHOLD_KEYS.includes(key)) continue;
 			const glob = key;
 			const globThresholds = resolveGlobThresholds(this.options.thresholds[glob]);
 			const globCoverageMap = this.createCoverageMap();
@@ -4466,6 +4084,7 @@ class BaseCoverageProvider {
 				thresholds: globThresholds
 			});
 		}
+		// Global threshold is for all files, even if they are included by glob patterns
 		for (const file of files) {
 			const fileCoverage = coverageMap.fileCoverageFor(file);
 			globalCoverageMap.addFileCoverage(fileCoverage);
@@ -4487,9 +4106,8 @@ class BaseCoverageProvider {
 	*/
 	checkThresholds(allThresholds) {
 		for (const { coverageMap, thresholds, name } of allThresholds) {
-			if (thresholds.branches === undefined && thresholds.functions === undefined && thresholds.lines === undefined && thresholds.statements === undefined) {
-				continue;
-			}
+			if (thresholds.branches === void 0 && thresholds.functions === void 0 && thresholds.lines === void 0 && thresholds.statements === void 0) continue;
+			// Construct list of coverage summaries where thresholds are compared against
 			const summaries = this.options.thresholds?.perFile ? coverageMap.files().map((file) => ({
 				file,
 				summary: coverageMap.fileCoverageFor(file).toSummary()
@@ -4497,47 +4115,40 @@ class BaseCoverageProvider {
 				file: null,
 				summary: coverageMap.getCoverageSummary()
 			}];
-			for (const { summary, file } of summaries) {
-				for (const thresholdKey of THRESHOLD_KEYS) {
-					const threshold = thresholds[thresholdKey];
-					if (threshold === undefined) {
-						continue;
+			// Check thresholds of each summary
+			for (const { summary, file } of summaries) for (const thresholdKey of THRESHOLD_KEYS) {
+				const threshold = thresholds[thresholdKey];
+				if (threshold === void 0) continue;
+				/**
+				* Positive thresholds are treated as minimum coverage percentages (X means: X% of lines must be covered),
+				* while negative thresholds are treated as maximum uncovered counts (-X means: X lines may be uncovered).
+				*/
+				if (threshold >= 0) {
+					const coverage = summary.data[thresholdKey].pct;
+					if (coverage < threshold) {
+						process.exitCode = 1;
+						/**
+						* Generate error message based on perFile flag:
+						* - ERROR: Coverage for statements (33.33%) does not meet threshold (85%) for src/math.ts
+						* - ERROR: Coverage for statements (50%) does not meet global threshold (85%)
+						*/
+						let errorMessage = `ERROR: Coverage for ${thresholdKey} (${coverage}%) does not meet ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
+						if (this.options.thresholds?.perFile && file) errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
+						this.ctx.logger.error(errorMessage);
 					}
-					/**
-					* Positive thresholds are treated as minimum coverage percentages (X means: X% of lines must be covered),
-					* while negative thresholds are treated as maximum uncovered counts (-X means: X lines may be uncovered).
-					*/
-					if (threshold >= 0) {
-						const coverage = summary.data[thresholdKey].pct;
-						if (coverage < threshold) {
-							process.exitCode = 1;
-							/**
-							* Generate error message based on perFile flag:
-							* - ERROR: Coverage for statements (33.33%) does not meet threshold (85%) for src/math.ts
-							* - ERROR: Coverage for statements (50%) does not meet global threshold (85%)
-							*/
-							let errorMessage = `ERROR: Coverage for ${thresholdKey} (${coverage}%) does not meet ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
-							if (this.options.thresholds?.perFile && file) {
-								errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
-							}
-							this.ctx.logger.error(errorMessage);
-						}
-					} else {
-						const uncovered = summary.data[thresholdKey].total - summary.data[thresholdKey].covered;
-						const absoluteThreshold = threshold * -1;
-						if (uncovered > absoluteThreshold) {
-							process.exitCode = 1;
-							/**
-							* Generate error message based on perFile flag:
-							* - ERROR: Uncovered statements (33) exceed threshold (30) for src/math.ts
-							* - ERROR: Uncovered statements (33) exceed global threshold (30)
-							*/
-							let errorMessage = `ERROR: Uncovered ${thresholdKey} (${uncovered}) exceed ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${absoluteThreshold})`;
-							if (this.options.thresholds?.perFile && file) {
-								errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
-							}
-							this.ctx.logger.error(errorMessage);
-						}
+				} else {
+					const uncovered = summary.data[thresholdKey].total - summary.data[thresholdKey].covered;
+					const absoluteThreshold = threshold * -1;
+					if (uncovered > absoluteThreshold) {
+						process.exitCode = 1;
+						/**
+						* Generate error message based on perFile flag:
+						* - ERROR: Uncovered statements (33) exceed threshold (30) for src/math.ts
+						* - ERROR: Uncovered statements (33) exceed global threshold (30)
+						*/
+						let errorMessage = `ERROR: Uncovered ${thresholdKey} (${uncovered}) exceed ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${absoluteThreshold})`;
+						if (this.options.thresholds?.perFile && file) errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
+						this.ctx.logger.error(errorMessage);
 					}
 				}
 			}
@@ -4561,29 +4172,23 @@ class BaseCoverageProvider {
 				*/
 				if (threshold >= 0) {
 					const actual = Math.min(...summaries.map((summary) => summary[key].pct));
-					if (actual > threshold) {
-						thresholdsToUpdate.push([key, actual]);
-					}
+					if (actual > threshold) thresholdsToUpdate.push([key, actual]);
 				} else {
 					const absoluteThreshold = threshold * -1;
 					const actual = Math.max(...summaries.map((summary) => summary[key].total - summary[key].covered));
 					if (actual < absoluteThreshold) {
+						// If everything was covered, set new threshold to 100% (since a threshold of 0 would be considered as 0%)
 						const updatedThreshold = actual === 0 ? 100 : actual * -1;
 						thresholdsToUpdate.push([key, updatedThreshold]);
 					}
 				}
 			}
-			if (thresholdsToUpdate.length === 0) {
-				continue;
-			}
+			if (thresholdsToUpdate.length === 0) continue;
 			updatedThresholds = true;
-			for (const [threshold, newValue] of thresholdsToUpdate) {
-				if (name === GLOBAL_THRESHOLDS_KEY) {
-					config.test.coverage.thresholds[threshold] = newValue;
-				} else {
-					const glob = config.test.coverage.thresholds[name];
-					glob[threshold] = newValue;
-				}
+			for (const [threshold, newValue] of thresholdsToUpdate) if (name === GLOBAL_THRESHOLDS_KEY) config.test.coverage.thresholds[threshold] = newValue;
+			else {
+				const glob = config.test.coverage.thresholds[name];
+				glob[threshold] = newValue;
 			}
 		}
 		if (updatedThresholds) {
@@ -4593,9 +4198,7 @@ class BaseCoverageProvider {
 	}
 	async mergeReports(coverageMaps) {
 		const coverageMap = this.createCoverageMap();
-		for (const coverage of coverageMaps) {
-			coverageMap.merge(coverage);
-		}
+		for (const coverage of coverageMaps) coverageMap.merge(coverage);
 		await this.generateReports(coverageMap, true);
 	}
 	hasTerminalReporter(reporters) {
@@ -4606,11 +4209,8 @@ class BaseCoverageProvider {
 			const index = Math.max(0, chunks.length - 1);
 			const lastChunk = chunks[index] || [];
 			chunks[index] = lastChunk;
-			if (lastChunk.length >= size) {
-				chunks.push([item]);
-			} else {
-				lastChunk.push(item);
-			}
+			if (lastChunk.length >= size) chunks.push([item]);
+			else lastChunk.push(item);
 			return chunks;
 		}, []);
 	}
@@ -4627,14 +4227,11 @@ class BaseCoverageProvider {
 		return async function transformFile(filename) {
 			let lastError;
 			for (const { root, vitenode, isBrowserEnabled } of servers) {
-				if (!filename.startsWith(root) && !filename.startsWith(`/${root}`)) {
-					continue;
-				}
+				// On Windows root doesn't start with "/" while filenames do
+				if (!filename.startsWith(root) && !filename.startsWith(`/${root}`)) continue;
 				if (isBrowserEnabled) {
-					const result = await vitenode.transformRequest(filename, undefined, "web").catch(() => null);
-					if (result) {
-						return result;
-					}
+					const result = await vitenode.transformRequest(filename, void 0, "web").catch(() => null);
+					if (result) return result;
 				}
 				try {
 					return await vitenode.transformRequest(filename);
@@ -4642,6 +4239,7 @@ class BaseCoverageProvider {
 					lastError = error;
 				}
 			}
+			// All vite-node servers failed to transform the file
 			throw lastError;
 		};
 	}
@@ -4650,29 +4248,24 @@ class BaseCoverageProvider {
 * Narrow down `unknown` glob thresholds to resolved ones
 */
 function resolveGlobThresholds(thresholds) {
-	if (!thresholds || typeof thresholds !== "object") {
-		return {};
-	}
-	if (100 in thresholds && thresholds[100] === true) {
-		return {
-			lines: 100,
-			branches: 100,
-			functions: 100,
-			statements: 100
-		};
-	}
+	if (!thresholds || typeof thresholds !== "object") return {};
+	if (100 in thresholds && thresholds[100] === true) return {
+		lines: 100,
+		branches: 100,
+		functions: 100,
+		statements: 100
+	};
 	return {
-		lines: "lines" in thresholds && typeof thresholds.lines === "number" ? thresholds.lines : undefined,
-		branches: "branches" in thresholds && typeof thresholds.branches === "number" ? thresholds.branches : undefined,
-		functions: "functions" in thresholds && typeof thresholds.functions === "number" ? thresholds.functions : undefined,
-		statements: "statements" in thresholds && typeof thresholds.statements === "number" ? thresholds.statements : undefined
+		lines: "lines" in thresholds && typeof thresholds.lines === "number" ? thresholds.lines : void 0,
+		branches: "branches" in thresholds && typeof thresholds.branches === "number" ? thresholds.branches : void 0,
+		functions: "functions" in thresholds && typeof thresholds.functions === "number" ? thresholds.functions : void 0,
+		statements: "statements" in thresholds && typeof thresholds.statements === "number" ? thresholds.statements : void 0
 	};
 }
 function assertConfigurationModule(config) {
 	try {
-		if (typeof config.test.coverage.thresholds !== "object") {
-			throw new TypeError("Expected config.test.coverage.thresholds to be an object");
-		}
+		// @ts-expect-error -- Intentional unsafe null pointer check as wrapped in try-catch
+		if (typeof config.test.coverage.thresholds !== "object") throw new TypeError("Expected config.test.coverage.thresholds to be an object");
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		throw new Error(`Unable to parse thresholds from configuration file: ${message}`);
@@ -4681,49 +4274,41 @@ function assertConfigurationModule(config) {
 function resolveConfig(configModule) {
 	const mod = configModule.exports.default;
 	try {
-		if (mod.$type === "object") {
-			return mod;
-		}
+		// Check for "export default { test: {...} }"
+		if (mod.$type === "object") return mod;
+		// "export default defineConfig(...)"
 		let config = resolveDefineConfig(mod);
-		if (config) {
-			return config;
-		}
+		if (config) return config;
+		// "export default mergeConfig(..., defineConfig(...))"
 		if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
 			config = resolveMergeConfig(mod);
-			if (config) {
-				return config;
-			}
+			if (config) return config;
 		}
 	} catch (error) {
+		// Reduce magicast's verbose errors to readable ones
 		throw new Error(error instanceof Error ? error.message : String(error));
 	}
 	throw new Error("Failed to update coverage thresholds. Configuration file is too complex.");
 }
 function resolveDefineConfig(mod) {
 	if (mod.$type === "function-call" && mod.$callee === "defineConfig") {
-		if (mod.$args[0].$type === "object") {
-			return mod.$args[0];
-		}
+		// "export default defineConfig({ test: {...} })"
+		if (mod.$args[0].$type === "object") return mod.$args[0];
 		if (mod.$args[0].$type === "arrow-function-expression") {
-			if (mod.$args[0].$body.$type === "object") {
-				return mod.$args[0].$body;
-			}
+			if (mod.$args[0].$body.$type === "object")
+ // "export default defineConfig(() => ({ test: {...} }))"
+			return mod.$args[0].$body;
+			// "export default defineConfig(() => mergeConfig({...}, ...))"
 			const config = resolveMergeConfig(mod.$args[0].$body);
-			if (config) {
-				return config;
-			}
+			if (config) return config;
 		}
 	}
 }
 function resolveMergeConfig(mod) {
-	if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
-		for (const arg of mod.$args) {
-			const config = resolveDefineConfig(arg);
-			if (config) {
-				return config;
-			}
-		}
+	if (mod.$type === "function-call" && mod.$callee === "mergeConfig") for (const arg of mod.$args) {
+		const config = resolveDefineConfig(arg);
+		if (config) return config;
 	}
 }
 
-export { BaseCoverageProvider as B, RandomSequencer as R, VitestCache as V, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, isBrowserEnabled as d, groupBy as e, getCoverageProvider as f, getFilePoolName as g, hash as h, isPackageExists as i, createPool as j, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };
+export { BaseCoverageProvider as B, RandomSequencer as R, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, isBrowserEnabled as d, groupBy as e, getCoverageProvider as f, getFilePoolName as g, hash as h, isPackageExists as i, createPool as j, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };