vitest 4.0.0-beta.5 → 4.0.0-beta.6

package/dist/chunks/{coverage.B6cReEn1.js → coverage.BPRS6xgn.js}

@@ -23,7 +23,7 @@ import { isatty } from 'node:tty';
 import EventEmitter from 'node:events';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.BgoW4nTA.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.Cd1wvxUM.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';
@@ -33,9 +33,7 @@ import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 function groupBy(collection, iteratee) {
 	return collection.reduce((acc, item) => {
 		const key = iteratee(item);
-		acc[key] ||= [];
-		acc[key].push(item);
-		return acc;
+		return acc[key] ||= [], acc[key].push(item), acc;
 	}, {});
 }
 function stdout() {
@@ -2384,8 +2382,7 @@ const isPackageListed = quansync(function* (name, cwd) {
 isPackageListed.sync;
 
 function getWorkersCountByPercentage(percent) {
-	const maxWorkersCount = nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length;
-	const workersCountByPercentage = Math.round(Number.parseInt(percent) / 100 * maxWorkersCount);
+	const maxWorkersCount = nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length, workersCountByPercentage = Math.round(Number.parseInt(percent) / 100 * maxWorkersCount);
 	return Math.max(1, Math.min(maxWorkersCount, workersCountByPercentage));
 }
 
@@ -2406,9 +2403,7 @@ async function groupFilesByEnv(files) {
 		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 = {
+		const envOptions = JSON.parse(envOptionsJson || "null"), envKey = env === "happy-dom" ? "happyDOM" : env, environment = {
 			name: env,
 			options: envOptions ? { [envKey]: envOptions } : null
 		};
@@ -2424,8 +2419,7 @@ async function groupFilesByEnv(files) {
 	return groupBy(filesWithEnv, ({ environment }) => environment.name);
 }
 
-const created = /* @__PURE__ */ new Set();
-const promises = /* @__PURE__ */ new Map();
+const created = /* @__PURE__ */ new Set(), promises = /* @__PURE__ */ new Map();
 function createFetchModuleFunction(resolver, cacheFs = false, tmpDir = join$1(tmpdir(), nanoid())) {
 	const cachedFsResults = /* @__PURE__ */ new Map();
 	return async (url, importer, environment, options) => {
@@ -2451,8 +2445,7 @@ function createFetchModuleFunction(resolver, cacheFs = false, tmpDir = join$1(tm
 		// so we do this first to resolve the module and check its `id`. The next call of
 		// `ensureEntryFromUrl` inside `fetchModule` is cached and should take no time
 		// This also makes it so externalized modules are inside the module graph.
-		const moduleGraphModule = await environment.moduleGraph.ensureEntryFromUrl(unwrapId(url));
-		const cached = !!moduleGraphModule.transformResult;
+		const moduleGraphModule = await environment.moduleGraph.ensureEntryFromUrl(unwrapId(url)), cached = !!moduleGraphModule.transformResult;
 		// if url is already cached, we can just confirm it's also cached on the server
 		if (options?.cached && cached) return { cache: true };
 		if (moduleGraphModule.id) {
@@ -2465,29 +2458,15 @@ function createFetchModuleFunction(resolver, cacheFs = false, tmpDir = join$1(tm
 		const moduleRunnerModule = await fetchModule(environment, url, importer, {
 			...options,
 			inlineSourceMap: false
-		}).catch(handleRollupError);
-		const result = processResultSource(environment, moduleRunnerModule);
+		}).catch(handleRollupError), result = processResultSource(environment, moduleRunnerModule);
 		if (!cacheFs || !("code" in result)) return result;
 		const code = result.code;
 		// to avoid serialising large chunks of code,
 		// we store them in a tmp file and read in the test thread
 		if (cachedFsResults.has(result.id)) return getCachedResult(result, cachedFsResults);
-		const dir = join$1(tmpDir, environment.name);
-		const name = hash("sha1", result.id, "hex");
-		const tmp = join$1(dir, name);
-		if (!created.has(dir)) {
-			mkdirSync(dir, { recursive: true });
-			created.add(dir);
-		}
-		if (promises.has(tmp)) {
-			await promises.get(tmp);
-			cachedFsResults.set(result.id, tmp);
-			return getCachedResult(result, cachedFsResults);
-		}
-		promises.set(tmp, atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp)));
-		await promises.get(tmp);
-		cachedFsResults.set(result.id, tmp);
-		return getCachedResult(result, cachedFsResults);
+		const dir = join$1(tmpDir, environment.name), name = hash("sha1", result.id, "hex"), tmp = join$1(dir, name);
+		if (!created.has(dir)) mkdirSync(dir, { recursive: true }), created.add(dir);
+		return promises.has(tmp) ? (await promises.get(tmp), cachedFsResults.set(result.id, tmp), getCachedResult(result, cachedFsResults)) : (promises.set(tmp, atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp))), await promises.get(tmp), cachedFsResults.set(result.id, tmp), getCachedResult(result, cachedFsResults));
 	};
 }
 let SOURCEMAPPING_URL = "sourceMa";
@@ -2514,15 +2493,12 @@ function inlineSourceMap(result) {
 	const map = result.map;
 	let code = result.code;
 	if (!map || !("version" in map) || code.includes(MODULE_RUNNER_SOURCEMAPPING_SOURCE)) return result;
-	// to reduce the payload size, we only inline vite node source map, because it's also the only one we use
-	OTHER_SOURCE_MAP_REGEXP.lastIndex = 0;
-	if (OTHER_SOURCE_MAP_REGEXP.test(code)) code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");
+	if (OTHER_SOURCE_MAP_REGEXP.lastIndex = 0, OTHER_SOURCE_MAP_REGEXP.test(code)) code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");
 	const sourceMap = { ...map };
 	// If the first line is not present on source maps, add simple 1:1 mapping ([0,0,0,0], [1,0,0,0])
 	// so that debuggers can be set to break on first line
 	if (sourceMap.mappings.startsWith(";")) sourceMap.mappings = `AAAA,CAAA${sourceMap.mappings}`;
-	result.code = `${code.trimEnd()}\n${MODULE_RUNNER_SOURCEMAPPING_SOURCE}\n//# ${SOURCEMAPPING_URL}=${genSourceMapUrl(sourceMap)}\n`;
-	return result;
+	return result.code = `${code.trimEnd()}\n${MODULE_RUNNER_SOURCEMAPPING_SOURCE}\n//# ${SOURCEMAPPING_URL}=${genSourceMapUrl(sourceMap)}\n`, result;
 }
 function genSourceMapUrl(map) {
 	if (typeof map !== "string") map = JSON.stringify(map);
@@ -2542,9 +2518,7 @@ function getCachedResult(result, cachedFsResults) {
 }
 // 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))
- // eslint-disable-next-line no-throw-literal
-	throw {
+	throw e instanceof Error && ("plugin" in e || "frame" in e || "id" in e) ? {
 		name: e.name,
 		message: e.message,
 		stack: e.stack,
@@ -2555,8 +2529,7 @@ function handleRollupError(e) {
 			loc: e.loc,
 			frame: e.frame
 		}
-	};
-	throw e;
+	} : e;
 }
 /**
 * Performs an atomic write operation using the write-then-rename pattern.
@@ -2573,11 +2546,9 @@ function handleRollupError(e) {
 * Added in https://github.com/vitest-dev/vitest/pull/7531
 */
 async function atomicWriteFile(realFilePath, data) {
-	const dir = dirname$1(realFilePath);
-	const tmpFilePath = join$1(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	const dir = dirname$1(realFilePath), tmpFilePath = join$1(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 	try {
-		await writeFile(tmpFilePath, data, "utf-8");
-		await rename(tmpFilePath, realFilePath);
+		await writeFile(tmpFilePath, data, "utf-8"), await rename(tmpFilePath, realFilePath);
 	} finally {
 		try {
 			if (await stat(tmpFilePath)) await unlink(tmpFilePath);
@@ -2587,8 +2558,7 @@ async function atomicWriteFile(realFilePath, data) {
 
 // this is copy pasted from vite
 function normalizeResolvedIdToUrl(environment, resolvedId) {
-	const root = environment.config.root;
-	const depsOptimizer = environment.depsOptimizer;
+	const root = environment.config.root, depsOptimizer = environment.depsOptimizer;
 	let url;
 	// normalize all imports into resolved URLs
 	// e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
@@ -2608,9 +2578,7 @@ function normalizeResolvedIdToUrl(environment, resolvedId) {
 }
 
 function createMethodsRPC(project, options = {}) {
-	const ctx = project.vitest;
-	const cacheFs = options.cacheFs ?? false;
-	const fetch = createFetchModuleFunction(project._resolver, cacheFs, project.tmpDir);
+	const ctx = project.vitest, cacheFs = options.cacheFs ?? false, fetch = createFetchModuleFunction(project._resolver, cacheFs, project.tmpDir);
 	return {
 		async fetch(url, importer, environmentName, options) {
 			const environment = project.vite.environments[environmentName];
@@ -2626,12 +2594,11 @@ function createMethodsRPC(project, options = {}) {
 			const environment = project.vite.environments[environmentName];
 			if (!environment) throw new Error(`The environment ${environmentName} was not defined in the Vite config.`);
 			const resolved = await environment.pluginContainer.resolveId(id, importer);
-			if (!resolved) return null;
-			return {
+			return resolved ? {
 				file: cleanUrl(resolved.id),
 				url: normalizeResolvedIdToUrl(environment, resolved.id),
 				id: resolved.id
-			};
+			} : null;
 		},
 		snapshotSaved(snapshot) {
 			ctx.snapshot.add(snapshot);
@@ -2642,8 +2609,7 @@ function createMethodsRPC(project, options = {}) {
 		async transform(id) {
 			const environment = project.vite.environments.__vitest_vm__;
 			if (!environment) throw new Error(`The VM environment was not defined in the Vite config. This is a bug in Vitest. Please, open a new issue with reproduction.`);
-			const url = normalizeResolvedIdToUrl(environment, fileURLToPath$1(id));
-			const result = await environment.transformRequest(url).catch(handleRollupError);
+			const url = normalizeResolvedIdToUrl(environment, fileURLToPath$1(id)), result = await environment.transformRequest(url).catch(handleRollupError);
 			return { code: result?.code };
 		},
 		async onQueued(file) {
@@ -2681,12 +2647,10 @@ function createMethodsRPC(project, options = {}) {
 }
 
 function createChildProcessChannel$1(project, collect = false) {
-	const emitter = new EventEmitter();
-	const events = {
+	const emitter = new EventEmitter(), events = {
 		message: "message",
 		response: "response"
-	};
-	const rpc = createBirpc(createMethodsRPC(project, {
+	}, rpc = createBirpc(createMethodsRPC(project, {
 		cacheFs: true,
 		collect
 	}), {
@@ -2716,20 +2680,13 @@ function createChildProcessChannel$1(project, collect = false) {
 		onMessage: (callback) => emitter.on(events.message, callback),
 		postMessage: (message) => emitter.emit(events.response, message),
 		onClose: () => {
-			emitter.removeAllListeners();
-			rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+			emitter.removeAllListeners(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
 		}
 	};
 	return channel;
 }
 function createForksPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	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 ?? Math.min(threadsCount, maxThreads);
-	const worker = resolve(vitest.distPath, "workers/forks.js");
-	const options = {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.forks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minForks ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/forks.js"), options = {
 		runtime: "child_process",
 		filename: resolve(vitest.distPath, "worker.js"),
 		teardown: "teardown",
@@ -2739,22 +2696,15 @@ function createForksPool(vitest, { execArgv, env }) {
 		execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
 		terminateTimeout: vitest.config.teardownTimeout,
 		concurrentTasksPerWorker: 1
-	};
-	const isolated = poolOptions.isolate ?? true;
+	}, isolated = poolOptions.isolate ?? true;
 	if (isolated) options.isolateWorkers = true;
-	if (poolOptions.singleFork || !vitest.config.fileParallelism) {
-		options.maxThreads = 1;
-		options.minThreads = 1;
-	}
-	const pool = new Tinypool(options);
-	const runWithFiles = (name) => {
+	if (poolOptions.singleFork || !vitest.config.fileParallelism) options.maxThreads = 1, options.minThreads = 1;
+	const pool = new Tinypool(options), runWithFiles = (name) => {
 		let id = 0;
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
 			vitest.state.clearFiles(project, paths);
-			const channel = createChildProcessChannel$1(project, name === "collect");
-			const workerId = ++id;
-			const data = {
+			const channel = createChildProcessChannel$1(project, name === "collect"), workerId = ++id, data = {
 				pool: "forks",
 				worker,
 				config,
@@ -2780,40 +2730,25 @@ function createForksPool(vitest, { execArgv, env }) {
 		return async (specs, invalidates) => {
 			// Cancel pending tasks from pool when possible
 			vitest.onCancel(() => pool.cancelPendingTasks());
-			const configs = /* @__PURE__ */ new WeakMap();
-			const getConfig = (project) => {
+			const configs = /* @__PURE__ */ new WeakMap(), getConfig = (project) => {
 				if (configs.has(project)) return configs.get(project);
-				const _config = project.getSerializableConfig();
-				const config = wrapSerializableConfig(_config);
-				configs.set(project, config);
-				return config;
-			};
-			const singleFork = specs.filter((spec) => spec.project.config.poolOptions?.forks?.singleFork);
-			const multipleForks = specs.filter((spec) => !spec.project.config.poolOptions?.forks?.singleFork);
+				const _config = project.getSerializableConfig(), config = wrapSerializableConfig(_config);
+				return configs.set(project, config), config;
+			}, singleFork = specs.filter((spec) => spec.project.config.poolOptions?.forks?.singleFork), multipleForks = specs.filter((spec) => !spec.project.config.poolOptions?.forks?.singleFork);
 			if (multipleForks.length) {
-				const filesByEnv = await groupFilesByEnv(multipleForks);
-				const files = Object.values(filesByEnv).flat();
-				const results = [];
+				const filesByEnv = await groupFilesByEnv(multipleForks), files = Object.values(filesByEnv).flat(), results = [];
 				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();
-					}
+					for (const group of Object.values(grouped)) results.push(...await Promise.allSettled(group.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)))), 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 (singleFork.length) {
-				const filesByEnv = await groupFilesByEnv(singleFork);
-				const envs = envsOrder.concat(Object.keys(filesByEnv).filter((env) => !envsOrder.includes(env)));
+				const filesByEnv = await groupFilesByEnv(singleFork), envs = envsOrder.concat(Object.keys(filesByEnv).filter((env) => !envsOrder.includes(env)));
 				for (const env of envs) {
 					const files = filesByEnv[env];
 					if (!files?.length) continue;
@@ -2837,10 +2772,7 @@ function createForksPool(vitest, { execArgv, env }) {
 }
 
 function createWorkerChannel$1(project, collect) {
-	const channel = new MessageChannel();
-	const port = channel.port2;
-	const workerPort = channel.port1;
-	const rpc = createBirpc(createMethodsRPC(project, { collect }), {
+	const channel = new MessageChannel(), port = channel.port2, workerPort = channel.port1, rpc = createBirpc(createMethodsRPC(project, { collect }), {
 		eventNames: ["onCancel"],
 		post(v) {
 			port.postMessage(v);
@@ -2852,9 +2784,7 @@ function createWorkerChannel$1(project, collect) {
 	});
 	project.vitest.onCancel((reason) => rpc.onCancel(reason));
 	const onClose = () => {
-		port.close();
-		workerPort.close();
-		rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+		port.close(), workerPort.close(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
 	};
 	return {
 		workerPort,
@@ -2863,13 +2793,7 @@ function createWorkerChannel$1(project, collect) {
 	};
 }
 function createThreadsPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	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 ?? Math.min(threadsCount, maxThreads);
-	const worker = resolve(vitest.distPath, "workers/threads.js");
-	const options = {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.threads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minThreads ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/threads.js"), options = {
 		filename: resolve(vitest.distPath, "worker.js"),
 		teardown: "teardown",
 		useAtomics: poolOptions.useAtomics ?? false,
@@ -2879,22 +2803,15 @@ function createThreadsPool(vitest, { execArgv, env }) {
 		execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
 		terminateTimeout: vitest.config.teardownTimeout,
 		concurrentTasksPerWorker: 1
-	};
-	const isolated = poolOptions.isolate ?? true;
+	}, isolated = poolOptions.isolate ?? true;
 	if (isolated) options.isolateWorkers = true;
-	if (poolOptions.singleThread || !vitest.config.fileParallelism) {
-		options.maxThreads = 1;
-		options.minThreads = 1;
-	}
-	const pool = new Tinypool$1(options);
-	const runWithFiles = (name) => {
+	if (poolOptions.singleThread || !vitest.config.fileParallelism) options.maxThreads = 1, options.minThreads = 1;
+	const pool = new Tinypool$1(options), runWithFiles = (name) => {
 		let id = 0;
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
 			vitest.state.clearFiles(project, paths);
-			const { workerPort, onClose } = createWorkerChannel$1(project, name === "collect");
-			const workerId = ++id;
-			const data = {
+			const { workerPort, onClose } = createWorkerChannel$1(project, name === "collect"), workerId = ++id, data = {
 				pool: "threads",
 				worker,
 				port: workerPort,
@@ -2922,39 +2839,25 @@ function createThreadsPool(vitest, { execArgv, env }) {
 		return async (specs, invalidates) => {
 			// Cancel pending tasks from pool when possible
 			vitest.onCancel(() => pool.cancelPendingTasks());
-			const configs = /* @__PURE__ */ new WeakMap();
-			const getConfig = (project) => {
+			const configs = /* @__PURE__ */ new WeakMap(), getConfig = (project) => {
 				if (configs.has(project)) return configs.get(project);
 				const config = project.serializedConfig;
-				configs.set(project, config);
-				return config;
-			};
-			const singleThreads = specs.filter((spec) => spec.project.config.poolOptions?.threads?.singleThread);
-			const multipleThreads = specs.filter((spec) => !spec.project.config.poolOptions?.threads?.singleThread);
+				return configs.set(project, config), config;
+			}, singleThreads = specs.filter((spec) => spec.project.config.poolOptions?.threads?.singleThread), multipleThreads = specs.filter((spec) => !spec.project.config.poolOptions?.threads?.singleThread);
 			if (multipleThreads.length) {
-				const filesByEnv = await groupFilesByEnv(multipleThreads);
-				const files = Object.values(filesByEnv).flat();
-				const results = [];
+				const filesByEnv = await groupFilesByEnv(multipleThreads), files = Object.values(filesByEnv).flat(), results = [];
 				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();
-					}
+					for (const group of Object.values(grouped)) results.push(...await Promise.allSettled(group.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)))), 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 (singleThreads.length) {
-				const filesByEnv = await groupFilesByEnv(singleThreads);
-				const envs = envsOrder.concat(Object.keys(filesByEnv).filter((env) => !envsOrder.includes(env)));
+				const filesByEnv = await groupFilesByEnv(singleThreads), envs = envsOrder.concat(Object.keys(filesByEnv).filter((env) => !envsOrder.includes(env)));
 				for (const env of envs) {
 					const files = filesByEnv[env];
 					if (!files?.length) continue;
@@ -2978,102 +2881,69 @@ function createThreadsPool(vitest, { execArgv, env }) {
 }
 
 function createTypecheckPool(vitest) {
-	const promisesMap = /* @__PURE__ */ new WeakMap();
-	const rerunTriggered = /* @__PURE__ */ new WeakSet();
+	const promisesMap = /* @__PURE__ */ new WeakMap(), 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"));
+		const checker = project.typechecker, { packs, events } = checker.getTestPacksAndEvents();
+		if (await vitest._testRun.updated(packs, events), !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());
-			error.stack = "";
-			vitest.state.catchError(error, "Typecheck Error");
+			error.stack = "", vitest.state.catchError(error, "Typecheck Error");
 		}
-		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()]);
+		if (promisesMap.get(project)?.resolve(), rerunTriggered.delete(project), vitest.config.watch && !vitest.runningPromise) {
+			const modules = files.map((file) => vitest.state.getReportedEntity(file)).filter((e) => e?.type === "module"), state = vitest.isCancelling ? "interrupted" : modules.some((m) => !m.ok()) ? "failed" : "passed";
+			await vitest.report("onTestRunEnd", modules, [], state), await vitest.report("onWatcherStart", files, [...project.config.typecheck.ignoreSourceErrors ? [] : sourceErrors, ...vitest.state.getUnhandledErrors()]);
 		}
 	}
 	async function createWorkspaceTypechecker(project, files) {
 		const checker = project.typechecker ?? new Typechecker(project);
-		if (project.typechecker) return checker;
-		project.typechecker = checker;
-		checker.setFiles(files);
-		checker.onParseStart(async () => {
+		return project.typechecker ? 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);
 			await vitest._testRun.collected(project, files);
-		});
-		checker.onParseEnd((result) => onParseEnd(project, result));
-		checker.onWatcherRerun(async () => {
-			rerunTriggered.add(project);
-			if (!vitest.runningPromise) {
-				vitest.state.clearErrors();
-				await vitest.report("onWatcherRerun", files, "File change detected. Triggering rerun.");
-			}
+		}), checker.onParseEnd((result) => onParseEnd(project, result)), checker.onWatcherRerun(async () => {
+			if (rerunTriggered.add(project), !vitest.runningPromise) vitest.state.clearErrors(), await vitest.report("onWatcherRerun", files, "File change detected. Triggering rerun.");
 			await checker.collectTests();
 			const testFiles = checker.getTestFiles();
 			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);
-		});
-		return checker;
+		}), checker);
 	}
 	async function startTypechecker(project, files) {
 		if (project.typechecker) return;
 		const checker = await createWorkspaceTypechecker(project, files);
-		await checker.collectTests();
-		await checker.start();
+		await checker.collectTests(), await checker.start();
 	}
 	async function collectTests(specs) {
 		const specsByProject = groupBy(specs, (spec) => spec.project.name);
 		for (const name in specsByProject) {
-			const project = specsByProject[name][0].project;
-			const files = specsByProject[name].map((spec) => spec.moduleId);
-			const checker = await createWorkspaceTypechecker(project, files);
-			checker.setFiles(files);
-			await checker.collectTests();
+			const project = specsByProject[name][0].project, files = specsByProject[name].map((spec) => spec.moduleId), checker = await createWorkspaceTypechecker(project, files);
+			checker.setFiles(files), await checker.collectTests();
 			const testFiles = checker.getTestFiles();
 			vitest.state.collectFiles(project, testFiles);
 		}
 	}
 	async function runTests(specs) {
-		const specsByProject = groupBy(specs, (spec) => spec.project.name);
-		const promises = [];
+		const specsByProject = groupBy(specs, (spec) => spec.project.name), promises = [];
 		for (const name in specsByProject) {
-			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 project = specsByProject[name][0].project, files = specsByProject[name].map((spec) => spec.moduleId), promise = createDefer(), _p = new Promise((resolve) => {
 				const _i = setInterval(() => {
-					if (!project.typechecker || rerunTriggered.has(project)) {
-						resolve(true);
-						clearInterval(_i);
-					}
+					if (!project.typechecker || rerunTriggered.has(project)) resolve(true), clearInterval(_i);
 				});
 				setTimeout(() => {
-					resolve(false);
-					clearInterval(_i);
+					resolve(false), clearInterval(_i);
 				}, 500).unref();
-			});
-			const triggered = await _p;
+			}), triggered = await _p;
 			if (project.typechecker && !triggered) {
 				const testFiles = project.typechecker.getTestFiles();
 				for (const file of testFiles) await vitest._testRun.enqueued(project, file);
-				await vitest._testRun.collected(project, testFiles);
-				await onParseEnd(project, project.typechecker.getResult());
+				await vitest._testRun.collected(project, testFiles), await onParseEnd(project, project.typechecker.getResult());
 				continue;
 			}
-			promises.push(promise);
-			promisesMap.set(project, promise);
-			promises.push(startTypechecker(project, files));
+			promises.push(promise), promisesMap.set(project, promise), promises.push(startTypechecker(project, files));
 		}
 		await Promise.all(promises);
 	}
@@ -3117,8 +2987,7 @@ function stringToBytes(input, percentageReference) {
 		let [, numericString, trailingChars] = input.match(/(.*?)([^0-9.-]+)$/) || [];
 		if (trailingChars && numericString) {
 			const numericValue = Number.parseFloat(numericString);
-			trailingChars = trailingChars.toLowerCase();
-			switch (trailingChars) {
+			switch (trailingChars = trailingChars.toLowerCase(), trailingChars) {
 				case "%":
 					input = numericValue / 100;
 					break;
@@ -3134,21 +3003,20 @@ function stringToBytes(input, percentageReference) {
 			}
 		}
 	} 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);
+	if (typeof input === "number") if (input <= 1 && input > 0) {
+		if (percentageReference) return Math.floor(input * percentageReference);
+		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(rootDir, "./suppress-warnings.cjs");
 function createChildProcessChannel(project, collect) {
-	const emitter = new EventEmitter();
-	const events = {
+	const emitter = new EventEmitter(), events = {
 		message: "message",
 		response: "response"
-	};
-	const rpc = createBirpc(createMethodsRPC(project, {
+	}, rpc = createBirpc(createMethodsRPC(project, {
 		cacheFs: true,
 		collect
 	}), {
@@ -3178,20 +3046,13 @@ function createChildProcessChannel(project, collect) {
 		onMessage: (callback) => emitter.on(events.message, callback),
 		postMessage: (message) => emitter.emit(events.response, message),
 		onClose: () => {
-			emitter.removeAllListeners();
-			rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+			emitter.removeAllListeners(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
 		}
 	};
 	return { channel };
 }
 function createVmForksPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	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 ?? Math.min(threadsCount, maxThreads);
-	const worker = resolve(vitest.distPath, "workers/vmForks.js");
-	const options = {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.vmForks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.maxForks ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/vmForks.js"), options = {
 		runtime: "child_process",
 		filename: resolve(vitest.distPath, "worker.js"),
 		maxThreads,
@@ -3209,19 +3070,13 @@ function createVmForksPool(vitest, { execArgv, env }) {
 		concurrentTasksPerWorker: 1,
 		maxMemoryLimitBeforeRecycle: getMemoryLimit$1(vitest.config) || void 0
 	};
-	if (poolOptions.singleFork || !vitest.config.fileParallelism) {
-		options.maxThreads = 1;
-		options.minThreads = 1;
-	}
-	const pool = new Tinypool$1(options);
-	const runWithFiles = (name) => {
+	if (poolOptions.singleFork || !vitest.config.fileParallelism) options.maxThreads = 1, options.minThreads = 1;
+	const pool = new Tinypool$1(options), runWithFiles = (name) => {
 		let id = 0;
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
 			vitest.state.clearFiles(project, paths);
-			const { channel } = createChildProcessChannel(project, name === "collect");
-			const workerId = ++id;
-			const data = {
+			const { channel } = createChildProcessChannel(project, name === "collect"), workerId = ++id, data = {
 				pool: "forks",
 				worker,
 				config,
@@ -3249,18 +3104,11 @@ function createVmForksPool(vitest, { execArgv, env }) {
 		return async (specs, invalidates) => {
 			// Cancel pending tasks from pool when possible
 			vitest.onCancel(() => pool.cancelPendingTasks());
-			const configs = /* @__PURE__ */ new Map();
-			const getConfig = (project) => {
+			const configs = /* @__PURE__ */ new Map(), getConfig = (project) => {
 				if (configs.has(project)) return configs.get(project);
-				const _config = project.serializedConfig;
-				const config = wrapSerializableConfig(_config);
-				configs.set(project, config);
-				return config;
-			};
-			const filesByEnv = await groupFilesByEnv(specs);
-			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);
+				const _config = project.serializedConfig, config = wrapSerializableConfig(_config);
+				return configs.set(project, config), config;
+			}, filesByEnv = await groupFilesByEnv(specs), promises = Object.values(filesByEnv).flat(), results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))), 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.");
 		};
 	};
@@ -3272,21 +3120,14 @@ function createVmForksPool(vitest, { 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 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);
+	const memory = nodeos.totalmem(), limit = getWorkerMemoryLimit(config, "vmForks");
 	// just ignore "memoryLimit" value because we cannot detect memory limit
-	return null;
+	return typeof memory === "number" ? stringToBytes(limit, config.watch ? memory / 2 : memory) : typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%" ? stringToBytes(limit) : null;
 }
 
 const suppressWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
 function createWorkerChannel(project, collect) {
-	const channel = new MessageChannel();
-	const port = channel.port2;
-	const workerPort = channel.port1;
-	const rpc = createBirpc(createMethodsRPC(project, { collect }), {
+	const channel = new MessageChannel(), port = channel.port2, workerPort = channel.port1, rpc = createBirpc(createMethodsRPC(project, { collect }), {
 		eventNames: ["onCancel"],
 		post(v) {
 			port.postMessage(v);
@@ -3298,9 +3139,7 @@ function createWorkerChannel(project, collect) {
 	});
 	project.vitest.onCancel((reason) => rpc.onCancel(reason));
 	function onClose() {
-		workerPort.close();
-		port.close();
-		rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+		workerPort.close(), port.close(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
 	}
 	return {
 		workerPort,
@@ -3308,13 +3147,7 @@ function createWorkerChannel(project, collect) {
 	};
 }
 function createVmThreadsPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-	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 ?? Math.min(threadsCount, maxThreads);
-	const worker = resolve(vitest.distPath, "workers/vmThreads.js");
-	const options = {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.vmThreads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minThreads ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/vmThreads.js"), options = {
 		filename: resolve(vitest.distPath, "worker.js"),
 		useAtomics: poolOptions.useAtomics ?? false,
 		maxThreads,
@@ -3332,19 +3165,13 @@ function createVmThreadsPool(vitest, { execArgv, env }) {
 		concurrentTasksPerWorker: 1,
 		maxMemoryLimitBeforeRecycle: getMemoryLimit(vitest.config) || void 0
 	};
-	if (poolOptions.singleThread || !vitest.config.fileParallelism) {
-		options.maxThreads = 1;
-		options.minThreads = 1;
-	}
-	const pool = new Tinypool$1(options);
-	const runWithFiles = (name) => {
+	if (poolOptions.singleThread || !vitest.config.fileParallelism) options.maxThreads = 1, options.minThreads = 1;
+	const pool = new Tinypool$1(options), runWithFiles = (name) => {
 		let id = 0;
 		async function runFiles(project, config, files, environment, invalidates = []) {
 			const paths = files.map((f) => f.filepath);
 			vitest.state.clearFiles(project, paths);
-			const { workerPort, onClose } = createWorkerChannel(project, name === "collect");
-			const workerId = ++id;
-			const data = {
+			const { workerPort, onClose } = createWorkerChannel(project, name === "collect"), workerId = ++id, data = {
 				pool: "vmThreads",
 				worker,
 				port: workerPort,
@@ -3373,17 +3200,11 @@ function createVmThreadsPool(vitest, { execArgv, env }) {
 		return async (specs, invalidates) => {
 			// Cancel pending tasks from pool when possible
 			vitest.onCancel(() => pool.cancelPendingTasks());
-			const configs = /* @__PURE__ */ new Map();
-			const getConfig = (project) => {
+			const configs = /* @__PURE__ */ new Map(), getConfig = (project) => {
 				if (configs.has(project)) return configs.get(project);
 				const config = project.serializedConfig;
-				configs.set(project, config);
-				return config;
-			};
-			const filesByEnv = await groupFilesByEnv(specs);
-			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);
+				return configs.set(project, config), config;
+			}, filesByEnv = await groupFilesByEnv(specs), promises = Object.values(filesByEnv).flat(), results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))), 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.");
 		};
 	};
@@ -3395,13 +3216,9 @@ function createVmThreadsPool(vitest, { 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 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);
+	const memory = nodeos.totalmem(), limit = getWorkerMemoryLimit(config, "vmThreads");
 	// just ignore "memoryLimit" value because we cannot detect memory limit
-	return null;
+	return typeof memory === "number" ? stringToBytes(limit, config.watch ? memory / 2 : memory) : typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%" ? stringToBytes(limit) : null;
 }
 
 const builtinPools = [
@@ -3413,8 +3230,7 @@ const builtinPools = [
 	"typescript"
 ];
 function getDefaultPoolName(project) {
-	if (project.config.browser.enabled) return "browser";
-	return project.config.pool;
+	return project.config.browser.enabled ? "browser" : project.config.pool;
 }
 function getFilePoolName(project) {
 	return getDefaultPoolName(project);
@@ -3427,26 +3243,15 @@ function createPool(ctx) {
 		vmThreads: null,
 		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 ?? [] : [
+	}, viteMajor = Number(version.split(".")[0]), potentialConditions = new Set(viteMajor >= 6 ? ctx.vite.config.ssr.resolve?.conditions ?? [] : [
 		"production",
 		"development",
 		...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;
-		return true;
+	]), conditions = [...potentialConditions].filter((condition) => {
+		return condition === "production" ? ctx.vite.config.isProduction : condition === "development" ? !ctx.vite.config.isProduction : true;
 	}).map((condition) => {
-		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"));
+		return viteMajor >= 6 && condition === "development|production" ? ctx.vite.config.isProduction ? "production" : "development" : condition;
+	}).flatMap((c) => ["--conditions", c]), 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 = {
 			execArgv: [...execArgv, ...conditions],
@@ -3462,8 +3267,7 @@ function createPool(ctx) {
 		};
 		// 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();
+		const poolConcurrentPromises = /* @__PURE__ */ new Map(), customPools = /* @__PURE__ */ new Map();
 		async function resolveCustomPool(filepath) {
 			if (customPools.has(filepath)) return customPools.get(filepath);
 			const pool = await ctx.runner.import(filepath);
@@ -3471,16 +3275,14 @@ function createPool(ctx) {
 			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`);
-			customPools.set(filepath, poolInstance);
-			return poolInstance;
+			return customPools.set(filepath, poolInstance), poolInstance;
 		}
 		function getConcurrentPool(pool, fn) {
 			if (poolConcurrentPromises.has(pool)) return poolConcurrentPromises.get(pool);
 			const promise = fn().finally(() => {
 				poolConcurrentPromises.delete(pool);
 			});
-			poolConcurrentPromises.set(pool, promise);
-			return promise;
+			return poolConcurrentPromises.set(pool, promise), promise;
 		}
 		function getCustomPool(pool) {
 			return getConcurrentPool(pool, () => resolveCustomPool(pool));
@@ -3491,9 +3293,7 @@ function createPool(ctx) {
 				return createBrowserPool(ctx);
 			});
 		}
-		const groupedSpecifications = {};
-		const groups = /* @__PURE__ */ new Set();
-		const factories = {
+		const groupedSpecifications = {}, groups = /* @__PURE__ */ new Set(), factories = {
 			vmThreads: () => createVmThreadsPool(ctx, options),
 			vmForks: () => createVmForksPool(ctx, options),
 			threads: () => createThreadsPool(ctx, options),
@@ -3502,12 +3302,9 @@ function createPool(ctx) {
 		};
 		for (const spec of files) {
 			const group = spec[0].config.sequence.groupOrder ?? 0;
-			groups.add(group);
-			groupedSpecifications[group] ??= [];
-			groupedSpecifications[group].push(spec);
+			groups.add(group), groupedSpecifications[group] ??= [], groupedSpecifications[group].push(spec);
 		}
-		const Sequencer = ctx.config.sequence.sequencer;
-		const sequencer = new Sequencer(ctx);
+		const Sequencer = ctx.config.sequence.sequencer, sequencer = new Sequencer(ctx);
 		async function sortSpecs(specs) {
 			if (ctx.config.shard) {
 				if (!ctx.config.passWithNoTests && ctx.config.shard.count > specs.length) throw new Error(`--shard <count> must be a smaller than count of test files. Resolved ${specs.length} test files for --shard=${ctx.config.shard.index}/${ctx.config.shard.count}.`);
@@ -3528,25 +3325,18 @@ function createPool(ctx) {
 			};
 			specifications.forEach((specification) => {
 				const pool = specification[2].pool;
-				filesByPool[pool] ??= [];
-				filesByPool[pool].push(specification);
-			});
-			await Promise.all(Object.entries(filesByPool).map(async (entry) => {
+				filesByPool[pool] ??= [], filesByPool[pool].push(specification);
+			}), await Promise.all(Object.entries(filesByPool).map(async (entry) => {
 				const [pool, files] = entry;
 				if (!files.length) return null;
 				const specs = await sortSpecs(files);
 				if (pool in factories) {
 					const factory = factories[pool];
-					pools[pool] ??= factory();
-					return pools[pool][method](specs, invalidate);
-				}
-				if (pool === "browser") {
-					pools.browser ??= await getBrowserPool();
-					return pools.browser[method](specs, invalidate);
+					return pools[pool] ??= factory(), pools[pool][method](specs, invalidate);
 				}
+				if (pool === "browser") return pools.browser ??= await getBrowserPool(), pools.browser[method](specs, invalidate);
 				const poolHandler = await getCustomPool(pool);
-				pools[poolHandler.name] ??= poolHandler;
-				return poolHandler[method](specs, invalidate);
+				return pools[poolHandler.name] ??= poolHandler, poolHandler[method](specs, invalidate);
 			}));
 		}
 	}
@@ -3567,12 +3357,9 @@ class BaseSequencer {
 	}
 	// async so it can be extended by other sequelizers
 	async shard(files) {
-		const { config } = this.ctx;
-		const { index, count } = config.shard;
-		const [shardStart, shardEnd] = this.calculateShardRange(files.length, index, count);
+		const { config } = this.ctx, { index, count } = config.shard, [shardStart, shardEnd] = this.calculateShardRange(files.length, index, count);
 		return [...files].map((spec) => {
-			const fullPath = resolve$1(slash(config.root), slash(spec.moduleId));
-			const specPath = fullPath?.slice(config.root.length);
+			const fullPath = resolve$1(slash(config.root), slash(spec.moduleId)), specPath = fullPath?.slice(config.root.length);
 			return {
 				spec,
 				hash: hash("sha1", specPath, "hex")
@@ -3583,37 +3370,24 @@ class BaseSequencer {
 	async sort(files) {
 		const cache = this.ctx.cache;
 		return [...files].sort((a, b) => {
-			const keyA = `${a.project.name}:${relative(this.ctx.config.root, a.moduleId)}`;
-			const keyB = `${b.project.name}:${relative(this.ctx.config.root, b.moduleId)}`;
-			const aState = cache.getFileTestResults(keyA);
-			const bState = cache.getFileTestResults(keyB);
+			const keyA = `${a.project.name}:${relative(this.ctx.config.root, a.moduleId)}`, keyB = `${b.project.name}:${relative(this.ctx.config.root, b.moduleId)}`, aState = cache.getFileTestResults(keyA), bState = cache.getFileTestResults(keyB);
 			if (!aState || !bState) {
-				const statsA = cache.getFileStats(keyA);
-				const statsB = cache.getFileStats(keyB);
-				// run unknown first
-				if (!statsA || !statsB) return !statsA && statsB ? -1 : !statsB && statsA ? 1 : 0;
+				const statsA = cache.getFileStats(keyA), statsB = cache.getFileStats(keyB);
 				// run larger files first
-				return statsB.size - statsA.size;
+				return !statsA || !statsB ? !statsA && statsB ? -1 : !statsB && statsA ? 1 : 0 : statsB.size - statsA.size;
 			}
-			// 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;
+			return aState.failed && !bState.failed ? -1 : !aState.failed && bState.failed ? 1 : bState.duration - aState.duration;
 		});
 	}
 	// Calculate distributed shard range [start, end] distributed equally
 	calculateShardRange(filesCount, index, count) {
-		const baseShardSize = Math.floor(filesCount / count);
-		const remainderTestFilesCount = filesCount % count;
+		const baseShardSize = Math.floor(filesCount / count), remainderTestFilesCount = filesCount % count;
 		if (remainderTestFilesCount >= index) {
-			const shardSize = baseShardSize + 1;
-			const shardStart = shardSize * (index - 1);
-			const shardEnd = shardSize * index;
+			const shardSize = baseShardSize + 1, shardStart = shardSize * (index - 1), shardEnd = shardSize * index;
 			return [shardStart, shardEnd];
 		}
-		const shardStart = remainderTestFilesCount * (baseShardSize + 1) + (index - remainderTestFilesCount - 1) * baseShardSize;
-		const shardEnd = shardStart + baseShardSize;
+		const shardStart = remainderTestFilesCount * (baseShardSize + 1) + (index - remainderTestFilesCount - 1) * baseShardSize, shardEnd = shardStart + baseShardSize;
 		return [shardStart, shardEnd];
 	}
 }
@@ -3633,11 +3407,10 @@ function parseInspector(inspect) {
 	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 };
-	return {
+	return port ? {
 		host,
 		port: Number(port) || defaultInspectPort
-	};
+	} : { host };
 }
 function resolveApiServerConfig(options, defaultPort) {
 	let api;
@@ -3655,12 +3428,10 @@ function resolveApiServerConfig(options, defaultPort) {
 	return api;
 }
 function resolveInlineWorkerOption(value) {
-	if (typeof value === "string" && value.trim().endsWith("%")) return getWorkersCountByPercentage(value);
-	else return Number(value);
+	return typeof value === "string" && value.trim().endsWith("%") ? getWorkersCountByPercentage(value) : Number(value);
 }
 function resolveConfig$1(vitest, options, viteConfig) {
-	const mode = vitest.mode;
-	const logger = vitest.logger;
+	const mode = vitest.mode, 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}"`));
 		options.environment = "happy-dom";
@@ -3671,25 +3442,17 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		root: viteConfig.root,
 		mode
 	};
-	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 : void 0;
-	if (resolved.environment === "browser") throw new Error(`Looks like you set "test.environment" to "browser". To enabled Browser Mode, use "test.browser.enabled" instead.`);
+	if (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 : void 0, resolved.environment === "browser") throw new Error(`Looks like you set "test.environment" to "browser". To enabled Browser Mode, use "test.browser.enabled" instead.`);
 	const inspector = resolved.inspect || resolved.inspectBrk;
-	resolved.inspector = {
+	if (resolved.inspector = {
 		...resolved.inspector,
 		...parseInspector(inspector),
 		enabled: !!inspector,
 		waitForDebugger: options.inspector?.waitForDebugger ?? !!resolved.inspectBrk
-	};
-	if (viteConfig.base !== "/") resolved.base = viteConfig.base;
-	resolved.clearScreen = resolved.clearScreen ?? viteConfig.clearScreen ?? true;
-	if (options.shard) {
+	}, viteConfig.base !== "/") resolved.base = viteConfig.base;
+	if (resolved.clearScreen = resolved.clearScreen ?? viteConfig.clearScreen ?? true, options.shard) {
 		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));
+		const [indexString, countString] = options.shard.split("/"), index = Math.abs(Number.parseInt(indexString, 10)), 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>");
 		resolved.shard = {
@@ -3701,20 +3464,10 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	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;
-	}
-	if (resolved.maxConcurrency === 0) {
-		logger.console.warn(c.yellow(`The option "maxConcurrency" cannot be set to 0. Using default value ${configDefaults.maxConcurrency} instead.`));
-		resolved.maxConcurrency = configDefaults.maxConcurrency;
-	}
+	if (resolved.fileParallelism ??= mode !== "benchmark", !resolved.fileParallelism) resolved.maxWorkers = 1, resolved.minWorkers = 1;
+	if (resolved.maxConcurrency === 0) logger.console.warn(c.yellow(`The option "maxConcurrency" cannot be set to 0. Using default value ${configDefaults.maxConcurrency} instead.`)), resolved.maxConcurrency = configDefaults.maxConcurrency;
 	if (resolved.inspect || resolved.inspectBrk) {
-		const isSingleThread = resolved.pool === "threads" && resolved.poolOptions?.threads?.singleThread;
-		const isSingleFork = resolved.pool === "forks" && resolved.poolOptions?.forks?.singleFork;
+		const isSingleThread = resolved.pool === "threads" && resolved.poolOptions?.threads?.singleThread, isSingleFork = resolved.pool === "forks" && resolved.poolOptions?.forks?.singleFork;
 		if (resolved.fileParallelism && !isSingleThread && !isSingleFork) {
 			const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
 			throw new Error(`You cannot use ${inspectOption} without "--no-file-parallelism", "poolOptions.threads.singleThread" or "poolOptions.forks.singleFork"`);
@@ -3752,37 +3505,20 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			} }, null, 2)}\n\n...or disable ${inspectOption}\n`);
 		}
 	}
-	resolved.coverage.reporter = resolveCoverageReporters(resolved.coverage.reporter);
-	if (resolved.coverage.enabled && resolved.coverage.reportsDirectory) {
+	if (resolved.coverage.reporter = resolveCoverageReporters(resolved.coverage.reporter), resolved.coverage.enabled && resolved.coverage.reportsDirectory) {
 		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.expect ??= {}, resolved.deps ??= {}, resolved.deps.moduleDirectories ??= [];
 	const envModuleDirectories = process.env.VITEST_MODULE_DIRECTORIES || process.env.npm_config_VITEST_MODULE_DIRECTORIES;
 	if (envModuleDirectories) resolved.deps.moduleDirectories.push(...envModuleDirectories.split(","));
-	resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map((dir) => {
+	if (resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map((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/");
-	resolved.deps.optimizer ??= {};
-	resolved.deps.optimizer.ssr ??= {};
-	resolved.deps.optimizer.ssr.enabled ??= false;
-	resolved.deps.optimizer.client ??= {};
-	resolved.deps.optimizer.client.enabled ??= false;
-	resolved.deps.web ??= {};
-	resolved.deps.web.transformAssets ??= true;
-	resolved.deps.web.transformCss ??= true;
-	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));
-	// Add hard-coded default coverage exclusions. These cannot be overidden by user config.
-	// Override original exclude array for cases where user re-uses same object in test.exclude.
-	resolved.coverage.exclude = [
+	}), !resolved.deps.moduleDirectories.includes("/node_modules/")) resolved.deps.moduleDirectories.push("/node_modules/");
+	if (resolved.deps.optimizer ??= {}, resolved.deps.optimizer.ssr ??= {}, resolved.deps.optimizer.ssr.enabled ??= false, resolved.deps.optimizer.client ??= {}, resolved.deps.optimizer.client.enabled ??= false, resolved.deps.web ??= {}, resolved.deps.web.transformAssets ??= true, resolved.deps.web.transformCss ??= true, 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)), resolved.coverage.exclude = [
 		...resolved.coverage.exclude,
 		...resolved.setupFiles.map((file) => `${resolved.coverage.allowExternal ? "**/" : ""}${relative(resolved.root, file)}`),
 		...resolved.include,
@@ -3791,32 +3527,22 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		"**/virtual:*",
 		"**/__x00__*",
 		"**/node_modules/**"
-	].filter((pattern) => pattern != null);
-	resolved.forceRerunTriggers = [...resolved.forceRerunTriggers, ...resolved.setupFiles];
-	if (resolved.cliExclude) resolved.exclude.push(...resolved.cliExclude);
+	].filter((pattern) => pattern != null), resolved.forceRerunTriggers = [...resolved.forceRerunTriggers, ...resolved.setupFiles], resolved.cliExclude) resolved.exclude.push(...resolved.cliExclude);
 	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 = [];
+	if (resolved.attachmentsDir = resolve$1(resolved.root, resolved.attachmentsDir ?? ".vitest-attachments"), resolved.snapshotEnvironment) resolved.snapshotEnvironment = resolvePath(resolved.snapshotEnvironment, resolved.root);
+	if (resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0, resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) {
 		// TODO: support it via separate config (like DiffOptions) or via `Function.toString()`
-		if (typeof resolved.snapshotFormat.compareKeys === "function") throw new TypeError(`"snapshotFormat.compareKeys" function is not supported.`);
+		if (resolved.snapshotFormat.plugins = [], typeof resolved.snapshotFormat.compareKeys === "function") throw new TypeError(`"snapshotFormat.compareKeys" function is not supported.`);
 	}
 	const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
-	resolved.snapshotOptions = {
+	if (resolved.snapshotOptions = {
 		expand: resolved.expandSnapshotDiff ?? false,
 		snapshotFormat: resolved.snapshotFormat || {},
 		updateSnapshot: isCI && !UPDATE_SNAPSHOT ? "none" : UPDATE_SNAPSHOT ? "all" : "new",
 		resolveSnapshotPath: options.resolveSnapshotPath,
 		snapshotEnvironment: null
-	};
-	resolved.snapshotSerializers ??= [];
-	resolved.snapshotSerializers = resolved.snapshotSerializers.map((file) => resolvePath(file, resolved.root));
-	resolved.forceRerunTriggers.push(...resolved.snapshotSerializers);
-	if (options.resolveSnapshotPath) delete resolved.resolveSnapshotPath;
-	resolved.pool ??= "threads";
-	if (process.env.VITEST_MAX_THREADS) resolved.poolOptions = {
+	}, resolved.snapshotSerializers ??= [], resolved.snapshotSerializers = resolved.snapshotSerializers.map((file) => resolvePath(file, resolved.root)), resolved.forceRerunTriggers.push(...resolved.snapshotSerializers), options.resolveSnapshotPath) delete resolved.resolveSnapshotPath;
+	if (resolved.pool ??= "threads", process.env.VITEST_MAX_THREADS) resolved.poolOptions = {
 		...resolved.poolOptions,
 		threads: {
 			...resolved.poolOptions?.threads,
@@ -3879,13 +3605,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		resolved.benchmark = {
 			...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;
+		}, 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"];
@@ -3894,17 +3614,13 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		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);
-	}
+	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 = {
+	if (resolved.api = {
 		...api,
 		token: crypto.randomUUID()
-	};
-	if (options.related) resolved.related = toArray(options.related).map((file) => resolve$1(resolved.root, file));
+	}, options.related) resolved.related = toArray(options.related).map((file) => resolve$1(resolved.root, file));
 	/*
 	* Reporters can be defined in many different ways:
 	* { reporter: 'json' }
@@ -3933,85 +3649,51 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	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) => {
-			// ./reporter.js || ../reporter.js, but not .reporters/reporter.js
-			if (/^\.\.?\//.test(reporter)) return resolve$1(process.cwd(), reporter);
-			return reporter;
+		const reportersFromCLI = resolved.reporter, cliReporters = toArray(reportersFromCLI || []).map((reporter) => {
+			return /^\.\.?\//.test(reporter) ? resolve$1(process.cwd(), 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", {}]);
 		// also enable github-actions reporter as a default
-		if (process.env.GITHUB_ACTIONS === "true") resolved.reporters.push(["github-actions", {}]);
+		if (resolved.reporters.push(["default", {}]), 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.css ??= {}, typeof resolved.css === "object") resolved.css.modules ??= {}, resolved.css.modules.classNameStrategy ??= "stable";
 	if (resolved.cache !== false) {
 		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") {
+	if (resolved.sequence ??= {}, resolved.sequence.shuffle && typeof resolved.sequence.shuffle === "object") {
 		const { files, tests } = resolved.sequence.shuffle;
-		resolved.sequence.sequencer ??= files ? RandomSequencer : BaseSequencer;
-		resolved.sequence.shuffle = tests;
+		resolved.sequence.sequencer ??= files ? RandomSequencer : BaseSequencer, resolved.sequence.shuffle = tests;
 	}
 	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();
-	resolved.typecheck = {
+	if (resolved.sequence.groupOrder ??= 0, resolved.sequence.hooks ??= "stack", resolved.sequence.sequencer === RandomSequencer) resolved.sequence.seed ??= Date.now();
+	if (resolved.typecheck = {
 		...configDefaults.typecheck,
 		...resolved.typecheck
-	};
-	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.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$1(resolved.root, resolved.browser.screenshotDirectory);
+	}, resolved.typecheck ??= {}, resolved.typecheck.enabled ??= false, 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."));
+	if (resolved.browser.enabled ??= false, resolved.browser.headless ??= isCI, resolved.browser.isolate ??= true, resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark", resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI, 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([
-			`Browser provider "preview" doesn't support screenshots, `,
-			`so "browser.screenshotFailures" option is forcefully disabled. `,
-			`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;
-	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";
-	resolved.browser.api = resolveApiServerConfig(resolved.browser, defaultBrowserPort) || { port: defaultBrowserPort };
+	if (isPreview && resolved.browser.screenshotFailures === true) console.warn(c.yellow([
+		`Browser provider "preview" doesn't support screenshots, `,
+		`so "browser.screenshotFailures" option is forcefully disabled. `,
+		`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;
+	if (resolved.browser.viewport ??= {}, resolved.browser.viewport.width ??= 414, resolved.browser.viewport.height ??= 896, resolved.browser.locators ??= {}, resolved.browser.locators.testIdAttribute ??= "data-testid", resolved.browser.enabled && provider === "stackblitz") resolved.browser.provider = "preview";
 	// enable includeTaskLocation by default in UI mode
-	if (resolved.browser.enabled) {
+	if (resolved.browser.api = resolveApiServerConfig(resolved.browser, defaultBrowserPort) || { port: defaultBrowserPort }, resolved.browser.enabled) {
 		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";
-		return false;
+		return Array.isArray(reporter) ? reporter[0] === "html" : false;
 	});
 	if (htmlReporter) resolved.includeTaskLocation ??= true;
-	resolved.server ??= {};
-	resolved.server.deps ??= {};
-	resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3;
-	resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4;
-	return resolved;
+	return resolved.server ??= {}, resolved.server.deps ??= {}, resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3, resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4, resolved;
 }
 function isBrowserEnabled(config) {
 	return Boolean(config.browser?.enabled);
@@ -4047,14 +3729,11 @@ const THRESHOLD_KEYS = [
 	"functions",
 	"statements",
 	"branches"
-];
-const GLOBAL_THRESHOLDS_KEY = "global";
-const DEFAULT_PROJECT = Symbol.for("default-project");
+], GLOBAL_THRESHOLDS_KEY = "global", 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();
-	return null;
+	return coverageModule ? coverageModule.getProvider() : null;
 }
 class BaseCoverageProvider {
 	ctx;
@@ -4067,8 +3746,7 @@ class BaseCoverageProvider {
 	coverageFilesDirectory;
 	roots = [];
 	_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} `))}.
+		if (this.ctx = ctx, 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;
@@ -4086,25 +3764,18 @@ Update your dependencies and make sure the versions match.`));
 				statements: config.thresholds["100"] ? 100 : config.thresholds.statements
 			}
 		};
-		const shard = this.ctx.config.shard;
-		const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
-		this.coverageFilesDirectory = resolve$1(this.options.reportsDirectory, tempDirectory);
+		const shard = this.ctx.config.shard, tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
 		// If --project filter is set pick only roots of resolved projects
-		this.roots = ctx.config.project?.length ? [...new Set(ctx.projects.map((project) => project.config.root))] : [ctx.config.root];
+		this.coverageFilesDirectory = resolve$1(this.options.reportsDirectory, tempDirectory), this.roots = ctx.config.project?.length ? [...new Set(ctx.projects.map((project) => project.config.root))] : [ctx.config.root];
 	}
 	/**
 	* Check if file matches `coverage.include` but not `coverage.exclude`
 	*/
 	isIncluded(_filename, root) {
-		const roots = root ? [root] : this.roots;
-		const filename = slash(_filename);
-		const cacheHit = this.globCache.get(filename);
+		const roots = root ? [root] : this.roots, filename = slash(_filename), cacheHit = this.globCache.get(filename);
 		if (cacheHit !== void 0) return cacheHit;
 		// File outside project root with default allowExternal
-		if (this.options.allowExternal === false && roots.every((root) => !filename.startsWith(root))) {
-			this.globCache.set(filename, false);
-			return false;
-		}
+		if (this.options.allowExternal === false && roots.every((root) => !filename.startsWith(root))) return this.globCache.set(filename, false), false;
 		// By default `coverage.include` matches all files, except "coverage.exclude"
 		const glob = this.options.include || "**";
 		let included = roots.some((root) => {
@@ -4116,9 +3787,7 @@ Update your dependencies and make sure the versions match.`));
 			};
 			return pm.isMatch(filename, glob, options);
 		});
-		included &&= existsSync(cleanUrl(filename));
-		this.globCache.set(filename, included);
-		return included;
+		return included &&= existsSync(cleanUrl(filename)), this.globCache.set(filename, included), included;
 	}
 	async getUntestedFilesByRoot(testedFiles, include, root) {
 		let includedFiles = await glob(include, {
@@ -4128,15 +3797,12 @@ Update your dependencies and make sure the versions match.`));
 			dot: true,
 			onlyFiles: true
 		});
-		// Run again through picomatch as tinyglobby's exclude pattern is different ({ "exclude": ["math"] } should ignore "src/math.ts")
-		includedFiles = includedFiles.filter((file) => this.isIncluded(file, root));
-		if (this.ctx.config.changed) includedFiles = (this.ctx.config.related || []).filter((file) => includedFiles.includes(file));
+		if (includedFiles = includedFiles.filter((file) => this.isIncluded(file, root)), this.ctx.config.changed) includedFiles = (this.ctx.config.related || []).filter((file) => includedFiles.includes(file));
 		return includedFiles.map((file) => slash(path.resolve(root, file)));
 	}
 	async getUntestedFiles(testedFiles) {
 		if (this.options.include == null) return [];
-		const rootMapper = this.getUntestedFilesByRoot.bind(this, testedFiles, this.options.include);
-		const matrix = await Promise.all(this.roots.map(rootMapper));
+		const rootMapper = this.getUntestedFilesByRoot.bind(this, testedFiles, this.options.include), matrix = await Promise.all(this.roots.map(rootMapper));
 		return matrix.flatMap((files) => files);
 	}
 	createCoverageMap() {
@@ -4162,41 +3828,28 @@ Update your dependencies and make sure the versions match.`));
 			force: true,
 			maxRetries: 10
 		});
-		await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true });
-		this.coverageFiles = /* @__PURE__ */ new Map();
-		this.pendingPromises = [];
+		await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true }), this.coverageFiles = /* @__PURE__ */ new Map(), this.pendingPromises = [];
 	}
 	onAfterSuiteRun({ coverage, environment, projectName, testFiles }) {
 		if (!coverage) return;
 		let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
-		if (!entry) {
-			entry = {};
-			this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
-		}
-		const testFilenames = testFiles.join();
-		const filename = resolve$1(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
-		entry[environment] ??= {};
+		if (!entry) entry = {}, this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
+		const testFilenames = testFiles.join(), filename = resolve$1(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
 		// If there's a result from previous run, overwrite it
-		entry[environment][testFilenames] = filename;
+		entry[environment] ??= {}, entry[environment][testFilenames] = filename;
 		const promise = promises$1.writeFile(filename, JSON.stringify(coverage), "utf-8");
 		this.pendingPromises.push(promise);
 	}
 	async readCoverageFiles({ onFileRead, onFinished, onDebug }) {
 		let index = 0;
 		const total = this.pendingPromises.length;
-		await Promise.all(this.pendingPromises);
-		this.pendingPromises = [];
+		await Promise.all(this.pendingPromises), this.pendingPromises = [];
 		for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) for (const [environment, coverageByTestfiles] of Object.entries(coveragePerProject)) {
-			const filenames = Object.values(coverageByTestfiles);
-			const project = this.ctx.getProjectByName(projectName);
+			const filenames = Object.values(coverageByTestfiles), 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}`);
-				}
+				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);
+					const contents = await promises$1.readFile(filename, "utf-8"), coverage = JSON.parse(contents);
 					onFileRead(coverage);
 				}));
 			}
@@ -4204,10 +3857,8 @@ Update your dependencies and make sure the versions match.`));
 		}
 	}
 	async cleanAfterRun() {
-		this.coverageFiles = /* @__PURE__ */ new Map();
-		await promises$1.rm(this.coverageFilesDirectory, { 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 });
+		if (this.coverageFiles = /* @__PURE__ */ new Map(), await promises$1.rm(this.coverageFilesDirectory, { recursive: true }), readdirSync(this.options.reportsDirectory).length === 0) await promises$1.rm(this.options.reportsDirectory, { recursive: true });
 	}
 	async onTestFailure() {
 		if (!this.options.reportOnFailure) await this.cleanAfterRun();
@@ -4220,11 +3871,9 @@ Update your dependencies and make sure the versions match.`));
 	}
 	async reportThresholds(coverageMap, allTestsRun) {
 		const resolvedThresholds = this.resolveThresholds(coverageMap);
-		this.checkThresholds(resolvedThresholds);
-		if (this.options.thresholds?.autoUpdate && allTestsRun) {
+		if (this.checkThresholds(resolvedThresholds), 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.");
-			const configFilePath = this.ctx.server.config.configFile;
-			const configModule = await this.parseConfigModule(configFilePath);
+			const configFilePath = this.ctx.server.config.configFile, configModule = await this.parseConfigModule(configFilePath);
 			await this.updateThresholds({
 				thresholds: resolvedThresholds,
 				configurationFile: configModule,
@@ -4238,16 +3887,10 @@ Update your dependencies and make sure the versions match.`));
 	* for specific files defined by glob pattern or global for all other files.
 	*/
 	resolveThresholds(coverageMap) {
-		const resolvedThresholds = [];
-		const files = coverageMap.files();
-		const globalCoverageMap = this.createCoverageMap();
+		const resolvedThresholds = [], files = coverageMap.files(), globalCoverageMap = this.createCoverageMap();
 		for (const key of Object.keys(this.options.thresholds)) {
 			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();
-			const matcher = pm(glob);
-			const matchingFiles = files.filter((file) => matcher(relative(this.ctx.config.root, file)));
+			const glob = key, globThresholds = resolveGlobThresholds(this.options.thresholds[glob]), globCoverageMap = this.createCoverageMap(), matcher = pm(glob), matchingFiles = files.filter((file) => matcher(relative(this.ctx.config.root, file)));
 			for (const file of matchingFiles) {
 				const fileCoverage = coverageMap.fileCoverageFor(file);
 				globCoverageMap.addFileCoverage(fileCoverage);
@@ -4263,7 +3906,7 @@ Update your dependencies and make sure the versions match.`));
 			const fileCoverage = coverageMap.fileCoverageFor(file);
 			globalCoverageMap.addFileCoverage(fileCoverage);
 		}
-		resolvedThresholds.unshift({
+		return resolvedThresholds.unshift({
 			name: GLOBAL_THRESHOLDS_KEY,
 			coverageMap: globalCoverageMap,
 			thresholds: {
@@ -4272,8 +3915,7 @@ Update your dependencies and make sure the versions match.`));
 				lines: this.options.thresholds?.lines,
 				statements: this.options.thresholds?.statements
 			}
-		});
-		return resolvedThresholds;
+		}), resolvedThresholds;
 	}
 	/**
 	* Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
@@ -4311,8 +3953,7 @@ Update your dependencies and make sure the versions match.`));
 						this.ctx.logger.error(errorMessage);
 					}
 				} else {
-					const uncovered = summary.data[thresholdKey].total - summary.data[thresholdKey].covered;
-					const absoluteThreshold = threshold * -1;
+					const uncovered = summary.data[thresholdKey].total - summary.data[thresholdKey].covered, absoluteThreshold = threshold * -1;
 					if (uncovered > absoluteThreshold) {
 						process.exitCode = 1;
 						/**
@@ -4336,8 +3977,7 @@ Update your dependencies and make sure the versions match.`));
 		const config = resolveConfig(configurationFile);
 		assertConfigurationModule(config);
 		for (const { coverageMap, thresholds, name } of allThresholds) {
-			const summaries = this.options.thresholds?.perFile ? coverageMap.files().map((file) => coverageMap.fileCoverageFor(file).toSummary()) : [coverageMap.getCoverageSummary()];
-			const thresholdsToUpdate = [];
+			const summaries = this.options.thresholds?.perFile ? coverageMap.files().map((file) => coverageMap.fileCoverageFor(file).toSummary()) : [coverageMap.getCoverageSummary()], thresholdsToUpdate = [];
 			for (const key of THRESHOLD_KEYS) {
 				const threshold = thresholds[key] ?? 100;
 				/**
@@ -4348,8 +3988,7 @@ Update your dependencies and make sure the versions match.`));
 					const actual = Math.min(...summaries.map((summary) => summary[key].pct));
 					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));
+					const absoluteThreshold = threshold * -1, 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;
@@ -4365,10 +4004,7 @@ Update your dependencies and make sure the versions match.`));
 				glob[threshold] = newValue;
 			}
 		}
-		if (updatedThresholds) {
-			this.ctx.logger.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds.");
-			onUpdate();
-		}
+		if (updatedThresholds) this.ctx.logger.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds."), onUpdate();
 	}
 	async mergeReports(coverageMaps) {
 		const coverageMap = this.createCoverageMap();
@@ -4380,10 +4016,8 @@ Update your dependencies and make sure the versions match.`));
 	}
 	toSlices(array, size) {
 		return array.reduce((chunks, item) => {
-			const index = Math.max(0, chunks.length - 1);
-			const lastChunk = chunks[index] || [];
-			chunks[index] = lastChunk;
-			if (lastChunk.length >= size) chunks.push([item]);
+			const index = Math.max(0, chunks.length - 1), lastChunk = chunks[index] || [];
+			if (chunks[index] = lastChunk, lastChunk.length >= size) chunks.push([item]);
 			else lastChunk.push(item);
 			return chunks;
 		}, []);
@@ -4393,13 +4027,13 @@ Update your dependencies and make sure the versions match.`));
 			root: project.config.root,
 			isBrowserEnabled: project.isBrowserEnabled(),
 			vite: project.vite
-		})), 
+		})), (
 		// Check core last as it will match all files anyway
-{
+		{
 			root: ctx.config.root,
 			vite: ctx.vite,
 			isBrowserEnabled: ctx.getRootProject().isBrowserEnabled()
-		}];
+		})];
 		return async function transformFile(filename) {
 			let lastError;
 			for (const { root, vite, isBrowserEnabled } of servers) {
@@ -4424,14 +4058,12 @@ Update your dependencies and make sure the versions match.`));
 * 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 {
+	return !thresholds || typeof thresholds !== "object" ? {} : 100 in thresholds && thresholds[100] === true ? {
 		lines: 100,
 		branches: 100,
 		functions: 100,
 		statements: 100
-	};
-	return {
+	} : {
 		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,
@@ -4457,8 +4089,7 @@ function resolveConfig(configModule) {
 		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 = resolveMergeConfig(mod), config) return config;
 		}
 	} catch (error) {
 		// Reduce magicast's verbose errors to readable ones