vitest 4.0.0-beta.1 → 4.0.0-beta.10

package/dist/chunks/{coverage.Cwa-XhJt.js → coverage.BCU-r2QL.js}

@@ -1,13 +1,12 @@
 import fs, { statSync, realpathSync, promises as promises$1, mkdirSync, existsSync, readdirSync, writeFileSync } from 'node:fs';
 import path, { win32, dirname, join, resolve } from 'node:path';
+import { isExternalUrl, unwrapId, nanoid, withTrailingSlash as withTrailingSlash$1, cleanUrl, wrapId, createDefer, slash, shuffle, toArray } from '@vitest/utils';
 import { isAbsolute, join as join$1, dirname as dirname$1, resolve as resolve$1, relative, normalize } from 'pathe';
 import pm from 'picomatch';
 import { glob } from 'tinyglobby';
 import c from 'tinyrainbow';
-import { slash, cleanUrl } from 'vite-node/utils';
 import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.CXFFjsi8.js';
 import crypto from 'node:crypto';
-import { createDefer, shuffle, toArray, slash as slash$1 } from '@vitest/utils';
 import { builtinModules, createRequire } from 'node:module';
 import process$1 from 'node:process';
 import fs$1, { writeFile, rename, stat, unlink } from 'node:fs/promises';
@@ -15,28 +14,26 @@ import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL
 import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
-import { version, mergeConfig } from 'vite';
-import { c as configFiles, w as workspacesFiles, e as extraInlineDeps, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.DnKduX2e.js';
+import { fetchModule, version, mergeConfig } from 'vite';
+import { c as configFiles, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.D_Q9UYh-.js';
 import { a as isWindows } from './env.D4Lgay0q.js';
 import * as nodeos from 'node:os';
-import nodeos__default from 'node:os';
+import nodeos__default, { tmpdir } from 'node:os';
 import { isatty } from 'node:tty';
 import EventEmitter from 'node:events';
-import { c as createBirpc } from './index.B521nVV-.js';
+import { c as createBirpc } from './index.Bgo3tNWt.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.CVytUJuF.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.DB-fIMaH.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';
 import { isCI, provider } from 'std-env';
-import { r as resolveCoverageProviderModule } from './coverage.DVF1vEu8.js';
+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() {
@@ -2017,7 +2014,7 @@ function normalizeid(id) {
   if (typeof id !== "string") {
     id = id.toString();
   }
-  if (/(node|data|http|https|file):/.test(id)) {
+  if (/(?:node|data|http|https|file):/.test(id)) {
     return id;
   }
   if (BUILTIN_MODULES.has(id)) {
@@ -2051,7 +2048,7 @@ function _resolve$1(id, options = {}) {
       throw new TypeError("input must be a `string` or `URL`");
     }
   }
-  if (/(node|data|http|https):/.test(id)) {
+  if (/(?:node|data|http|https):/.test(id)) {
     return id;
   }
   if (BUILTIN_MODULES.has(id)) {
@@ -2385,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));
 }
 
@@ -2396,35 +2392,19 @@ const envsOrder = [
 	"happy-dom",
 	"edge-runtime"
 ];
-function getTransformMode(patterns, filename) {
-	if (patterns.web && pm.isMatch(filename, patterns.web)) return "web";
-	if (patterns.ssr && pm.isMatch(filename, patterns.ssr)) return "ssr";
-	return void 0;
-}
 async function groupFilesByEnv(files) {
 	const filesWithEnv = await Promise.all(files.map(async ({ moduleId: filepath, project, testLines }) => {
 		const code = await promises$1.readFile(filepath, "utf-8");
 		// 1. Check for control comments in the file
 		let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
-		// 2. Check for globals
-		if (!env) {
-			for (const [glob, target] of project.config.environmentMatchGlobs || []) if (pm.isMatch(filepath, glob, { cwd: project.config.root })) {
-				env = target;
-				break;
-			}
-		}
-		// 3. Fallback to global env
+		// 2. Fallback to global env
 		env ||= project.config.environment || "node";
-		const transformMode = getTransformMode(project.config.testTransformMode, filepath);
 		let envOptionsJson = code.match(/@(?:vitest|jest)-environment-options\s+(.+)/)?.[1];
 		if (envOptionsJson?.endsWith("*/"))
  // 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,
-			transformMode,
 			options: envOptions ? { [envKey]: envOptions } : null
 		};
 		return {
@@ -2439,45 +2419,198 @@ 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) => {
+		// We are copy pasting Vite's externalization logic from `fetchModule` because
+		// we instead rely on our own `shouldExternalize` method because Vite
+		// doesn't support `resolve.external` in non SSR environments (jsdom/happy-dom)
+		if (url.startsWith("data:")) return {
+			externalize: url,
+			type: "builtin"
+		};
+		if (url === "/@vite/client" || url === "@vite/client")
+ // this will be stubbed
+		return {
+			externalize: "/@vite/client",
+			type: "module"
+		};
+		const isFileUrl = url.startsWith("file://");
+		if (isExternalUrl(url) && !isFileUrl) return {
+			externalize: url,
+			type: "network"
+		};
+		// Vite does the same in `fetchModule`, but we want to externalize modules ourselves,
+		// 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)), 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) {
+			const externalize = await resolver.shouldExternalize(moduleGraphModule.id);
+			if (externalize) return {
+				externalize,
+				type: "module"
+			};
+		}
+		const moduleRunnerModule = await fetchModule(environment, url, importer, {
+			...options,
+			inlineSourceMap: false
+		}).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), 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";
+SOURCEMAPPING_URL += "ppingURL";
+const MODULE_RUNNER_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-generated";
+function processResultSource(environment, result) {
+	if (!("code" in result)) return result;
+	const node = environment.moduleGraph.getModuleById(result.id);
+	if (node?.transformResult)
+ // this also overrides node.transformResult.code which is also what the module
+	// runner does under the hood by default (we disable source maps inlining)
+	inlineSourceMap(node.transformResult);
+	return {
+		...result,
+		code: node?.transformResult?.code || result.code
+	};
+}
+const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, "gm");
+// we have to inline the source map ourselves, because
+// - we don't need //# sourceURL since we are running code in VM
+//   - important in stack traces and the V8 coverage
+// - we need to inject an empty line for --inspect-brk
+function inlineSourceMap(result) {
+	const map = result.map;
+	let code = result.code;
+	if (!map || !("version" in map) || code.includes(MODULE_RUNNER_SOURCEMAPPING_SOURCE)) return result;
+	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}`;
+	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);
+	return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
+}
+function getCachedResult(result, cachedFsResults) {
+	const tmp = cachedFsResults.get(result.id);
+	if (!tmp) throw new Error(`The cached result was returned too early for ${result.id}.`);
+	return {
+		cached: true,
+		file: result.file,
+		id: result.id,
+		tmp,
+		url: result.url,
+		invalidate: result.invalidate
+	};
+}
+// serialize rollup error on server to preserve details as a test error
+function handleRollupError(e) {
+	throw e instanceof Error && ("plugin" in e || "frame" in e || "id" in e) ? {
+		name: e.name,
+		message: e.message,
+		stack: e.stack,
+		cause: e.cause,
+		__vitest_rollup_error__: {
+			plugin: e.plugin,
+			id: e.id,
+			loc: e.loc,
+			frame: e.frame
+		}
+	} : e;
+}
+/**
+* Performs an atomic write operation using the write-then-rename pattern.
+*
+* Why we need this:
+* - Ensures file integrity by never leaving partially written files on disk
+* - Prevents other processes from reading incomplete data during writes
+* - Particularly important for test files where incomplete writes could cause test failures
+*
+* The implementation writes to a temporary file first, then renames it to the target path.
+* This rename operation is atomic on most filesystems (including POSIX-compliant ones),
+* guaranteeing that other processes will only ever see the complete file.
+*
+* Added in https://github.com/vitest-dev/vitest/pull/7531
+*/
+async function atomicWriteFile(realFilePath, data) {
+	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);
+	} finally {
+		try {
+			if (await stat(tmpFilePath)) await unlink(tmpFilePath);
+		} catch {}
+	}
+}
+
+// this is copy pasted from vite
+function normalizeResolvedIdToUrl(environment, resolvedId) {
+	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'`
+	if (resolvedId.startsWith(withTrailingSlash$1(root)))
+ // in root: infer short absolute path from root
+	url = resolvedId.slice(root.length);
+	else if (depsOptimizer?.isOptimizedDepFile(resolvedId) || resolvedId !== "/@react-refresh" && path.isAbsolute(resolvedId) && existsSync(cleanUrl(resolvedId)))
+ // an optimized deps may not yet exists in the filesystem, or
+	// a regular file exists but is out of root: rewrite to absolute /@fs/ paths
+	url = path.posix.join("/@fs/", resolvedId);
+	else url = resolvedId;
+	// if the resolved id is not a valid browser import specifier,
+	// prefix it to make it valid. We will strip this before feeding it
+	// back into the transform pipeline
+	if (url[0] !== "." && url[0] !== "/") url = wrapId(resolvedId);
+	return url;
+}
+
 function createMethodsRPC(project, options = {}) {
-	const ctx = project.vitest;
-	const cacheFs = options.cacheFs ?? false;
+	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];
+			if (!environment) throw new Error(`The environment ${environmentName} was not defined in the Vite config.`);
+			const start = performance.now();
+			try {
+				return await fetch(url, importer, environment, options);
+			} finally {
+				project.vitest.state.transformTime += performance.now() - start;
+			}
+		},
+		async resolve(id, importer, environmentName) {
+			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);
+			return resolved ? {
+				file: cleanUrl(resolved.id),
+				url: normalizeResolvedIdToUrl(environment, resolved.id),
+				id: resolved.id
+			} : null;
+		},
 		snapshotSaved(snapshot) {
 			ctx.snapshot.add(snapshot);
 		},
 		resolveSnapshotPath(testPath) {
 			return ctx.snapshot.resolvePath(testPath, { config: project.serializedConfig });
 		},
-		async fetch(id, transformMode) {
-			const result = await project.vitenode.fetchResult(id, transformMode).catch(handleRollupError);
-			const code = result.code;
-			if (!cacheFs || result.externalize) return result;
-			if ("id" in result && typeof result.id === "string") return { id: result.id };
-			if (code == null) throw new Error(`Failed to fetch module ${id}`);
-			const dir = join$1(project.tmpDir, transformMode);
-			const name = hash("sha1", 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);
-				return { id: tmp };
-			}
-			promises.set(tmp, atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp)));
-			await promises.get(tmp);
-			Object.assign(result, { id: tmp });
-			return { id: tmp };
-		},
-		resolveId(id, importer, transformMode) {
-			return project.vitenode.resolveId(id, importer, transformMode).catch(handleRollupError);
-		},
-		transform(id, environment) {
-			return project.vitenode.transformModule(id, environment).catch(handleRollupError);
+		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)), result = await environment.transformRequest(url).catch(handleRollupError);
+			return { code: result?.code };
 		},
 		async onQueued(file) {
 			if (options.collect) ctx.state.collectFiles(project, [file]);
@@ -2512,63 +2645,12 @@ function createMethodsRPC(project, options = {}) {
 		}
 	};
 }
-// serialize rollup error on server to preserve details as a test error
-function handleRollupError(e) {
-	if (e instanceof Error && ("plugin" in e || "frame" in e || "id" in e))
- // eslint-disable-next-line no-throw-literal
-	throw {
-		name: e.name,
-		message: e.message,
-		stack: e.stack,
-		cause: e.cause,
-		__vitest_rollup_error__: {
-			plugin: e.plugin,
-			id: e.id,
-			loc: e.loc,
-			frame: e.frame
-		}
-	};
-	throw e;
-}
-/**
-* Performs an atomic write operation using the write-then-rename pattern.
-*
-* Why we need this:
-* - Ensures file integrity by never leaving partially written files on disk
-* - Prevents other processes from reading incomplete data during writes
-* - Particularly important for test files where incomplete writes could cause test failures
-*
-* The implementation writes to a temporary file first, then renames it to the target path.
-* This rename operation is atomic on most filesystems (including POSIX-compliant ones),
-* guaranteeing that other processes will only ever see the complete file.
-*
-* 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)}`);
-	try {
-		await writeFile(tmpFilePath, data, "utf-8");
-		await rename(tmpFilePath, realFilePath);
-	} finally {
-		try {
-			if (await stat(tmpFilePath)) await unlink(tmpFilePath);
-		} catch {}
-	}
-}
 
 function createChildProcessChannel$1(project, collect = false) {
-	const emitter = new EventEmitter();
-	const events = {
+	const emitter = new EventEmitter(), events = {
 		message: "message",
 		response: "response"
-	};
-	const channel = {
-		onMessage: (callback) => emitter.on(events.message, callback),
-		postMessage: (message) => emitter.emit(events.response, message),
-		onClose: () => emitter.removeAllListeners()
-	};
-	const rpc = createBirpc(createMethodsRPC(project, {
+	}, rpc = createBirpc(createMethodsRPC(project, {
 		cacheFs: true,
 		collect
 	}), {
@@ -2591,21 +2673,20 @@ function createChildProcessChannel$1(project, collect = false) {
 		on(fn) {
 			emitter.on(events.response, fn);
 		},
-		onTimeoutError(functionName) {
-			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-		}
+		timeout: -1
 	});
 	project.vitest.onCancel((reason) => rpc.onCancel(reason));
+	const channel = {
+		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"));
+		}
+	};
 	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 = {
+function createForksPool(vitest, { execArgv, env }, specifications) {
+	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), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.forks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, worker = resolve(vitest.distPath, "workers/forks.js"), options = {
 		runtime: "child_process",
 		filename: resolve(vitest.distPath, "worker.js"),
 		teardown: "teardown",
@@ -2615,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,
@@ -2656,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.serializedConfig, 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;
@@ -2713,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);
@@ -2724,24 +2780,20 @@ function createWorkerChannel$1(project, collect) {
 		on(fn) {
 			port.on("message", fn);
 		},
-		onTimeoutError(functionName) {
-			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-		}
+		timeout: -1
 	});
 	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"));
+	};
 	return {
 		workerPort,
-		port
+		port,
+		onClose
 	};
 }
-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 = {
+function createThreadsPool(vitest, { execArgv, env }, specifications) {
+	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), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.threads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, worker = resolve(vitest.distPath, "workers/threads.js"), options = {
 		filename: resolve(vitest.distPath, "worker.js"),
 		teardown: "teardown",
 		useAtomics: poolOptions.useAtomics ?? false,
@@ -2751,26 +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, port } = createWorkerChannel$1(project, name === "collect");
-			const onClose = () => {
-				port.close();
-				workerPort.close();
-			};
-			const workerId = ++id;
-			const data = {
+			const { workerPort, onClose } = createWorkerChannel$1(project, name === "collect"), workerId = ++id, data = {
 				pool: "threads",
 				worker,
 				port: workerPort,
@@ -2798,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;
@@ -2854,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);
 	}
@@ -2993,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;
@@ -3010,26 +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 cleanup = () => emitter.removeAllListeners();
-	const events = {
+	const emitter = new EventEmitter(), events = {
 		message: "message",
 		response: "response"
-	};
-	const channel = {
-		onMessage: (callback) => emitter.on(events.message, callback),
-		postMessage: (message) => emitter.emit(events.response, message)
-	};
-	const rpc = createBirpc(createMethodsRPC(project, {
+	}, rpc = createBirpc(createMethodsRPC(project, {
 		cacheFs: true,
 		collect
 	}), {
@@ -3052,24 +3039,20 @@ function createChildProcessChannel(project, collect) {
 		on(fn) {
 			emitter.on(events.response, fn);
 		},
-		onTimeoutError(functionName) {
-			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-		}
+		timeout: -1
 	});
 	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	return {
-		channel,
-		cleanup
+	const channel = {
+		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"));
+		}
 	};
+	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 = {
+function createVmForksPool(vitest, { execArgv, env }, specifications) {
+	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), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.vmForks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, worker = resolve(vitest.distPath, "workers/vmForks.js"), options = {
 		runtime: "child_process",
 		filename: resolve(vitest.distPath, "worker.js"),
 		maxThreads,
@@ -3087,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, cleanup } = createChildProcessChannel(project, name === "collect");
-			const workerId = ++id;
-			const data = {
+			const { channel } = createChildProcessChannel(project, name === "collect"), workerId = ++id, data = {
 				pool: "forks",
 				worker,
 				config,
@@ -3121,24 +3098,17 @@ function createVmForksPool(vitest, { execArgv, env }) {
 				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
 				else throw error;
 			} finally {
-				cleanup();
+				channel.onClose();
 			}
 		}
 		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.");
 		};
 	};
@@ -3150,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);
@@ -3172,24 +3135,19 @@ function createWorkerChannel(project, collect) {
 		on(fn) {
 			port.on("message", fn);
 		},
-		onTimeoutError(functionName) {
-			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-		}
+		timeout: -1
 	});
 	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"));
+	}
 	return {
 		workerPort,
-		port
+		onClose
 	};
 }
-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 = {
+function createVmThreadsPool(vitest, { execArgv, env }, specifications) {
+	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), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.vmThreads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, worker = resolve(vitest.distPath, "workers/vmThreads.js"), options = {
 		filename: resolve(vitest.distPath, "worker.js"),
 		useAtomics: poolOptions.useAtomics ?? false,
 		maxThreads,
@@ -3207,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, port } = createWorkerChannel(project, name === "collect");
-			const workerId = ++id;
-			const data = {
+			const { workerPort, onClose } = createWorkerChannel(project, name === "collect"), workerId = ++id, data = {
 				pool: "vmThreads",
 				worker,
 				port: workerPort,
@@ -3242,24 +3194,17 @@ function createVmThreadsPool(vitest, { execArgv, env }) {
 				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
 				else throw error;
 			} finally {
-				port.close();
-				workerPort.close();
+				onClose();
 			}
 		}
 		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.");
 		};
 	};
@@ -3271,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 = [
@@ -3289,14 +3230,9 @@ 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, file) {
-	for (const [glob, pool] of project.config.poolMatchGlobs) {
-		if (pool === "browser") throw new Error("Since Vitest 0.31.0 \"browser\" pool is not supported in `poolMatchGlobs`. You can create a project to run some of your tests in browser in parallel. Read more: https://vitest.dev/guide/projects");
-		if (pm.isMatch(file, glob, { cwd: project.config.root })) return pool;
-	}
+function getFilePoolName(project) {
 	return getDefaultPoolName(project);
 }
 function createPool(ctx) {
@@ -3307,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],
@@ -3342,25 +3267,22 @@ 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.executeId(filepath);
+			const pool = await ctx.runner.import(filepath);
 			if (typeof pool.default !== "function") throw new TypeError(`Custom pool "${filepath}" must export a function as default export`);
 			const poolInstance = await pool.default(ctx, options);
 			if (typeof poolInstance?.name !== "string") throw new TypeError(`Custom pool "${filepath}" should return an object with "name" property`);
 			if (typeof poolInstance?.[method] !== "function") throw new TypeError(`Custom pool "${filepath}" should return an object with "${method}" method`);
-			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));
@@ -3371,23 +3293,18 @@ function createPool(ctx) {
 				return createBrowserPool(ctx);
 			});
 		}
-		const groupedSpecifications = {};
-		const groups = /* @__PURE__ */ new Set();
-		const factories = {
-			vmThreads: () => createVmThreadsPool(ctx, options),
-			vmForks: () => createVmForksPool(ctx, options),
-			threads: () => createThreadsPool(ctx, options),
-			forks: () => createForksPool(ctx, options),
+		const groupedSpecifications = {}, groups = /* @__PURE__ */ new Set(), factories = {
+			vmThreads: (specs) => createVmThreadsPool(ctx, options, specs),
+			vmForks: (specs) => createVmForksPool(ctx, options, specs),
+			threads: (specs) => createThreadsPool(ctx, options, specs),
+			forks: (specs) => createForksPool(ctx, options, specs),
 			typescript: () => createTypecheckPool(ctx)
 		};
 		for (const spec of files) {
-			const group = spec[0].config.sequence.groupOrder ?? 0;
-			groups.add(group);
-			groupedSpecifications[group] ??= [];
-			groupedSpecifications[group].push(spec);
+			const group = spec.project.config.sequence.groupOrder ?? 0;
+			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}.`);
@@ -3407,26 +3324,19 @@ function createPool(ctx) {
 				typescript: []
 			};
 			specifications.forEach((specification) => {
-				const pool = specification[2].pool;
-				filesByPool[pool] ??= [];
-				filesByPool[pool].push(specification);
-			});
-			await Promise.all(Object.entries(filesByPool).map(async (entry) => {
+				const pool = specification.pool;
+				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(specs), 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);
 			}));
 		}
 	}
@@ -3447,14 +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 shardSize = Math.ceil(files.length / count);
-		const shardStart = shardSize * (index - 1);
-		const shardEnd = shardSize * index;
+		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")
@@ -3465,25 +3370,26 @@ 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), remainderTestFilesCount = filesCount % count;
+		if (remainderTestFilesCount >= index) {
+			const shardSize = baseShardSize + 1, shardStart = shardSize * (index - 1), shardEnd = shardSize * index;
+			return [shardStart, shardEnd];
+		}
+		const shardStart = remainderTestFilesCount * (baseShardSize + 1) + (index - remainderTestFilesCount - 1) * baseShardSize, shardEnd = shardStart + baseShardSize;
+		return [shardStart, shardEnd];
+	}
 }
 
 class RandomSequencer extends BaseSequencer {
@@ -3501,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;
@@ -3523,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";
@@ -3539,24 +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.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 = {
@@ -3567,21 +3463,12 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	if (resolved.standalone && !resolved.watch) throw new Error(`Vitest standalone mode requires --watch`);
 	if (resolved.mergeReports && resolved.watch) throw new Error(`Cannot merge reports with --watch enabled`);
 	if (resolved.maxWorkers) resolved.maxWorkers = resolveInlineWorkerOption(resolved.maxWorkers);
-	if (resolved.minWorkers) resolved.minWorkers = resolveInlineWorkerOption(resolved.minWorkers);
-	// run benchmark sequentially by default
-	resolved.fileParallelism ??= mode !== "benchmark";
-	if (!resolved.fileParallelism) {
-		// ignore user config, parallelism cannot be implemented without limiting workers
-		resolved.maxWorkers = 1;
-		resolved.minWorkers = 1;
-	}
-	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)
+ // ignore user config, parallelism cannot be implemented without limiting workers
+	resolved.maxWorkers = 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"`);
@@ -3602,113 +3489,78 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	const playwrightChromiumOnly = isPlaywrightChromiumOnly(vitest, resolved);
 	// Browser-mode "Playwright + Chromium" only features:
 	if (browser.enabled && !playwrightChromiumOnly) {
-		const browserConfig = { browser: {
-			provider: browser.provider,
-			name: browser.name,
-			instances: browser.instances?.map((i) => ({ browser: i.browser }))
-		} };
-		if (resolved.coverage.enabled && resolved.coverage.provider === "v8") throw new Error(`@vitest/coverage-v8 does not work with\n${JSON.stringify(browserConfig, null, 2)}\n\nUse either:\n${JSON.stringify({ browser: {
-			provider: "playwright",
-			instances: [{ browser: "chromium" }]
-		} }, null, 2)}\n\n...or change your coverage provider to:\n${JSON.stringify({ coverage: { provider: "istanbul" } }, null, 2)}\n`);
+		const browserConfig = `
+{
+  browser: {
+    provider: ${browser.provider?.name || "preview"}(),
+    instances: [
+      ${(browser.instances || []).map((i) => `{ browser: '${i.browser}' }`).join(",\n      ")}
+    ],
+  },
+}
+    `.trim(), correctExample = `
+{
+  browser: {
+    provider: playwright(),
+    instances: [
+      { browser: 'chromium' }
+    ],
+  },
+}
+    `.trim();
+		if (resolved.coverage.enabled && resolved.coverage.provider === "v8") {
+			const coverageExample = `
+{
+  coverage: {
+    provider: 'istanbul',
+  },
+}
+      `.trim();
+			throw new Error(`@vitest/coverage-v8 does not work with\n${browserConfig}\n\nUse either:\n${correctExample}\n\n...or change your coverage provider to:\n${coverageExample}\n`);
+		}
 		if (resolved.inspect || resolved.inspectBrk) {
 			const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
-			throw new Error(`${inspectOption} does not work with\n${JSON.stringify(browserConfig, null, 2)}\n\nUse either:\n${JSON.stringify({ browser: {
-				provider: "playwright",
-				instances: [{ browser: "chromium" }]
-			} }, null, 2)}\n\n...or disable ${inspectOption}\n`);
+			throw new Error(`${inspectOption} does not work with\n${browserConfig}\n\nUse either:\n${correctExample}\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.deps.moduleDirectories = resolved.deps.moduleDirectories.map((dir) => {
+	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(","));
+	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 ??= true;
-	resolved.deps.optimizer.web ??= {};
-	resolved.deps.optimizer.web.enabled ??= true;
-	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,
-		resolved.config && slash$1(resolved.config),
+		resolved.config && slash(resolved.config),
 		...configFiles,
-		...workspacesFiles,
 		"**/virtual:*",
 		"**/__x00__*",
 		"**/node_modules/**"
-	].filter((pattern) => pattern != null);
-	resolved.forceRerunTriggers = [...resolved.forceRerunTriggers, ...resolved.setupFiles];
-	resolved.server ??= {};
-	resolved.server.deps ??= {};
-	const deprecatedDepsOptions = [
-		"inline",
-		"external",
-		"fallbackCJS"
-	];
-	deprecatedDepsOptions.forEach((option) => {
-		if (resolved.deps[option] === void 0) return;
-		if (option === "fallbackCJS") logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. Use "server.deps.${option}" instead`));
-		else {
-			const transformMode = resolved.environment === "happy-dom" || resolved.environment === "jsdom" ? "web" : "ssr";
-			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. If you rely on vite-node directly, use "server.deps.${option}" instead. Otherwise, consider using "deps.optimizer.${transformMode}.${option === "external" ? "exclude" : "include"}"`));
-		}
-		if (resolved.server.deps[option] === void 0) resolved.server.deps[option] = resolved.deps[option];
-	});
-	if (resolved.cliExclude) resolved.exclude.push(...resolved.cliExclude);
-	// vitenode will try to import such file with native node,
-	// but then our mocker will not work properly
-	if (resolved.server.deps.inline !== true) {
-		const ssrOptions = viteConfig.ssr;
-		if (ssrOptions?.noExternal === true && resolved.server.deps.inline == null) resolved.server.deps.inline = true;
-		else {
-			resolved.server.deps.inline ??= [];
-			resolved.server.deps.inline.push(...extraInlineDeps);
-		}
-	}
-	resolved.server.deps.inlineFiles ??= [];
-	resolved.server.deps.inlineFiles.push(...resolved.setupFiles);
-	resolved.server.deps.moduleDirectories ??= [];
-	resolved.server.deps.moduleDirectories.push(...resolved.deps.moduleDirectories);
+	].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 (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,
@@ -3719,17 +3571,6 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
 		}
 	};
-	if (process.env.VITEST_MIN_THREADS) resolved.poolOptions = {
-		...resolved.poolOptions,
-		threads: {
-			...resolved.poolOptions?.threads,
-			minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-		},
-		vmThreads: {
-			...resolved.poolOptions?.vmThreads,
-			minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-		}
-	};
 	if (process.env.VITEST_MAX_FORKS) resolved.poolOptions = {
 		...resolved.poolOptions,
 		forks: {
@@ -3741,51 +3582,16 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
 		}
 	};
-	if (process.env.VITEST_MIN_FORKS) resolved.poolOptions = {
-		...resolved.poolOptions,
-		forks: {
-			...resolved.poolOptions?.forks,
-			minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-		},
-		vmForks: {
-			...resolved.poolOptions?.vmForks,
-			minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-		}
-	};
-	const poolThreadsOptions = [
-		["threads", "minThreads"],
-		["threads", "maxThreads"],
-		["vmThreads", "minThreads"],
-		["vmThreads", "maxThreads"]
-	];
+	const poolThreadsOptions = [["threads", "maxThreads"], ["vmThreads", "maxThreads"]];
 	for (const [poolOptionKey, workerOptionKey] of poolThreadsOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-	const poolForksOptions = [
-		["forks", "minForks"],
-		["forks", "maxForks"],
-		["vmForks", "minForks"],
-		["vmForks", "maxForks"]
-	];
+	const poolForksOptions = [["forks", "maxForks"], ["vmForks", "maxForks"]];
 	for (const [poolOptionKey, workerOptionKey] of poolForksOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-	if (typeof resolved.workspace === "string")
- // if passed down from the CLI and it's relative, resolve relative to CWD
-	resolved.workspace = typeof options.workspace === "string" && options.workspace[0] === "." ? resolve$1(process.cwd(), options.workspace) : resolvePath(resolved.workspace, resolved.root);
 	if (!builtinPools.includes(resolved.pool)) resolved.pool = resolvePath(resolved.pool, resolved.root);
-	if (resolved.poolMatchGlobs) logger.deprecate("`poolMatchGlobs` is deprecated. Use `test.projects` to define different configurations instead.");
-	resolved.poolMatchGlobs = (resolved.poolMatchGlobs || []).map(([glob, pool]) => {
-		if (!builtinPools.includes(pool)) pool = resolvePath(pool, resolved.root);
-		return [glob, pool];
-	});
 	if (mode === "benchmark") {
 		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"];
@@ -3794,17 +3600,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' }
@@ -3833,86 +3635,55 @@ 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
-	};
-	if (resolved.environmentMatchGlobs) logger.deprecate("\"environmentMatchGlobs\" is deprecated. Use `test.projects` to define different configurations instead.");
-	resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve$1(resolved.root, i[0]), i[1]]);
-	resolved.typecheck ??= {};
-	resolved.typecheck.enabled ??= false;
-	if (resolved.typecheck.enabled) logger.console.warn(c.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."));
-	resolved.browser.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);
-	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 };
+	}, 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);
+	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 = void 0;
+	if (typeof resolved.browser.provider === "string") {
+		const source = `@vitest/browser/providers/${resolved.browser.provider}`;
+		throw new TypeError(`The \`browser.provider\` configuration was changed to accept a factory instead of a string. Add an import of "${resolved.browser.provider}" from "${source}" instead. See: https://vitest.dev/guide/browser/config#provider`);
+	}
+	const isPreview = resolved.browser.provider?.name === "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;
 	// 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.testTransformMode ??= {};
-	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);
@@ -3931,7 +3702,7 @@ function resolveCoverageReporters(configReporters) {
 }
 function isPlaywrightChromiumOnly(vitest, config) {
 	const browser = config.browser;
-	if (!browser || browser.provider !== "playwright" || !browser.enabled) return false;
+	if (!browser || !browser.provider || browser.provider.name !== "playwright" || !browser.enabled) return false;
 	if (browser.name) return browser.name === "chromium";
 	if (!browser.instances) return false;
 	for (const instance of browser.instances) {
@@ -3948,14 +3719,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;
@@ -3966,12 +3734,12 @@ class BaseCoverageProvider {
 	coverageFiles = /* @__PURE__ */ new Map();
 	pendingPromises = [];
 	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;
+		const config = ctx._coverageOptions;
 		this.options = {
 			...coverageConfigDefaults,
 			...config,
@@ -3986,47 +3754,46 @@ 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.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) {
-		const filename = slash(_filename);
-		const cacheHit = this.globCache.get(filename);
+	isIncluded(_filename, root) {
+		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 && !filename.startsWith(this.ctx.config.root)) {
-			this.globCache.set(filename, false);
-			return false;
-		}
-		const options = {
-			contains: true,
-			dot: true,
-			cwd: this.ctx.config.root,
-			ignore: this.options.exclude
-		};
+		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 || "**";
-		const included = pm.isMatch(filename, glob, options) && existsSync(cleanUrl(filename));
-		this.globCache.set(filename, included);
-		return included;
+		let included = roots.some((root) => {
+			const options = {
+				contains: true,
+				dot: true,
+				cwd: root,
+				ignore: this.options.exclude
+			};
+			return pm.isMatch(filename, glob, options);
+		});
+		return included &&= existsSync(cleanUrl(filename)), this.globCache.set(filename, included), included;
 	}
-	async getUntestedFiles(testedFiles) {
-		if (this.options.include == null) return [];
-		let includedFiles = await glob(this.options.include, {
-			cwd: this.ctx.config.root,
+	async getUntestedFilesByRoot(testedFiles, include, root) {
+		let includedFiles = await glob(include, {
+			cwd: root,
 			ignore: [...this.options.exclude, ...testedFiles.map((file) => slash(file))],
 			absolute: true,
 			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));
-		if (this.ctx.config.changed) includedFiles = (this.ctx.config.related || []).filter((file) => includedFiles.includes(file));
-		return includedFiles.map((file) => slash(path.resolve(this.ctx.config.root, 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), matrix = await Promise.all(this.roots.map(rootMapper));
+		return matrix.flatMap((files) => files);
 	}
 	createCoverageMap() {
 		throw new Error("BaseReporter's createCoverageMap was not overwritten");
@@ -4051,56 +3818,37 @@ 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, transformMode, projectName, testFiles }) {
+	onAfterSuiteRun({ coverage, environment, projectName, testFiles }) {
 		if (!coverage) return;
-		if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") throw new Error(`Invalid transform mode: ${transformMode}`);
 		let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
-		if (!entry) {
-			entry = {
-				web: {},
-				ssr: {},
-				browser: {}
-			};
-			this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
-		}
-		const testFilenames = testFiles.join();
-		const filename = resolve$1(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
+		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[transformMode][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 = [];
-		for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
-			const filenames = Object.values(coverageByTestfiles);
-			const project = this.ctx.getProjectByName(projectName);
+		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), 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);
 				}));
 			}
-			await onFinished(project, transformMode);
+			await onFinished(project, environment);
 		}
 	}
 	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();
@@ -4113,11 +3861,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.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);
+		if (this.checkThresholds(resolvedThresholds), this.options.thresholds?.autoUpdate && allTestsRun) {
+			if (!this.ctx.vite.config.configFile) throw new Error("Missing configurationFile. The \"coverage.thresholds.autoUpdate\" can only be enabled when configuration file is used.");
+			const configFilePath = this.ctx.vite.config.configFile, configModule = await this.parseConfigModule(configFilePath);
 			await this.updateThresholds({
 				thresholds: resolvedThresholds,
 				configurationFile: configModule,
@@ -4131,16 +3877,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);
@@ -4156,7 +3896,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: {
@@ -4165,8 +3905,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.
@@ -4204,8 +3943,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;
 						/**
@@ -4229,8 +3967,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;
 				/**
@@ -4241,8 +3978,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;
@@ -4252,16 +3988,17 @@ Update your dependencies and make sure the versions match.`));
 			}
 			if (thresholdsToUpdate.length === 0) continue;
 			updatedThresholds = true;
-			for (const [threshold, newValue] of thresholdsToUpdate) if (name === GLOBAL_THRESHOLDS_KEY) config.test.coverage.thresholds[threshold] = newValue;
-			else {
-				const glob = config.test.coverage.thresholds[name];
-				glob[threshold] = newValue;
+			const thresholdFormatter = typeof this.options.thresholds?.autoUpdate === "function" ? this.options.thresholds?.autoUpdate : (value) => value;
+			for (const [threshold, newValue] of thresholdsToUpdate) {
+				const formattedValue = thresholdFormatter(newValue);
+				if (name === GLOBAL_THRESHOLDS_KEY) config.test.coverage.thresholds[threshold] = formattedValue;
+				else {
+					const glob = config.test.coverage.thresholds[name];
+					glob[threshold] = formattedValue;
+				}
 			}
 		}
-		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();
@@ -4273,10 +4010,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;
 		}, []);
@@ -4285,23 +4020,25 @@ Update your dependencies and make sure the versions match.`));
 		const servers = [...ctx.projects.map((project) => ({
 			root: project.config.root,
 			isBrowserEnabled: project.isBrowserEnabled(),
-			vitenode: project.vitenode
-		})), {
+			vite: project.vite
+		})), (
+		// Check core last as it will match all files anyway
+		{
 			root: ctx.config.root,
-			vitenode: ctx.vitenode,
+			vite: ctx.vite,
 			isBrowserEnabled: ctx.getRootProject().isBrowserEnabled()
-		}];
+		})];
 		return async function transformFile(filename) {
 			let lastError;
-			for (const { root, vitenode, isBrowserEnabled } of servers) {
+			for (const { root, vite, isBrowserEnabled } of servers) {
 				// On Windows root doesn't start with "/" while filenames do
 				if (!filename.startsWith(root) && !filename.startsWith(`/${root}`)) continue;
 				if (isBrowserEnabled) {
-					const result = await vitenode.transformRequest(filename, void 0, "web").catch(() => null);
+					const result = await vite.environments.client.transformRequest(filename).catch(() => null);
 					if (result) return result;
 				}
 				try {
-					return await vitenode.transformRequest(filename);
+					return await vite.environments.ssr.transformRequest(filename);
 				} catch (error) {
 					lastError = error;
 				}
@@ -4315,14 +4052,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,
@@ -4348,8 +4083,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
@@ -4378,4 +4112,4 @@ function resolveMergeConfig(mod) {
 	}
 }
 
-export { BaseCoverageProvider as B, RandomSequencer as R, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, isBrowserEnabled as d, groupBy as e, getCoverageProvider as f, getFilePoolName as g, hash as h, isPackageExists as i, createPool as j, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };
+export { BaseCoverageProvider as B, RandomSequencer as R, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, createFetchModuleFunction as d, isBrowserEnabled as e, groupBy as f, getFilePoolName as g, hash as h, isPackageExists as i, getCoverageProvider as j, createPool as k, normalizeResolvedIdToUrl as n, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };