vitest 4.0.0-beta.8 → 4.0.0

package/dist/chunks/{cli-api.C-JHgQgp.js → cli-api.PwHwIMss.js}

@@ -1,18 +1,19 @@
-import fs, { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { relative, resolve, dirname, extname, normalize, join, basename, isAbsolute } from 'pathe';
+import fs, { promises as promises$1, existsSync, mkdirSync, readFileSync, statSync, readdirSync, writeFileSync } from 'node:fs';
+import { relative, resolve, dirname, join, extname, normalize, basename, isAbsolute } from 'pathe';
 import { C as CoverageProviderMap } from './coverage.D_JHT54q.js';
 import path, { resolve as resolve$1 } from 'node:path';
-import { noop, createDefer, slash, highlight, toArray, cleanUrl, deepMerge, KNOWN_ASSET_RE, nanoid, deepClone, isPrimitive, notNullish } from '@vitest/utils';
-import { f as findUp, p as prompt } from './index.X0nbfr6-.js';
+import { noop, createDefer, slash, isExternalUrl, unwrapId, nanoid, withTrailingSlash, cleanUrl, wrapId, toArray, deepMerge, deepClone, isPrimitive, notNullish } from '@vitest/utils/helpers';
+import { a as any, p as prompt } from './index.Dc3xnDvT.js';
 import * as vite from 'vite';
-import { parseAst, searchForWorkspaceRoot, version, mergeConfig, createServer } from 'vite';
+import { parseAst, fetchModule, version, searchForWorkspaceRoot, mergeConfig, createServer } from 'vite';
 import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.D_Q9UYh-.js';
+import * as nodeos from 'node:os';
 import nodeos__default, { tmpdir } from 'node:os';
-import { generateHash as generateHash$1, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
+import { generateHash as generateHash$1, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, hasFailed, generateFileHash, limitConcurrency, createFileTask as createFileTask$1, getTasks, isTestCase } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { v as version$1 } from './cac.By1HvRIk.js';
+import { v as version$1 } from './cac.B99MQg-w.js';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.AzwzFtyi.js';
+import { p as parse, d as stringify, e as TraceMap, o as originalPositionFor, h as ancestor, i as printError, f as formatProjectName, w as withLabel, j as errorBanner, k as divider, l as Typechecker, m as generateCodeFrame, n as createDefinesScript, R as ReportersMap, B as BlobReporter, r as readBlobs, q as convertTasksToEvents, H as HangingProcessReporter } from './index.CcRZ6fUh.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -25,29 +26,35 @@ import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import crypto, { createHash } from 'node:crypto';
-import { distDir, rootDir } from '../path.js';
-import { h as hash, d as createFetchModuleFunction, n as normalizeResolvedIdToUrl, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, e as isBrowserEnabled, r as resolveConfig, f as groupBy, j as getCoverageProvider, k as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.DarITf6U.js';
-import { b as ancestor, c as convertTasksToEvents } from './typechecker.DSo_maXz.js';
-import { TraceMap, originalPositionFor, parseErrorStacktrace } from '@vitest/utils/source-map';
+import { rootDir, distDir } from '../path.js';
 import createDebug from 'debug';
+import { h as hash, R as RandomSequencer, i as isPackageExists, c as isBrowserEnabled, r as resolveConfig, g as getCoverageProvider, a as resolveApiServerConfig } from './coverage.FU3w4IrQ.js';
+import { readFile, writeFile, rename, stat, unlink, rm, mkdir, copyFile } from 'node:fs/promises';
 import { VitestModuleEvaluator } from '#module-evaluator';
 import { ModuleRunner } from 'vite/module-runner';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
+import { highlight } from '@vitest/utils/highlight';
 import { createRequire, builtinModules, isBuiltin } from 'node:module';
-import url, { pathToFileURL } from 'node:url';
+import url, { fileURLToPath, pathToFileURL } from 'node:url';
 import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
-import { rm, mkdir, copyFile } from 'node:fs/promises';
+import { isatty } from 'node:tty';
+import EventEmitter$1, { EventEmitter } from 'node:events';
+import { fork } from 'node:child_process';
+import v8 from 'node:v8';
+import { Worker } from 'node:worker_threads';
 import pm from 'picomatch';
 import { glob, isDynamicPattern } from 'tinyglobby';
 import MagicString from 'magic-string';
 import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
-import { c as configDefaults } from './defaults.CXFFjsi8.js';
-import { f as findNearestPackageData } from './resolver.Bx6lE0iq.js';
+import { c as configDefaults } from './defaults.BOqNVLsY.js';
+import { KNOWN_ASSET_RE } from '@vitest/utils/constants';
+import { findNearestPackageData } from '@vitest/utils/resolver';
 import * as esModuleLexer from 'es-module-lexer';
-import { a as BenchmarkReportsMap } from './index.BuwjkI-q.js';
+import { a as BenchmarkReportsMap } from './index.BdSLhLDZ.js';
 import assert$1 from 'node:assert';
-import { serializeError as serializeError$1 } from '@vitest/utils/error';
+import { serializeValue } from '@vitest/utils/serialize';
+import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import readline from 'node:readline';
 import { stripVTControlCharacters } from 'node:util';
 
@@ -5020,7 +5027,7 @@ var WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServerExport
 async function getModuleGraph(ctx, projectName, id, browser = false) {
 	const graph = {}, externalized = /* @__PURE__ */ new Set(), inlined = /* @__PURE__ */ new Set(), project = ctx.getProjectByName(projectName);
 	async function get(mod, seen = /* @__PURE__ */ new Map()) {
-		if (!mod || !mod.id || mod.id === "\0@vitest/browser/context") return;
+		if (!mod || !mod.id || mod.id === "\0vitest/browser") return;
 		if (seen.has(mod)) return seen.get(mod);
 		let id = clearId(mod.id);
 		seen.set(mod, id);
@@ -5081,8 +5088,8 @@ catch {}
 }
 
 function setup(ctx, _server) {
-	const wss = new WebSocketServer({ noServer: true }), clients = /* @__PURE__ */ new Map(), server = _server || ctx.vite;
-	server.httpServer?.on("upgrade", (request, socket, head) => {
+	const wss = new WebSocketServer({ noServer: true }), clients = /* @__PURE__ */ new Map();
+	(_server || ctx.vite).httpServer?.on("upgrade", (request, socket, head) => {
 		if (!request.url) return;
 		const { pathname } = new URL(request.url, "http://localhost");
 		if (pathname === API_PATH) {
@@ -5107,11 +5114,11 @@ function setup(ctx, _server) {
 				return ctx.state.getPaths();
 			},
 			async readTestFile(id) {
-				return !ctx.state.filesMap.has(id) || !existsSync(id) ? null : promises.readFile(id, "utf-8");
+				return !ctx.state.filesMap.has(id) || !existsSync(id) ? null : promises$1.readFile(id, "utf-8");
 			},
 			async saveTestFile(id, content) {
 				if (!ctx.state.filesMap.has(id) || !existsSync(id)) throw new Error(`Test file "${id}" was not registered, so it cannot be updated using the API.`);
-				return promises.writeFile(id, content, "utf-8");
+				return promises$1.writeFile(id, content, "utf-8");
 			},
 			async rerun(files, resetTestNamePattern) {
 				await ctx.rerunFiles(files, void 0, true, resetTestNamePattern);
@@ -5132,7 +5139,7 @@ function setup(ctx, _server) {
 				const project = ctx.getProjectByName(projectName), result = browser ? await project.browser.vite.transformRequest(id) : await project.vite.transformRequest(id);
 				if (result) {
 					try {
-						result.source = result.source || await promises.readFile(id, "utf-8");
+						result.source = result.source || await promises$1.readFile(id, "utf-8");
 					} catch {}
 					return result;
 				}
@@ -5148,8 +5155,7 @@ function setup(ctx, _server) {
 				return ctx.state.getUnhandledErrors();
 			},
 			async getTestFiles() {
-				const spec = await ctx.globTestSpecifications();
-				return spec.map((spec) => [
+				return (await ctx.globTestSpecifications()).map((spec) => [
 					{
 						name: spec.project.config.name,
 						root: spec.project.config.root
@@ -5229,16 +5235,39 @@ var setup$1 = /*#__PURE__*/Object.freeze({
   setup: setup
 });
 
+function groupBy(collection, iteratee) {
+	return collection.reduce((acc, item) => {
+		const key = iteratee(item);
+		return acc[key] ||= [], acc[key].push(item), acc;
+	}, {});
+}
+function stdout() {
+	// @ts-expect-error Node.js maps process.stdout to console._stdout
+	// eslint-disable-next-line no-console
+	return console._stdout || process.stdout;
+}
+function escapeRegExp(s) {
+	// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function wildcardPatternToRegExp(pattern) {
+	const negated = pattern[0] === "!";
+	if (negated) pattern = pattern.slice(1);
+	let regexp = `${pattern.split("*").map(escapeRegExp).join(".*")}$`;
+	if (negated) regexp = `(?!${regexp})`;
+	return new RegExp(`^${regexp}`, "i");
+}
+
 function createDebugger(namespace) {
 	const debug = createDebug(namespace);
 	if (debug.enabled) return debug;
 }
 
-const debug = createDebugger("vitest:ast-collect-info"), verbose = createDebugger("vitest:ast-collect-verbose");
+const debug$1 = createDebugger("vitest:ast-collect-info"), verbose = createDebugger("vitest:ast-collect-verbose");
 function astParseFile(filepath, code) {
 	const ast = parseAst(code);
 	if (verbose) verbose("Collecting", filepath, code);
-	else debug?.("Collecting", filepath);
+	else debug$1?.("Collecting", filepath);
 	const definitions = [], getName = (callee) => {
 		if (!callee) return null;
 		if (callee.type === "Identifier") return callee.name;
@@ -5302,7 +5331,7 @@ function astParseFile(filepath, code) {
 			const property = callee.tag?.property?.name;
 			isDynamicEach = property === "each" || property === "for";
 		}
-		debug?.("Found", name, message, `(${mode})`), definitions.push({
+		debug$1?.("Found", name, message, `(${mode})`), definitions.push({
 			start,
 			end,
 			name: message,
@@ -5338,17 +5367,13 @@ function createFailedFileTask(project, filepath, error) {
 	return file.file = file, file;
 }
 function serializeError(ctx, error) {
-	if ("errors" in error && "pluginCode" in error) {
-		const errors = error.errors.map((e) => {
-			return {
-				name: error.name,
-				message: e.text,
-				stack: e.location ? `${error.name}: ${e.text}\n  at ${relative(ctx.config.root, e.location.file)}:${e.location.line}:${e.location.column}` : ""
-			};
-		});
-		return errors;
-	}
-	return [{
+	return "errors" in error && "pluginCode" in error ? error.errors.map((e) => {
+		return {
+			name: error.name,
+			message: e.text,
+			stack: e.location ? `${error.name}: ${e.text}\n  at ${relative(ctx.config.root, e.location.file)}:${e.location.line}:${e.location.column}` : ""
+		};
+	}) : [{
 		name: error.name,
 		stack: error.stack,
 		message: error.message
@@ -5390,8 +5415,8 @@ function createFileTask(testFilepath, code, requestMap, options) {
 				column: processedLocation.column
 			});
 			if (originalLocation.column != null) verbose?.(`Found location for`, definition.type, definition.name, `${processedLocation.line}:${processedLocation.column}`, "->", `${originalLocation.line}:${originalLocation.column}`), location = originalLocation;
-			else debug?.("Cannot find original location for", definition.type, definition.name, `${processedLocation.column}:${processedLocation.line}`);
-		} else debug?.("Cannot find original location for", definition.type, definition.name, `${definition.start}`);
+			else debug$1?.("Cannot find original location for", definition.type, definition.name, `${processedLocation.column}:${processedLocation.line}`);
+		} else debug$1?.("Cannot find original location for", definition.type, definition.name, `${definition.start}`);
 		if (definition.type === "suite") {
 			const task = {
 				type: definition.type,
@@ -5446,7 +5471,7 @@ async function astCollectTests(project, filepath) {
 		allowOnly: project.config.allowOnly,
 		testNamePattern: project.config.testNamePattern,
 		pool: project.browser ? "browser" : project.config.pool
-	}) : (debug?.("Cannot parse", testFilepath, "(vite didn't return anything)"), createFailedFileTask(project, filepath, /* @__PURE__ */ new Error(`Failed to parse ${testFilepath}. Vite didn't return anything.`)));
+	}) : (debug$1?.("Cannot parse", testFilepath, "(vite didn't return anything)"), createFailedFileTask(project, filepath, /* @__PURE__ */ new Error(`Failed to parse ${testFilepath}. Vite didn't return anything.`)));
 }
 async function transformSSR(project, filepath) {
 	const request = await project.vite.transformRequest(filepath, { ssr: false });
@@ -5611,18 +5636,197 @@ class VitestCache {
 	}
 }
 
+const created = /* @__PURE__ */ new Set(), promises = /* @__PURE__ */ new Map();
+function createFetchModuleFunction(resolver, tmpDir = join(tmpdir(), nanoid()), dump) {
+	return async (url, importer, environment, cacheFs, 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"
+			};
+		}
+		let moduleRunnerModule;
+		if (dump?.dumpFolder && dump.readFromDump) {
+			const path = resolve(dump?.dumpFolder, url.replace(/[^\w+]/g, "-"));
+			if (existsSync(path)) {
+				const code = await readFile(path, "utf-8"), matchIndex = code.lastIndexOf("\n//");
+				if (matchIndex !== -1) {
+					const { id, file } = JSON.parse(code.slice(matchIndex + 4));
+					moduleRunnerModule = {
+						code,
+						id,
+						url,
+						file,
+						invalidate: false
+					};
+				}
+			}
+		}
+		if (!moduleRunnerModule) moduleRunnerModule = await fetchModule(environment, url, importer, {
+			...options,
+			inlineSourceMap: false
+		}).catch(handleRollupError);
+		const result = processResultSource(environment, moduleRunnerModule);
+		if (dump?.dumpFolder && "code" in result) {
+			const path = resolve(dump?.dumpFolder, result.url.replace(/[^\w+]/g, "-"));
+			await writeFile(path, `${result.code}\n// ${JSON.stringify({
+				id: result.id,
+				file: result.file
+			})}`, "utf-8");
+		}
+		if (!cacheFs || !("code" in result)) return result;
+		const code = result.code, transformResult = result.transformResult;
+		if (!transformResult) throw new Error(`"transformResult" in not defined. This is a bug in Vitest.`);
+		// to avoid serialising large chunks of code,
+		// we store them in a tmp file and read in the test thread
+		if ("_vitestTmp" in transformResult) return getCachedResult(result, Reflect.get(transformResult, "_vitestTmp"));
+		const dir = join(tmpDir, environment.name), name = hash("sha1", result.id, "hex"), tmp = join(dir, name);
+		if (!created.has(dir)) mkdirSync(dir, { recursive: true }), created.add(dir);
+		return promises.has(tmp) ? (await promises.get(tmp), Reflect.set(transformResult, "_vitestTmp", tmp), getCachedResult(result, tmp)) : (promises.set(tmp, atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp))), await promises.get(tmp), getCachedResult(result, tmp));
+	};
+}
+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,
+		transformResult: node?.transformResult
+	};
+}
+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[0] === ";") 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, tmp) {
+	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(realFilePath), tmpFilePath = join(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(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;
+}
+
 class ServerModuleRunner extends ModuleRunner {
-	constructor(environment, resolver, config) {
-		const fetchModule = createFetchModuleFunction(resolver, false);
+	constructor(environment, fetcher, config) {
 		super({
 			hmr: false,
-			sourcemapInterceptor: "node",
 			transport: { async invoke(event) {
 				if (event.type !== "custom") throw new Error(`Vitest Module Runner doesn't support Vite HMR events.`);
 				const { data } = event.data;
 				try {
-					const result = await fetchModule(data[0], data[1], environment, data[2]);
-					return { result };
+					return { result: await fetcher(data[0], data[1], environment, false, data[2]) };
 				} catch (error) {
 					return { error };
 				}
@@ -5761,8 +5965,8 @@ class Logger {
 		const projectsFilter = toArray(config.project);
 		if (projectsFilter.length) this.console.error(c.dim("projects: ") + c.yellow(projectsFilter.join(comma)));
 		this.ctx.projects.forEach((project) => {
-			const config = project.config, printConfig = !project.isRootProject() && project.name;
-			if (printConfig) this.console.error(`\n${formatProjectName(project)}\n`);
+			const config = project.config;
+			if (!project.isRootProject() && project.name) this.console.error(`\n${formatProjectName(project)}\n`);
 			if (config.include) this.console.error(c.dim("include: ") + c.yellow(config.include.join(comma)));
 			if (config.exclude) this.console.error(c.dim("exclude:  ") + c.yellow(config.exclude.join(comma)));
 			if (config.typecheck.enabled) this.console.error(c.dim("typecheck include: ") + c.yellow(config.typecheck.include.join(comma))), this.console.error(c.dim("typecheck exclude: ") + c.yellow(config.typecheck.exclude.join(comma)));
@@ -5787,7 +5991,7 @@ class Logger {
 		if (!project.browser) return;
 		const resolvedUrls = project.browser.vite.resolvedUrls, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
 		if (!origin) return;
-		const output = project.isRootProject() ? "" : formatProjectName(project), provider = project.browser.provider.name, providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
+		const output = project.isRootProject() ? "" : formatProjectName(project), provider = project.browser.provider?.name, providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
 		this.log(c.dim(`${output}Browser runner started${providerString} ${c.dim("at")} ${c.blue(new URL("/__vitest_test__/", origin))}\n`));
 	}
 	printUnhandledErrors(errors) {
@@ -5819,7 +6023,8 @@ This might cause false positive tests. Resolve unhandled errors to make sure you
 			// Interrupted signals don't set exit code automatically.
 			// Use same exit code as node: https://nodejs.org/api/process.html#signal-events
 			if (cleanup(), process.exitCode === void 0) process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
-			process.exit();
+			// Timeout to flush stderr
+			setTimeout(() => process.exit(), 1);
 		};
 		process.once("SIGINT", onExit), process.once("SIGTERM", onExit), process.once("exit", onExit), this.ctx.onClose(() => {
 			process.off("SIGINT", onExit), process.off("SIGTERM", onExit), process.off("exit", onExit), cleanup();
@@ -5853,7 +6058,7 @@ class VitestPackageInstaller {
 		}
 		if (/* @__PURE__ */ isPackageExists(dependency, { paths: [root, __dirname] })) return true;
 		if (process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEPENDENCY "))} Cannot find dependency '${dependency}'\n\n`)), !isTTY) return false;
-		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; }), { install } = await prompts.default({
+		const { install } = await (await import('./index.Dc3xnDvT.js').then(function (n) { return n.i; })).default({
 			type: "confirm",
 			name: "install",
 			message: c.reset(`Do you want to install ${c.green(dependency)}?`)
@@ -5866,12 +6071,1057 @@ class VitestPackageInstaller {
 	}
 }
 
-function serializeConfig(config, coreConfig, viteConfig) {
-	const optimizer = config.deps?.optimizer || {}, poolOptions = config.poolOptions, isolate = viteConfig?.test?.isolate;
+function getDefaultThreadsCount(config) {
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
+	return config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+}
+function getWorkerMemoryLimit(config) {
+	return config.vmMemoryLimit ? config.vmMemoryLimit : 1 / (config.maxWorkers ?? getDefaultThreadsCount(config));
+}
+/**
+* Converts a string representing an amount of memory to bytes.
+*
+* @param input The value to convert to bytes.
+* @param percentageReference The reference value to use when a '%' value is supplied.
+*/
+function stringToBytes(input, percentageReference) {
+	if (input === null || input === void 0) return input;
+	if (typeof input === "string") if (Number.isNaN(Number.parseFloat(input.slice(-1)))) {
+		let [, numericString, trailingChars] = input.match(/(.*?)([^0-9.-]+)$/) || [];
+		if (trailingChars && numericString) {
+			const numericValue = Number.parseFloat(numericString);
+			switch (trailingChars = trailingChars.toLowerCase(), trailingChars) {
+				case "%":
+					input = numericValue / 100;
+					break;
+				case "kb":
+				case "k": return numericValue * 1e3;
+				case "kib": return numericValue * 1024;
+				case "mb":
+				case "m": return numericValue * 1e3 * 1e3;
+				case "mib": return numericValue * 1024 * 1024;
+				case "gb":
+				case "g": return numericValue * 1e3 * 1e3 * 1e3;
+				case "gib": return numericValue * 1024 * 1024 * 1024;
+			}
+		}
+	} else input = Number.parseFloat(input);
+	if (typeof input === "number") if (input <= 1 && input > 0) {
+		if (percentageReference) return Math.floor(input * percentageReference);
+		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;
+}
+
+async function getSpecificationsEnvironments(specifications) {
+	const environments = /* @__PURE__ */ new WeakMap(), cache = /* @__PURE__ */ new Map();
+	return await Promise.all(specifications.map(async (spec) => {
+		const { moduleId: filepath, project } = spec;
+		// reuse if projects have the same test files
+		let code = cache.get(filepath);
+		if (!code) code = await promises$1.readFile(filepath, "utf-8"), cache.set(filepath, code);
+		// 1. Check for control comments in the file
+		let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
+		// 2. Fallback to global env
+		env ||= project.config.environment || "node";
+		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"), environment = {
+			name: env,
+			options: envOptions ? { [env === "happy-dom" ? "happyDOM" : env]: envOptions } : null
+		};
+		environments.set(spec, environment);
+	})), environments;
+}
+
+const debug = createDebugger("vitest:browser:pool");
+function createBrowserPool(vitest) {
+	const providers = /* @__PURE__ */ new Set(), numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, maxThreadsCount = Math.min(12, numCpus - 1), threadsCount = vitest.config.watch ? Math.max(Math.floor(maxThreadsCount / 2), 1) : Math.max(maxThreadsCount, 1), projectPools = /* @__PURE__ */ new WeakMap(), ensurePool = (project) => {
+		if (projectPools.has(project)) return projectPools.get(project);
+		debug?.("creating pool for project %s", project.name);
+		const resolvedUrls = project.browser.vite.resolvedUrls, origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
+		if (!origin) throw new Error(`Can't find browser origin URL for project "${project.name}"`);
+		const pool = new BrowserPool(project, {
+			maxWorkers: getThreadsCount(project),
+			origin
+		});
+		return projectPools.set(project, pool), vitest.onCancel(() => {
+			pool.cancel();
+		}), pool;
+	}, runWorkspaceTests = async (method, specs) => {
+		const groupedFiles = /* @__PURE__ */ new Map();
+		for (const { project, moduleId, testLines } of specs) {
+			const files = groupedFiles.get(project) || [];
+			files.push({
+				filepath: moduleId,
+				testLocations: testLines
+			}), groupedFiles.set(project, files);
+		}
+		let isCancelled = false;
+		vitest.onCancel(() => {
+			isCancelled = true;
+		});
+		const initialisedPools = await Promise.all([...groupedFiles.entries()].map(async ([project, files]) => {
+			if (await project._initBrowserProvider(), !project.browser) throw new TypeError(`The browser server was not initialized${project.name ? ` for the "${project.name}" project` : ""}. This is a bug in Vitest. Please, open a new issue with reproduction.`);
+			if (isCancelled) return;
+			debug?.("provider is ready for %s project", project.name);
+			const pool = ensurePool(project);
+			return vitest.state.clearFiles(project, files.map((f) => f.filepath)), providers.add(project.browser.provider), {
+				pool,
+				provider: project.browser.provider,
+				runTests: () => pool.runTests(method, files)
+			};
+		}));
+		if (isCancelled) return;
+		const parallelPools = [], nonParallelPools = [];
+		for (const pool of initialisedPools) {
+			if (!pool)
+ // this means it was cancelled
+			return;
+			if (pool.provider.mocker && pool.provider.supportsParallelism) parallelPools.push(pool.runTests);
+			else nonParallelPools.push(pool.runTests);
+		}
+		await Promise.all(parallelPools.map((runTests) => runTests()));
+		for (const runTests of nonParallelPools) {
+			if (isCancelled) return;
+			await runTests();
+		}
+	};
+	function getThreadsCount(project) {
+		const config = project.config.browser;
+		return !config.headless || !config.fileParallelism || !project.browser.provider.supportsParallelism ? 1 : project.config.maxWorkers ? project.config.maxWorkers : threadsCount;
+	}
+	return {
+		name: "browser",
+		async close() {
+			await Promise.all([...providers].map((provider) => provider.close())), vitest._browserSessions.sessionIds.clear(), providers.clear(), vitest.projects.forEach((project) => {
+				project.browser?.state.orchestrators.forEach((orchestrator) => {
+					orchestrator.$close();
+				});
+			}), debug?.("browser pool closed all providers");
+		},
+		runTests: (files) => runWorkspaceTests("run", files),
+		collectTests: (files) => runWorkspaceTests("collect", files)
+	};
+}
+function escapePathToRegexp(path) {
+	return path.replace(/[/\\.?*()^${}|[\]+]/g, "\\$&");
+}
+class BrowserPool {
+	_queue = [];
+	_promise;
+	_providedContext;
+	readySessions = /* @__PURE__ */ new Set();
+	constructor(project, options) {
+		this.project = project, this.options = options;
+	}
+	cancel() {
+		this._queue = [];
+	}
+	reject(error) {
+		this._promise?.reject(error), this._promise = void 0, this.cancel();
+	}
+	get orchestrators() {
+		return this.project.browser.state.orchestrators;
+	}
+	async runTests(method, files) {
+		if (this._promise ??= createDefer(), !files.length) return debug?.("no tests found, finishing test run immediately"), this._promise.resolve(), this._promise;
+		if (this._providedContext = stringify(this.project.getProvidedContext()), this._queue.push(...files), this.readySessions.forEach((sessionId) => {
+			if (this._queue.length) this.readySessions.delete(sessionId), this.runNextTest(method, sessionId);
+		}), this.orchestrators.size >= this.options.maxWorkers) return debug?.("all orchestrators are ready, not creating more"), this._promise;
+		// open the minimum amount of tabs
+		// if there is only 1 file running, we don't need 8 tabs running
+		const workerCount = Math.min(this.options.maxWorkers - this.orchestrators.size, files.length), promises = [];
+		for (let i = 0; i < workerCount; i++) {
+			const sessionId = crypto.randomUUID();
+			this.project.vitest._browserSessions.sessionIds.add(sessionId);
+			const project = this.project.name;
+			debug?.("[%s] creating session for %s", sessionId, project);
+			const page = this.openPage(sessionId).then(() => {
+				// start running tests on the page when it's ready
+				this.runNextTest(method, sessionId);
+			});
+			promises.push(page);
+		}
+		return await Promise.all(promises), debug?.("all sessions are created"), this._promise;
+	}
+	async openPage(sessionId) {
+		const sessionPromise = this.project.vitest._browserSessions.createSession(sessionId, this.project, this), browser = this.project.browser, url = new URL("/__vitest_test__/", this.options.origin);
+		url.searchParams.set("sessionId", sessionId);
+		const pagePromise = browser.provider.openPage(sessionId, url.toString());
+		await Promise.all([sessionPromise, pagePromise]);
+	}
+	getOrchestrator(sessionId) {
+		const orchestrator = this.orchestrators.get(sessionId);
+		if (!orchestrator) throw new Error(`Orchestrator not found for session ${sessionId}. This is a bug in Vitest. Please, open a new issue with reproduction.`);
+		return orchestrator;
+	}
+	finishSession(sessionId) {
+		// the last worker finished running tests
+		if (this.readySessions.add(sessionId), this.readySessions.size === this.orchestrators.size) this._promise?.resolve(), this._promise = void 0, debug?.("[%s] all tests finished running", sessionId);
+		else debug?.(`did not finish sessions for ${sessionId}: |ready - %s| |overall - %s|`, [...this.readySessions].join(", "), [...this.orchestrators.keys()].join(", "));
+	}
+	runNextTest(method, sessionId) {
+		const file = this._queue.shift();
+		if (!file) {
+			// we don't need to cleanup testers if isolation is enabled,
+			// because cleanup is done at the end of every test
+			if (debug?.("[%s] no more tests to run", sessionId), this.project.config.browser.isolate) {
+				this.finishSession(sessionId);
+				return;
+			}
+			this.getOrchestrator(sessionId).cleanupTesters().catch((error) => this.reject(error)).finally(() => this.finishSession(sessionId));
+			return;
+		}
+		if (!this._promise) throw new Error(`Unexpected empty queue`);
+		const orchestrator = this.getOrchestrator(sessionId);
+		debug?.("[%s] run test %s", sessionId, file), this.setBreakpoint(sessionId, file.filepath).then(() => {
+			// this starts running tests inside the orchestrator
+			orchestrator.createTesters({
+				method,
+				files: [file],
+				providedContext: this._providedContext || "[{}]"
+			}).then(() => {
+				debug?.("[%s] test %s finished running", sessionId, file), this.runNextTest(method, sessionId);
+			}).catch((error) => {
+				// if user cancels the test run manually, ignore the error and exit gracefully
+				if (this.project.vitest.isCancelling && error instanceof Error && error.message.startsWith("Browser connection was closed while running tests")) {
+					this.cancel(), this._promise?.resolve(), this._promise = void 0, debug?.("[%s] browser connection was closed", sessionId);
+					return;
+				}
+				debug?.("[%s] error during %s test run: %s", sessionId, file, error), this.reject(error);
+			});
+		}).catch((err) => this.reject(err));
+	}
+	async setBreakpoint(sessionId, file) {
+		if (!this.project.config.inspector.waitForDebugger) return;
+		const provider = this.project.browser.provider, browser = this.project.config.browser.name;
+		if (shouldIgnoreDebugger(provider.name, browser)) {
+			debug?.("[$s] ignoring debugger in %s browser because it is not supported", sessionId, browser);
+			return;
+		}
+		if (!provider.getCDPSession) throw new Error("Unable to set breakpoint, CDP not supported");
+		debug?.("[%s] set breakpoint for %s", sessionId, file);
+		const session = await provider.getCDPSession(sessionId);
+		await session.send("Debugger.enable", {}), await session.send("Debugger.setBreakpointByUrl", {
+			lineNumber: 0,
+			urlRegex: escapePathToRegexp(file)
+		});
+	}
+}
+function shouldIgnoreDebugger(provider, browser) {
+	return provider === "webdriverio" ? browser !== "chrome" && browser !== "edge" : browser !== "chromium";
+}
+
+function createMethodsRPC(project, options = {}) {
+	const vitest = project.vitest, cacheFs = options.cacheFs ?? false;
+	if (project.vitest.state.metadata[project.name] ??= {
+		externalized: {},
+		duration: {},
+		tmps: {}
+	}, project.config.dumpDir && !existsSync(project.config.dumpDir)) mkdirSync(project.config.dumpDir, { recursive: true });
+	return project.vitest.state.metadata[project.name].dumpDir = project.config.dumpDir, {
+		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();
+			return await project._fetcher(url, importer, environment, cacheFs, options).then((result) => {
+				const duration = performance.now() - start;
+				project.vitest.state.transformTime += duration;
+				const metadata = project.vitest.state.metadata[project.name];
+				if ("externalize" in result) metadata.externalized[url] = result.externalize;
+				if ("tmp" in result) metadata.tmps[url] = result.tmp;
+				return metadata.duration[url] ??= [], metadata.duration[url].push(duration), result;
+			});
+		},
+		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) {
+			vitest.snapshot.add(snapshot);
+		},
+		resolveSnapshotPath(testPath) {
+			return vitest.snapshot.resolvePath(testPath, { config: project.serializedConfig });
+		},
+		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(id));
+			return { code: (await environment.transformRequest(url).catch(handleRollupError))?.code };
+		},
+		async onQueued(file) {
+			if (options.collect) vitest.state.collectFiles(project, [file]);
+			else await vitest._testRun.enqueued(project, file);
+		},
+		async onCollected(files) {
+			if (options.collect) vitest.state.collectFiles(project, files);
+			else await vitest._testRun.collected(project, files);
+		},
+		onAfterSuiteRun(meta) {
+			vitest.coverageProvider?.onAfterSuiteRun(meta);
+		},
+		async onTaskAnnotate(testId, annotation) {
+			return vitest._testRun.annotate(testId, annotation);
+		},
+		async onTaskUpdate(packs, events) {
+			if (options.collect) vitest.state.updateTasks(packs);
+			else await vitest._testRun.updated(packs, events);
+		},
+		async onUserConsoleLog(log) {
+			if (options.collect) vitest.state.updateUserLog(log);
+			else await vitest._testRun.log(log);
+		},
+		onUnhandledError(err, type) {
+			vitest.state.catchError(err, type);
+		},
+		onCancel(reason) {
+			vitest.cancelCurrentRun(reason);
+		},
+		getCountOfFailedTests() {
+			return vitest.state.getCountOfFailedTests();
+		}
+	};
+}
+
+var RunnerState = /* @__PURE__ */ function(RunnerState) {
+	return RunnerState["IDLE"] = "idle", RunnerState["STARTING"] = "starting", RunnerState["STARTED"] = "started", RunnerState["STOPPING"] = "stopping", RunnerState["STOPPED"] = "stopped", RunnerState;
+}(RunnerState || {});
+const START_TIMEOUT = 1e4, STOP_TIMEOUT = 1e4;
+/** @experimental */
+class PoolRunner {
+	/** Exposed to test runner as `VITEST_POOL_ID`. Value is between 1-`maxWorkers`. */
+	poolId = void 0;
+	project;
+	environment;
+	_state = RunnerState.IDLE;
+	_operationLock = null;
+	_eventEmitter = new EventEmitter();
+	_rpc;
+	get isTerminated() {
+		return this._state === RunnerState.STOPPED;
+	}
+	get isStarted() {
+		return this._state === RunnerState.STARTED;
+	}
+	constructor(options, worker) {
+		this.worker = worker, this.project = options.project, this.environment = options.environment, this._rpc = createBirpc(createMethodsRPC(this.project, {
+			collect: options.method === "collect",
+			cacheFs: worker.cacheFs
+		}), {
+			eventNames: ["onCancel"],
+			post: (request) => this.postMessage(request),
+			on: (callback) => this._eventEmitter.on("rpc", callback),
+			timeout: -1
+		}), this.project.vitest.onCancel((reason) => this._rpc.onCancel(reason));
+	}
+	postMessage(message) {
+		// Only send messages when runner is active (not fully stopped)
+		// Allow sending during STOPPING state for the 'stop' message itself
+		if (this._state !== RunnerState.STOPPED) return this.worker.send(message);
+	}
+	async start() {
+		// Wait for any ongoing operation to complete
+		if (this._operationLock) await this._operationLock;
+		if (!(this._state === RunnerState.STARTED || this._state === RunnerState.STARTING)) {
+			if (this._state === RunnerState.STOPPED) throw new Error("[vitest-pool-runner]: Cannot start a stopped runner");
+			// Create operation lock to prevent concurrent start/stop
+			this._operationLock = createDefer();
+			try {
+				this._state = RunnerState.STARTING, await this.worker.start(), this.worker.on("error", this.emitWorkerError), this.worker.on("exit", this.emitUnexpectedExit), this.worker.on("message", this.emitWorkerMessage);
+				const startPromise = this.withTimeout(this.waitForStart(), START_TIMEOUT);
+				this.postMessage({
+					type: "start",
+					__vitest_worker_request__: true,
+					options: { reportMemory: this.worker.reportMemory ?? false }
+				}), await startPromise, this._state = RunnerState.STARTED;
+			} catch (error) {
+				throw this._state = RunnerState.IDLE, error;
+			} finally {
+				this._operationLock.resolve(), this._operationLock = null;
+			}
+		}
+	}
+	async stop() {
+		// Wait for any ongoing operation to complete
+		if (this._operationLock) await this._operationLock;
+		if (!(this._state === RunnerState.STOPPED || this._state === RunnerState.STOPPING)) {
+			if (this._state === RunnerState.IDLE) {
+				this._state = RunnerState.STOPPED;
+				return;
+			}
+			// Create operation lock to prevent concurrent start/stop
+			this._operationLock = createDefer();
+			try {
+				this._state = RunnerState.STOPPING, this.worker.off("exit", this.emitUnexpectedExit), await this.withTimeout(new Promise((resolve) => {
+					const onStop = (response) => {
+						if (response.type === "stopped") {
+							if (response.error) this.project.vitest.state.catchError(response.error, "Teardown Error");
+							resolve(), this.off("message", onStop);
+						}
+					};
+					this.on("message", onStop), this.postMessage({
+						type: "stop",
+						__vitest_worker_request__: true
+					});
+				}), STOP_TIMEOUT), this._eventEmitter.removeAllListeners(), this._rpc.$close(/* @__PURE__ */ new Error("[vitest-pool-runner]: Pending methods while closing rpc")), await this.worker.stop(), this._state = RunnerState.STOPPED;
+			} catch (error) {
+				throw this._state = RunnerState.STOPPED, error;
+			} finally {
+				this._operationLock.resolve(), this._operationLock = null;
+			}
+		}
+	}
+	on(event, callback) {
+		this._eventEmitter.on(event, callback);
+	}
+	off(event, callback) {
+		this._eventEmitter.off(event, callback);
+	}
+	emitWorkerError = (maybeError) => {
+		const error = maybeError instanceof Error ? maybeError : new Error(String(maybeError));
+		this._eventEmitter.emit("error", error);
+	};
+	emitWorkerMessage = (response) => {
+		try {
+			const message = this.worker.deserialize(response);
+			if (typeof message === "object" && message != null && message.__vitest_worker_response__) this._eventEmitter.emit("message", message);
+			else this._eventEmitter.emit("rpc", message);
+		} catch (error) {
+			this._eventEmitter.emit("error", error);
+		}
+	};
+	emitUnexpectedExit = () => {
+		const error = /* @__PURE__ */ new Error("Worker exited unexpectedly");
+		this._eventEmitter.emit("error", error);
+	};
+	waitForStart() {
+		return new Promise((resolve) => {
+			const onStart = (message) => {
+				if (message.type === "started") this.off("message", onStart), resolve();
+			};
+			this.on("message", onStart);
+		});
+	}
+	withTimeout(promise, timeout) {
+		return new Promise((resolve_, reject_) => {
+			const timer = setTimeout(() => reject(/* @__PURE__ */ new Error("[vitest-pool-runner]: Timeout waiting for worker to respond")), timeout);
+			function resolve(value) {
+				clearTimeout(timer), resolve_(value);
+			}
+			function reject(error) {
+				clearTimeout(timer), reject_(error);
+			}
+			promise.then(resolve, reject);
+		});
+	}
+}
+
+const SIGKILL_TIMEOUT = 500;
+/** @experimental */
+class ForksPoolWorker {
+	name = "forks";
+	cacheFs = true;
+	entrypoint;
+	execArgv;
+	env;
+	_fork;
+	constructor(options) {
+		/** Loads {@link file://./../../../runtime/workers/forks.ts} */
+		this.execArgv = options.execArgv, this.env = options.env, this.entrypoint = resolve$1(options.distPath, "workers/forks.js");
+	}
+	on(event, callback) {
+		this.fork.on(event, callback);
+	}
+	off(event, callback) {
+		this.fork.off(event, callback);
+	}
+	send(message) {
+		if ("context" in message) message = {
+			...message,
+			context: {
+				...message.context,
+				config: wrapSerializableConfig(message.context.config)
+			}
+		};
+		this.fork.send(v8.serialize(message));
+	}
+	async start() {
+		this._fork ||= fork(this.entrypoint, [], {
+			env: this.env,
+			execArgv: this.execArgv
+		});
+	}
+	async stop() {
+		const fork = this.fork, waitForExit = new Promise((resolve) => {
+			if (fork.exitCode != null) resolve();
+			else fork.once("exit", resolve);
+		}), sigkillTimeout = setTimeout(() => fork.kill("SIGKILL"), SIGKILL_TIMEOUT);
+		fork.kill(), await waitForExit, clearTimeout(sigkillTimeout), this._fork = void 0;
+	}
+	deserialize(data) {
+		try {
+			return v8.deserialize(Buffer.from(data));
+		} catch (error) {
+			let stringified = "";
+			try {
+				stringified = `\nReceived value: ${JSON.stringify(data)}`;
+			} catch {}
+			throw new Error(`[vitest-pool]: Unexpected call to process.send(). Make sure your test cases are not interfering with process's channel.${stringified}`, { cause: error });
+		}
+	}
+	get fork() {
+		if (!this._fork) throw new Error(`The child process was torn down or never initialized. This is a bug in Vitest.`);
+		return this._fork;
+	}
+}
+/**
+* Prepares `SerializedConfig` for serialization, e.g. `node:v8.serialize`
+* - Unwrapping done in {@link file://./../../../runtime/workers/init-forks.ts}
+*/
+function wrapSerializableConfig(config) {
+	let testNamePattern = config.testNamePattern, defines = config.defines;
+	// v8 serialize does not support regex
+	if (testNamePattern && typeof testNamePattern !== "string") testNamePattern = `$$vitest:${testNamePattern.toString()}`;
+	// v8 serialize drops properties with undefined value
+	if (defines) defines = {
+		keys: Object.keys(defines),
+		original: defines
+	};
+	return {
+		...config,
+		testNamePattern,
+		defines
+	};
+}
+
+/** @experimental */
+class ThreadsPoolWorker {
+	name = "threads";
+	entrypoint;
+	execArgv;
+	env;
+	_thread;
+	constructor(options) {
+		/** Loads {@link file://./../../../runtime/workers/threads.ts} */
+		this.execArgv = options.execArgv, this.env = options.env, this.entrypoint = resolve$1(options.distPath, "workers/threads.js");
+	}
+	on(event, callback) {
+		this.thread.on(event, callback);
+	}
+	off(event, callback) {
+		this.thread.off(event, callback);
+	}
+	send(message) {
+		this.thread.postMessage(message);
+	}
+	async start() {
+		// This can be called multiple times if the runtime is shared.
+		this._thread ||= new Worker(this.entrypoint, {
+			env: this.env,
+			execArgv: this.execArgv
+		});
+	}
+	async stop() {
+		await this.thread.terminate().then(() => {
+			this._thread = void 0;
+		});
+	}
+	deserialize(data) {
+		return data;
+	}
+	get thread() {
+		if (!this._thread) throw new Error(`The worker thread was torn down or never initialized. This is a bug in Vitest.`);
+		return this._thread;
+	}
+}
+
+/** @experimental */
+class TypecheckPoolWorker {
+	name = "typecheck";
+	project;
+	_eventEmitter = new EventEmitter$1();
+	constructor(options) {
+		this.project = options.project;
+	}
+	async start() {
+		// noop, onMessage handles it
+	}
+	async stop() {
+		// noop, onMessage handles it
+	}
+	canReuse() {
+		return true;
+	}
+	send(message) {
+		onMessage(message, this.project).then((response) => {
+			if (response) this._eventEmitter.emit("message", response);
+		});
+	}
+	on(event, callback) {
+		this._eventEmitter.on(event, callback);
+	}
+	off(event, callback) {
+		this._eventEmitter.on(event, callback);
+	}
+	deserialize(data) {
+		return data;
+	}
+}
+const __vitest_worker_response__ = true, runners = /* @__PURE__ */ new WeakMap();
+async function onMessage(message, project) {
+	if (message?.__vitest_worker_request__ !== true) return;
+	let runner = runners.get(project.vitest);
+	if (!runner) runner = createRunner(project.vitest), runners.set(project.vitest, runner);
+	let runPromise;
+	switch (message.type) {
+		case "start": return {
+			type: "started",
+			__vitest_worker_response__
+		};
+		case "run": return runPromise = runner.runTests(message.context.files, project).catch((error) => error), {
+			type: "testfileFinished",
+			error: await runPromise,
+			__vitest_worker_response__
+		};
+		case "collect": return runPromise = runner.collectTests(message.context.files, project).catch((error) => error), {
+			type: "testfileFinished",
+			error: await runPromise,
+			__vitest_worker_response__
+		};
+		case "stop": return await runPromise, await project.typechecker?.stop(), {
+			type: "stopped",
+			__vitest_worker_response__
+		};
+	}
+	throw new Error(`Unexpected message ${JSON.stringify(message, null, 2)}`);
+}
+function createRunner(vitest) {
+	const promisesMap = /* @__PURE__ */ new WeakMap(), rerunTriggered = /* @__PURE__ */ new WeakSet();
+	async function onParseEnd(project, { files, sourceErrors }) {
+		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"));
+		if (!hasFailed(files) && !sourceErrors.length && checker.getExitCode()) {
+			const error = new Error(checker.getOutput());
+			error.stack = "", vitest.state.catchError(error, "Typecheck Error");
+		}
+		// triggered by TSC watcher, not Vitest watcher, so we need to emulate what Vitest does in this case
+		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);
+		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 () => {
+			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);
+		}), checker);
+	}
+	async function startTypechecker(project, files) {
+		if (project.typechecker) return;
+		const checker = await createWorkspaceTypechecker(project, files);
+		await checker.collectTests(), await checker.start();
+	}
+	async function collectTests(specs, project) {
+		const files = specs.map((spec) => spec.filepath), checker = await createWorkspaceTypechecker(project, files);
+		checker.setFiles(files), await checker.collectTests();
+		const testFiles = checker.getTestFiles();
+		vitest.state.collectFiles(project, testFiles);
+	}
+	async function runTests(specs, project) {
+		const promises = [], files = specs.map((spec) => spec.filepath), promise = createDefer(), triggered = await new Promise((resolve) => {
+			const _i = setInterval(() => {
+				if (!project.typechecker || rerunTriggered.has(project)) resolve(true), clearInterval(_i);
+			});
+			setTimeout(() => {
+				resolve(false), clearInterval(_i);
+			}, 500).unref();
+		});
+		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());
+		}
+		promises.push(promise), promisesMap.set(project, promise), promises.push(startTypechecker(project, files)), await Promise.all(promises);
+	}
+	return {
+		runTests,
+		collectTests
+	};
+}
+
+/** @experimental */
+class VmForksPoolWorker extends ForksPoolWorker {
+	name = "vmForks";
+	reportMemory = true;
+	entrypoint;
+	constructor(options) {
+		/** Loads {@link file://./../../../runtime/workers/vmForks.ts} */
+		super(options), this.execArgv.push("--experimental-vm-modules"), this.entrypoint = resolve$1(options.distPath, "workers/vmForks.js");
+	}
+}
+
+/** @experimental */
+class VmThreadsPoolWorker extends ThreadsPoolWorker {
+	name = "vmThreads";
+	reportMemory = true;
+	entrypoint;
+	constructor(options) {
+		/** Loads {@link file://./../../../runtime/workers/vmThreads.ts} */
+		super(options), this.execArgv.push("--experimental-vm-modules"), this.entrypoint = resolve$1(options.distPath, "workers/vmThreads.js");
+	}
+}
+
+const WORKER_START_TIMEOUT = 5e3;
+class Pool {
+	maxWorkers = 0;
+	workerIds = /* @__PURE__ */ new Map();
+	queue = [];
+	activeTasks = [];
+	sharedRunners = [];
+	exitPromises = [];
+	_isCancelling = false;
+	constructor(options, logger) {
+		this.options = options, this.logger = logger;
+	}
+	setMaxWorkers(maxWorkers) {
+		this.maxWorkers = maxWorkers, this.workerIds = new Map(Array.from({ length: maxWorkers }).fill(0).map((_, i) => [i + 1, true]));
+	}
+	async run(task, method) {
+		// Prevent new tasks from being queued during cancellation
+		if (this._isCancelling) throw new Error("[vitest-pool]: Cannot run tasks while pool is cancelling");
+		// Every runner related failure should make this promise reject so that it's picked by pool.
+		// This resolver is used to make the error handling in recursive queue easier.
+		const testFinish = withResolvers();
+		this.queue.push({
+			task,
+			resolver: testFinish,
+			method
+		}), this.schedule(), await testFinish.promise;
+	}
+	async schedule() {
+		if (this.queue.length === 0 || this.activeTasks.length >= this.maxWorkers) return;
+		const { task, resolver, method } = this.queue.shift();
+		try {
+			let isMemoryLimitReached = false;
+			const runner = this.getPoolRunner(task, method), activeTask = {
+				task,
+				resolver,
+				method,
+				cancelTask
+			};
+			this.activeTasks.push(activeTask), runner.on("error", (error) => {
+				resolver.reject(new Error(`[vitest-pool]: Worker ${task.worker} emitted error.`, { cause: error }));
+			});
+			async function cancelTask() {
+				await runner.stop(), resolver.reject(/* @__PURE__ */ new Error("Cancelled"));
+			}
+			const onFinished = (message) => {
+				if (message?.__vitest_worker_response__ && message.type === "testfileFinished") {
+					if (task.memoryLimit && message.usedMemory) isMemoryLimitReached = message.usedMemory >= task.memoryLimit;
+					if (message.error) this.options.state.catchError(message.error, "Test Run Error");
+					runner.off("message", onFinished), resolver.resolve();
+				}
+			};
+			if (runner.on("message", onFinished), !runner.isStarted) {
+				const id = setTimeout(() => resolver.reject(/* @__PURE__ */ new Error(`[vitest-pool]: Timeout starting ${task.worker} runner.`)), WORKER_START_TIMEOUT);
+				await runner.start().finally(() => clearTimeout(id));
+			}
+			const poolId = runner.poolId ?? this.getWorkerId();
+			runner.poolId = poolId, runner.postMessage({
+				__vitest_worker_request__: true,
+				type: method,
+				context: task.context,
+				poolId
+			}), await resolver.promise;
+			const index = this.activeTasks.indexOf(activeTask);
+			if (index !== -1) this.activeTasks.splice(index, 1);
+			if (!task.isolate && !isMemoryLimitReached && this.queue[0]?.task.isolate === false && isEqualRunner(runner, this.queue[0].task)) return this.sharedRunners.push(runner), this.schedule();
+			// Runner terminations are started but not awaited until the end of full run.
+			// Runner termination can also already start from task cancellation.
+			if (!runner.isTerminated) {
+				const id = setTimeout(() => this.logger.error(`[vitest-pool]: Timeout terminating ${task.worker} worker for test files ${formatFiles(task)}.`), this.options.teardownTimeout);
+				this.exitPromises.push(runner.stop().then(() => clearTimeout(id)).catch((error) => this.logger.error(`[vitest-pool]: Failed to terminate ${task.worker} worker for test files ${formatFiles(task)}.`, error)));
+			}
+			this.freeWorkerId(poolId);
+		} 
+		// This is mostly to avoid zombie workers when/if Vitest internals run into errors
+catch (error) {
+			return resolver.reject(error);
+		}
+		return this.schedule();
+	}
+	async cancel() {
+		// Set flag to prevent new tasks from being queued
+		this._isCancelling = true;
+		const pendingTasks = this.queue.splice(0);
+		if (pendingTasks.length) {
+			const error = /* @__PURE__ */ new Error("Cancelled");
+			pendingTasks.forEach((task) => task.resolver.reject(error));
+		}
+		const activeTasks = this.activeTasks.splice(0);
+		await Promise.all(activeTasks.map((task) => task.cancelTask()));
+		const sharedRunners = this.sharedRunners.splice(0);
+		// Reset flag after cancellation completes
+		await Promise.all(sharedRunners.map((runner) => runner.stop())), await Promise.all(this.exitPromises.splice(0)), this.workerIds.forEach((_, id) => this.freeWorkerId(id)), this._isCancelling = false;
+	}
+	async close() {
+		await this.cancel();
+	}
+	getPoolRunner(task, method) {
+		if (task.isolate === false) {
+			const index = this.sharedRunners.findIndex((runner) => isEqualRunner(runner, task));
+			if (index !== -1) return this.sharedRunners.splice(index, 1)[0];
+		}
+		const options = {
+			distPath: this.options.distPath,
+			project: task.project,
+			method,
+			environment: task.context.environment.name,
+			env: task.env,
+			execArgv: task.execArgv
+		};
+		switch (task.worker) {
+			case "forks": return new PoolRunner(options, new ForksPoolWorker(options));
+			case "vmForks": return new PoolRunner(options, new VmForksPoolWorker(options));
+			case "threads": return new PoolRunner(options, new ThreadsPoolWorker(options));
+			case "vmThreads": return new PoolRunner(options, new VmThreadsPoolWorker(options));
+			case "typescript": return new PoolRunner(options, new TypecheckPoolWorker(options));
+		}
+		const customPool = task.project.config.poolRunner;
+		if (customPool != null && customPool.name === task.worker) return new PoolRunner(options, customPool.createPoolWorker(options));
+		throw new Error(`Runner ${task.worker} is not supported. Test files: ${formatFiles(task)}.`);
+	}
+	getWorkerId() {
+		let workerId = 0;
+		return this.workerIds.forEach((state, id) => {
+			if (state && !workerId) workerId = id, this.workerIds.set(id, false);
+		}), workerId;
+	}
+	freeWorkerId(id) {
+		this.workerIds.set(id, true);
+	}
+}
+function withResolvers() {
+	let resolve = () => {}, reject = (_error) => {};
+	const promise = new Promise((res, rej) => {
+		resolve = res, reject = rej;
+	});
+	return {
+		resolve,
+		reject,
+		promise
+	};
+}
+function formatFiles(task) {
+	return task.context.files.map((file) => file.filepath).join(", ");
+}
+function isEqualRunner(runner, task) {
+	if (task.isolate) throw new Error("Isolated tasks should not share runners");
+	return runner.worker.name === task.worker && runner.project === task.project && runner.environment === task.context.environment.name && (!runner.worker.canReuse || runner.worker.canReuse(task));
+}
+
+const suppressWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
+function getFilePoolName(project) {
+	return project.config.browser.enabled ? "browser" : project.config.pool;
+}
+function createPool(ctx) {
+	const pool = new Pool({
+		distPath: ctx.distPath,
+		teardownTimeout: ctx.config.teardownTimeout,
+		state: ctx.state
+	}, ctx.logger), options = resolveOptions(ctx), Sequencer = ctx.config.sequence.sequencer, sequencer = new Sequencer(ctx);
+	let browserPool;
+	async function executeTests(method, specs, invalidates) {
+		if (ctx.onCancel(() => pool.cancel()), 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}.`);
+			specs = await sequencer.shard(Array.from(specs));
+		}
+		const taskGroups = [];
+		let workerId = 0;
+		const sorted = await sequencer.sort(specs), environments = await getSpecificationsEnvironments(specs), groups = groupSpecs(sorted);
+		for (const group of groups) {
+			if (!group) continue;
+			const taskGroup = [], browserSpecs = [];
+			taskGroups.push({
+				tasks: taskGroup,
+				maxWorkers: group.maxWorkers,
+				browserSpecs
+			});
+			for (const specs of group.specs) {
+				const { project, pool } = specs[0];
+				if (pool === "browser") {
+					browserSpecs.push(...specs);
+					continue;
+				}
+				const environment = environments.get(specs[0]);
+				if (!environment) throw new Error(`Cannot find the environment. This is a bug in Vitest.`);
+				taskGroup.push({
+					context: {
+						pool,
+						config: project.serializedConfig,
+						files: specs.map((spec) => ({
+							filepath: spec.moduleId,
+							testLocations: spec.testLines
+						})),
+						invalidates,
+						environment,
+						projectName: project.name,
+						providedContext: project.getProvidedContext(),
+						workerId: workerId++
+					},
+					project,
+					env: {
+						...options.env,
+						...project.config.env
+					},
+					execArgv: [...options.execArgv, ...project.config.execArgv],
+					worker: pool,
+					isolate: project.config.isolate,
+					memoryLimit: getMemoryLimit(ctx.config, pool) ?? null
+				});
+			}
+		}
+		const results = [];
+		for (const { tasks, browserSpecs, maxWorkers } of taskGroups) {
+			pool.setMaxWorkers(maxWorkers);
+			const promises = tasks.map(async (task) => {
+				if (ctx.isCancelling) return ctx.state.cancelFiles(task.context.files, task.project);
+				try {
+					await pool.run(task, method);
+				} catch (error) {
+					// Intentionally cancelled
+					if (ctx.isCancelling && error instanceof Error && error.message === "Cancelled") ctx.state.cancelFiles(task.context.files, task.project);
+					else throw error;
+				}
+			});
+			if (browserSpecs.length) if (browserPool ??= createBrowserPool(ctx), method === "collect") promises.push(browserPool.collectTests(browserSpecs));
+			else promises.push(browserPool.runTests(browserSpecs));
+			const groupResults = await Promise.allSettled(promises);
+			results.push(...groupResults);
+		}
+		const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+		if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
+	}
+	return {
+		name: "default",
+		runTests: (files, invalidates) => executeTests("run", files, invalidates),
+		collectTests: (files, invalidates) => executeTests("collect", files, invalidates),
+		async close() {
+			await Promise.all([pool.close(), browserPool?.close?.()]);
+		}
+	};
+}
+function resolveOptions(ctx) {
+	// 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]), conditions = [...new Set(viteMajor >= 6 ? ctx.vite.config.ssr.resolve?.conditions ?? [] : [
+		"production",
+		"development",
+		...ctx.vite.config.resolve.conditions
+	])].filter((condition) => {
+		return condition === "production" ? ctx.vite.config.isProduction : condition === "development" ? !ctx.vite.config.isProduction : true;
+	}).map((condition) => {
+		return viteMajor >= 6 && condition === "development|production" ? ctx.vite.config.isProduction ? "production" : "development" : condition;
+	}).flatMap((c) => ["--conditions", c]), options = {
+		execArgv: [
+			...process.execArgv.filter((execArg) => execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir")),
+			...conditions,
+			"--experimental-import-meta-resolve",
+			"--require",
+			suppressWarningsPath
+		],
+		env: {
+			TEST: "true",
+			VITEST: "true",
+			NODE_ENV: process.env.NODE_ENV || "test",
+			VITEST_MODE: ctx.config.watch ? "WATCH" : "RUN",
+			FORCE_TTY: isatty(1) ? "true" : "",
+			...process.env,
+			...ctx.config.env
+		}
+	};
+	// 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];
+	return options;
+}
+function resolveMaxWorkers(project) {
+	if (project.config.maxWorkers) return project.config.maxWorkers;
+	if (project.vitest.config.maxWorkers) return project.vitest.config.maxWorkers;
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
+	return project.vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+}
+function getMemoryLimit(config, pool) {
+	if (pool !== "vmForks" && pool !== "vmThreads") return null;
+	const memory = nodeos.totalmem(), limit = getWorkerMemoryLimit(config);
+	// just ignore "memoryLimit" value because we cannot detect memory limit
+	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;
+}
+function groupSpecs(specs) {
+	const groups = [], sequential = {
+		specs: [],
+		maxWorkers: 1
+	}, typechecks = {};
+	specs.forEach((spec) => {
+		if (spec.pool === "typescript") {
+			typechecks[spec.project.name] ||= [], typechecks[spec.project.name].push(spec);
+			return;
+		}
+		const order = spec.project.config.sequence.groupOrder;
+		// Files that have disabled parallelism and default groupId are set into their own group
+		if (order === 0 && spec.project.config.fileParallelism === false) return sequential.specs.push([spec]);
+		const maxWorkers = resolveMaxWorkers(spec.project);
+		// Multiple projects with different maxWorkers but same groupId
+		if (groups[order] ||= {
+			specs: [],
+			maxWorkers
+		}, groups[order].maxWorkers !== maxWorkers) {
+			const last = groups[order].specs.at(-1)?.at(-1)?.project.name;
+			throw new Error(`Projects "${last}" and "${spec.project.name}" have different 'maxWorkers' but same 'sequence.groupId'.\nProvide unique 'sequence.groupId' for them.`);
+		}
+		groups[order].specs.push([spec]);
+	});
+	let order = Math.max(0, ...groups.keys()) + 1;
+	for (const projectName in typechecks) {
+		const maxWorkers = resolveMaxWorkers(typechecks[projectName][0].project), previous = groups[order - 1];
+		if (previous && previous.typecheck && maxWorkers !== previous.maxWorkers) order += 1;
+		groups[order] ||= {
+			specs: [],
+			maxWorkers,
+			typecheck: true
+		}, groups[order].specs.push(typechecks[projectName]);
+	}
+	if (sequential.specs.length) groups.push(sequential);
+	return groups;
+}
+
+function serializeConfig(project) {
+	const { config, globalConfig } = project, viteConfig = project._vite?.config, optimizer = config.deps?.optimizer || {};
 	return {
 		environmentOptions: config.environmentOptions,
 		mode: config.mode,
 		isolate: config.isolate,
+		fileParallelism: config.fileParallelism,
+		maxWorkers: config.maxWorkers,
 		base: config.base,
 		logHeapUsage: config.logHeapUsage,
 		runner: config.runner,
@@ -5911,18 +7161,6 @@ function serializeConfig(config, coreConfig, viteConfig) {
 			};
 		})(config.coverage),
 		fakeTimers: config.fakeTimers,
-		poolOptions: {
-			forks: {
-				singleFork: poolOptions?.forks?.singleFork ?? coreConfig.poolOptions?.forks?.singleFork ?? false,
-				isolate: poolOptions?.forks?.isolate ?? isolate ?? coreConfig.poolOptions?.forks?.isolate ?? true
-			},
-			threads: {
-				singleThread: poolOptions?.threads?.singleThread ?? coreConfig.poolOptions?.threads?.singleThread ?? false,
-				isolate: poolOptions?.threads?.isolate ?? isolate ?? coreConfig.poolOptions?.threads?.isolate ?? true
-			},
-			vmThreads: { singleThread: poolOptions?.vmThreads?.singleThread ?? coreConfig.poolOptions?.vmThreads?.singleThread ?? false },
-			vmForks: { singleFork: poolOptions?.vmForks?.singleFork ?? coreConfig.poolOptions?.vmForks?.singleFork ?? false }
-		},
 		deps: {
 			web: config.deps.web || {},
 			optimizer: Object.entries(optimizer).reduce((acc, [name, option]) => {
@@ -5933,27 +7171,28 @@ function serializeConfig(config, coreConfig, viteConfig) {
 		},
 		snapshotOptions: {
 			snapshotEnvironment: void 0,
-			updateSnapshot: coreConfig.snapshotOptions.updateSnapshot,
-			snapshotFormat: { ...coreConfig.snapshotOptions.snapshotFormat },
-			expand: config.snapshotOptions.expand ?? coreConfig.snapshotOptions.expand
+			updateSnapshot: globalConfig.snapshotOptions.updateSnapshot,
+			snapshotFormat: { ...globalConfig.snapshotOptions.snapshotFormat },
+			expand: config.snapshotOptions.expand ?? globalConfig.snapshotOptions.expand
 		},
 		sequence: {
-			shuffle: coreConfig.sequence.shuffle,
-			concurrent: coreConfig.sequence.concurrent,
-			seed: coreConfig.sequence.seed,
-			hooks: coreConfig.sequence.hooks,
-			setupFiles: coreConfig.sequence.setupFiles
+			shuffle: globalConfig.sequence.shuffle,
+			concurrent: globalConfig.sequence.concurrent,
+			seed: globalConfig.sequence.seed,
+			hooks: globalConfig.sequence.hooks,
+			setupFiles: globalConfig.sequence.setupFiles
 		},
-		inspect: coreConfig.inspect,
-		inspectBrk: coreConfig.inspectBrk,
-		inspector: coreConfig.inspector,
+		inspect: globalConfig.inspect,
+		inspectBrk: globalConfig.inspectBrk,
+		inspector: globalConfig.inspector,
 		watch: config.watch,
-		includeTaskLocation: config.includeTaskLocation ?? coreConfig.includeTaskLocation,
+		includeTaskLocation: config.includeTaskLocation ?? globalConfig.includeTaskLocation,
 		env: {
 			...viteConfig?.env,
 			...config.env
 		},
 		browser: ((browser) => {
+			const provider = project.browser?.provider;
 			return {
 				name: browser.name,
 				headless: browser.headless,
@@ -5963,13 +7202,15 @@ function serializeConfig(config, coreConfig, viteConfig) {
 				viewport: browser.viewport,
 				screenshotFailures: browser.screenshotFailures,
 				locators: { testIdAttribute: browser.locators.testIdAttribute },
-				providerOptions: browser.provider === "playwright" ? { actionTimeout: browser.providerOptions?.context?.actionTimeout } : {},
-				trackUnhandledErrors: browser.trackUnhandledErrors ?? true
+				providerOptions: provider?.name === "playwright" ? { actionTimeout: provider?.options?.actionTimeout } : {},
+				trackUnhandledErrors: browser.trackUnhandledErrors ?? true,
+				trace: browser.trace.mode
 			};
 		})(config.browser),
 		standalone: config.standalone,
-		printConsoleTrace: config.printConsoleTrace ?? coreConfig.printConsoleTrace,
-		benchmark: config.benchmark && { includeSamples: config.benchmark.includeSamples }
+		printConsoleTrace: config.printConsoleTrace ?? globalConfig.printConsoleTrace,
+		benchmark: config.benchmark && { includeSamples: config.benchmark.includeSamples },
+		serializedDefines: config.browser.enabled ? "" : project._serializedDefines || ""
 	};
 }
 
@@ -5999,6 +7240,7 @@ async function loadGlobalSetupFile(file, runner) {
 function CoverageTransform(ctx) {
 	return {
 		name: "vitest:coverage-transform",
+		enforce: "post",
 		transform(srcCode, id) {
 			return ctx.coverageProvider?.onFileTransform?.(srcCode, id, this);
 		}
@@ -6498,7 +7740,7 @@ function MetaEnvReplacerPlugin() {
 		transform(code, id) {
 			if (!/\bimport\.meta\.env\b/.test(code)) return null;
 			let s = null;
-			const cleanCode = stripLiteral(code), envs = cleanCode.matchAll(/\bimport\.meta\.env\b/g);
+			const envs = stripLiteral(code).matchAll(/\bimport\.meta\.env\b/g);
 			for (const env of envs) {
 				s ||= new MagicString(code);
 				const startIndex = env.index, endIndex = startIndex + env[0].length;
@@ -6630,9 +7872,7 @@ function isInline(id) {
 	return cssInlineRE.test(id);
 }
 function getCSSModuleProxyReturn(strategy, filename) {
-	if (strategy === "non-scoped") return "style";
-	const hash = generateCssFilenameHash(filename);
-	return `\`_\${style}_${hash}\``;
+	return strategy === "non-scoped" ? "style" : `\`_\${style}_${generateCssFilenameHash(filename)}\``;
 }
 function CSSEnablerPlugin(ctx) {
 	const shouldProcessCSS = (id) => {
@@ -6654,12 +7894,12 @@ function CSSEnablerPlugin(ctx) {
 					// return proxy for css modules, so that imported module has names:
 					// styles.foo returns a "foo" instead of "undefined"
 					// we don't use code content to generate hash for "scoped", because it's empty
-					const scopeStrategy = typeof ctx.config.css !== "boolean" && ctx.config.css.modules?.classNameStrategy || "stable", proxyReturn = getCSSModuleProxyReturn(scopeStrategy, relative(ctx.config.root, id)), code = `export default new Proxy(Object.create(null), {
+					const scopeStrategy = typeof ctx.config.css !== "boolean" && ctx.config.css.modules?.classNameStrategy || "stable";
+					return { code: `export default new Proxy(Object.create(null), {
             get(_, style) {
-              return ${proxyReturn};
+              return ${getCSSModuleProxyReturn(scopeStrategy, relative(ctx.config.root, id))};
             },
-          })`;
-					return { code };
+          })` };
 				}
 				return { code: "export default \"\"" };
 			}
@@ -6774,12 +8014,7 @@ function getDefaultResolveOptions() {
 	};
 }
 function getDefaultServerConditions() {
-	const viteMajor = Number(version.split(".")[0]);
-	if (viteMajor >= 6) {
-		const conditions = vite.defaultServerConditions;
-		return conditions.filter((c) => c !== "module");
-	}
-	return ["node"];
+	return Number(version.split(".")[0]) >= 6 ? vite.defaultServerConditions.filter((c) => c !== "module") : ["node"];
 }
 
 function ModuleRunnerTransform() {
@@ -6836,16 +8071,17 @@ function VitestProjectResolver(ctx) {
 	const plugin = {
 		name: "vitest:resolve-root",
 		enforce: "pre",
-		async resolveId(id, _, { ssr }) {
-			if (id === "vitest" || id.startsWith("@vitest/") || id.startsWith("vitest/")) {
-				// always redirect the request to the root vitest plugin since
-				// it will be the one used to run Vitest
-				const resolved = await ctx.vite.pluginContainer.resolveId(id, void 0, {
-					skip: new Set([plugin]),
-					ssr
-				});
-				return resolved;
+		config: {
+			order: "post",
+			handler() {
+				return { base: "/" };
 			}
+		},
+		async resolveId(id, _, { ssr }) {
+			if (id === "vitest" || id.startsWith("@vitest/") || id.startsWith("vitest/")) return await ctx.vite.pluginContainer.resolveId(id, void 0, {
+				skip: new Set([plugin]),
+				ssr
+			});
 		}
 	};
 	return plugin;
@@ -6854,6 +8090,12 @@ function VitestCoreResolver(ctx) {
 	return {
 		name: "vitest:resolve-core",
 		enforce: "pre",
+		config: {
+			order: "post",
+			handler() {
+				return { base: "/" };
+			}
+		},
 		async resolveId(id) {
 			if (id === "vitest") return resolve(distDir, "index.js");
 			if (id.startsWith("@vitest/") || id.startsWith("vitest/"))
@@ -6880,24 +8122,22 @@ function WorkspaceVitestPlugin(project, options) {
 					if (existsSync(pkgJsonPath)) name = JSON.parse(readFileSync(pkgJsonPath, "utf-8")).name;
 					if (typeof name !== "string" || !name) name = basename(dir);
 				} else name = options.workspacePath.toString();
-				const isUserBrowserEnabled = viteConfig.test?.browser?.enabled, isBrowserEnabled = isUserBrowserEnabled ?? (viteConfig.test?.browser && project.vitest._cliOptions.browser?.enabled), workspaceNames = [name], browser = viteConfig.test.browser || {};
+				const isBrowserEnabled = viteConfig.test?.browser?.enabled ?? (viteConfig.test?.browser && project.vitest._cliOptions.browser?.enabled), workspaceNames = [name], browser = viteConfig.test.browser || {};
 				if (isBrowserEnabled && browser.name && !browser.instances?.length)
  // vitest injects `instances` in this case later on
 				workspaceNames.push(name ? `${name} (${browser.name})` : browser.name);
-				viteConfig.test?.browser?.instances?.forEach((instance) => {
-					if (instance.name ??= name ? `${name} (${instance.browser})` : instance.browser, isBrowserEnabled) workspaceNames.push(instance.name);
-				});
-				const filters = project.vitest.config.project;
 				// if there is `--project=...` filter, check if any of the potential projects match
 				// if projects don't match, we ignore the test project altogether
 				// if some of them match, they will later be filtered again by `resolveWorkspace`
-				if (filters.length) {
-					const hasProject = workspaceNames.some((name) => {
+				if (viteConfig.test?.browser?.instances?.forEach((instance) => {
+					if (instance.name ??= name ? `${name} (${instance.browser})` : instance.browser, isBrowserEnabled) workspaceNames.push(instance.name);
+				}), project.vitest.config.project.length) {
+					if (!workspaceNames.some((name) => {
 						return project.vitest.matchesProjectFilter(name);
-					});
-					if (!hasProject) throw new VitestFilteredOutProjectError();
+					})) throw new VitestFilteredOutProjectError();
 				}
 				return {
+					base: "/",
 					environments: { __vitest__: { dev: {} } },
 					test: { name: {
 						label: name,
@@ -7036,13 +8276,11 @@ async function isValidNodeImport(id) {
 	const extension = extname(id);
 	if (BUILTIN_EXTENSIONS.has(extension)) return true;
 	if (extension !== ".js") return false;
-	id = id.replace("file:///", "");
-	const package_ = findNearestPackageData(dirname(id));
-	if (package_.type === "module") return true;
+	if (id = id.replace("file:///", ""), findNearestPackageData(dirname(id)).type === "module") return true;
 	if (/\.(?:\w+-)?esm?(?:-\w+)?\.js$|\/esm?\//.test(id)) return false;
 	try {
 		await esModuleLexer.init;
-		const code = await promises.readFile(id, "utf8"), [, , , hasModuleSyntax] = esModuleLexer.parse(code);
+		const code = await promises$1.readFile(id, "utf8"), [, , , hasModuleSyntax] = esModuleLexer.parse(code);
 		return !hasModuleSyntax;
 	} catch {
 		return false;
@@ -7062,8 +8300,8 @@ async function _shouldExternalize(id, options) {
 	// Unless the user explicitly opted to inline them, externalize Vite deps.
 	// They are too big to inline by default.
 	if (matchExternalizePattern(id, moduleDirectories, options?.external) || options?.cacheDir && id.includes(options.cacheDir)) return id;
-	const isLibraryModule = moduleDirectories.some((dir) => id.includes(dir)), guessCJS = isLibraryModule && options?.fallbackCJS;
-	return id = guessCJS ? guessCJSversion(id) || id : id, matchExternalizePattern(id, moduleDirectories, defaultInline) ? false : matchExternalizePattern(id, moduleDirectories, depsExternal) || isLibraryModule && await isValidNodeImport(id) ? id : false;
+	const isLibraryModule = moduleDirectories.some((dir) => id.includes(dir));
+	return id = isLibraryModule && options?.fallbackCJS ? guessCJSversion(id) || id : id, matchExternalizePattern(id, moduleDirectories, defaultInline) ? false : matchExternalizePattern(id, moduleDirectories, depsExternal) || isLibraryModule && await isValidNodeImport(id) ? id : false;
 }
 function matchExternalizePattern(id, moduleDirectories, patterns) {
 	if (patterns == null) return false;
@@ -7105,7 +8343,7 @@ class TestSpecification {
 	*/
 	get testModule() {
 		const task = this.project.vitest.state.idMap.get(this.taskId);
-		return task ? this.project.vitest.state.getReportedEntity(task) : void 0;
+		if (task) return this.project.vitest.state.getReportedEntity(task);
 	}
 	toJSON() {
 		return [
@@ -7136,7 +8374,6 @@ async function createViteServer(inlineConfig) {
 class TestProject {
 	/**
 	* The global Vitest instance.
-	* @experimental The public Vitest API is experimental and does not follow semver.
 	*/
 	vitest;
 	/**
@@ -7150,20 +8387,22 @@ class TestProject {
 	/**
 	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
 	*/
-	tmpDir = join(tmpdir(), nanoid());
+	tmpDir;
 	/** @internal */ typechecker;
 	/** @internal */ _config;
 	/** @internal */ _vite;
 	/** @internal */ _hash;
 	/** @internal */ _resolver;
+	/** @internal */ _fetcher;
+	/** @internal */ _serializedDefines;
 	/** @inetrnal */ testFilesList = null;
 	runner;
 	closingPromise;
 	typecheckFilesList = null;
 	_globalSetups;
 	_provided = {};
-	constructor(vitest, options) {
-		this.options = options, this.vitest = vitest, this.globalConfig = vitest.config;
+	constructor(vitest, options, tmpDir) {
+		this.options = options, this.vitest = vitest, this.globalConfig = vitest.config, this.tmpDir = tmpDir || join(tmpdir(), nanoid());
 	}
 	/**
 	* The unique hash of this project. This value is consistent between the reruns.
@@ -7298,7 +8537,7 @@ class TestProject {
 			const files = await this.globFiles(includeSource, exclude, cwd);
 			await Promise.all(files.map(async (file) => {
 				try {
-					const code = await promises.readFile(file, "utf-8");
+					const code = await promises$1.readFile(file, "utf-8");
 					if (this.isInSourceTestCode(code)) testFiles.push(file);
 				} catch {
 					return null;
@@ -7333,16 +8572,15 @@ class TestProject {
 	}
 	/** @internal */
 	async globFiles(include, exclude, cwd) {
-		const globOptions = {
+		// keep the slashes consistent with Vite
+		// we are not using the pathe here because it normalizes the drive letter on Windows
+		// and we want to keep it the same as working dir
+		return (await glob(include, {
 			dot: true,
 			cwd,
 			ignore: exclude,
 			expandDirectories: false
-		}, files = await glob(include, globOptions);
-		// keep the slashes consistent with Vite
-		// we are not using the pathe here because it normalizes the drive letter on Windows
-		// and we want to keep it the same as working dir
-		return files.map((file) => slash(path.resolve(cwd, file)));
+		})).map((file) => slash(path.resolve(cwd, file)));
 	}
 	/**
 	* Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
@@ -7377,28 +8615,22 @@ class TestProject {
 	/** @internal */
 	_parent;
 	/** @internal */
-	_initParentBrowser = deduped(async () => {
+	_initParentBrowser = deduped(async (childProject) => {
 		if (!this.isBrowserEnabled() || this._parentBrowser) return;
-		await this.vitest.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.vitest.version);
-		const { createBrowserServer, distRoot } = await import('@vitest/browser');
-		let cacheDir;
-		const browser = await createBrowserServer(this, this.vite.config.configFile, [
-			{
-				name: "vitest:browser-cacheDir",
-				configResolved(config) {
-					cacheDir = config.cacheDir;
-				}
-			},
-			...MocksPlugins({ filter(id) {
-				return !(id.includes(distRoot) || id.includes(cacheDir));
-			} }),
-			MetaEnvReplacerPlugin()
-		], [CoverageTransform(this.vitest)]);
+		const provider = this.config.browser.provider || childProject.config.browser.provider;
+		if (provider == null) throw new Error(`Proider was not specified in the "browser.provider" setting. Please, pass down playwright(), webdriverio() or preview() from "@vitest/browser-playwright", "@vitest/browser-webdriverio" or "@vitest/browser-preview" package respectively.`);
+		if (typeof provider.serverFactory !== "function") throw new TypeError(`The browser provider options do not return a "serverFactory" function. Are you using the latest "@vitest/browser-${provider.name}" package?`);
+		const browser = await provider.serverFactory({
+			project: this,
+			mocksPlugins: (options) => MocksPlugins(options),
+			metaEnvReplacer: () => MetaEnvReplacerPlugin(),
+			coveragePlugin: () => CoverageTransform(this.vitest)
+		});
 		if (this._parentBrowser = browser, this.config.browser.ui) setup(this.vitest, browser.vite);
 	});
 	/** @internal */
 	_initBrowserServer = deduped(async () => {
-		if (await this._parent?._initParentBrowser(), !this.browser && this._parent?._parentBrowser) this.browser = this._parent._parentBrowser.spawn(this), await this.vitest.report("onBrowserInit", this);
+		if (await this._parent?._initParentBrowser(this), !this.browser && this._parent?._parentBrowser) this.browser = this._parent._parentBrowser.spawn(this), await this.vitest.report("onBrowserInit", this);
 	});
 	/**
 	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
@@ -7411,6 +8643,8 @@ class TestProject {
 			this.browser?.close(),
 			this.clearTmpDir()
 		].filter(Boolean)).then(() => {
+			if (!this.runner.isClosed()) return this.runner.close();
+		}).then(() => {
 			this._provided = {}, this._vite = void 0;
 		});
 		return this.closingPromise;
@@ -7435,13 +8669,16 @@ class TestProject {
 			// type is very strict here, so we cast it to any
 			this.provide(providedKey, this.config.provide[providedKey]);
 		}
-		this.closingPromise = void 0, this._resolver = new VitestResolver(server.config.cacheDir, this._config), this._vite = server;
+		this.closingPromise = void 0, this._resolver = new VitestResolver(server.config.cacheDir, this._config), this._vite = server, this._serializedDefines = createDefinesScript(server.config.define), this._fetcher = createFetchModuleFunction(this._resolver, this.tmpDir, {
+			dumpFolder: this.config.dumpDir,
+			readFromDump: this.config.server.debug?.load ?? process.env.VITEST_DEBUG_LOAD_DUMP != null
+		});
 		const environment = server.environments.__vitest__;
-		this.runner = new ServerModuleRunner(environment, this._resolver, this._config);
+		this.runner = new ServerModuleRunner(environment, this._fetcher, this._config);
 	}
 	_serializeOverriddenConfig() {
 		// TODO: serialize the config _once_ or when needed
-		const config = serializeConfig(this.config, this.vitest.config, this.vite.config);
+		const config = serializeConfig(this);
 		return this.vitest.configOverride ? deepMerge(config, this.vitest.configOverride) : config;
 	}
 	async clearTmpDir() {
@@ -7466,13 +8703,13 @@ class TestProject {
 	}
 	/** @internal */
 	static _createBasicProject(vitest) {
-		const project = new TestProject(vitest);
-		return project.runner = vitest.runner, project._vite = vitest.vite, project._config = vitest.config, project._resolver = vitest._resolver, project._setHash(), project._provideObject(vitest.config.provide), project;
+		const project = new TestProject(vitest, void 0, vitest._tmpDir);
+		return project.runner = vitest.runner, project._vite = vitest.vite, project._config = vitest.config, project._resolver = vitest._resolver, project._fetcher = vitest._fetcher, project._serializedDefines = createDefinesScript(vitest.vite.config.define), project._setHash(), project._provideObject(vitest.config.provide), project;
 	}
 	/** @internal */
 	static _cloneBrowserProject(parent, config) {
-		const clone = new TestProject(parent.vitest);
-		return clone.runner = parent.runner, clone._vite = parent._vite, clone._resolver = parent._resolver, clone._config = config, clone._setHash(), clone._parent = parent, clone._provideObject(config.provide), clone;
+		const clone = new TestProject(parent.vitest, void 0, parent.tmpDir);
+		return clone.runner = parent.runner, clone._vite = parent._vite, clone._resolver = parent._resolver, clone._fetcher = parent._fetcher, clone._config = config, clone._setHash(), clone._parent = parent, clone._serializedDefines = parent._serializedDefines, clone._provideObject(config.provide), clone;
 	}
 }
 function deduped(cb) {
@@ -7507,8 +8744,13 @@ function generateHash(str) {
 	return `${hash}`;
 }
 
+// vitest.config.*
+// vite.config.*
+// vitest.unit.config.*
+// vite.unit.config.*
+const CONFIG_REGEXP = /^vite(?:st)?(?:\.\w+)?\.config\./;
 async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projectsDefinition, names) {
-	const { configFiles, projectConfigs, nonConfigDirectories } = await resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDefinition), overridesOptions = [
+	const { configFiles, projectConfigs, nonConfigDirectories } = await resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDefinition), cliOverrides = [
 		"logHeapUsage",
 		"allowOnly",
 		"sequence",
@@ -7527,7 +8769,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		"inspect",
 		"inspectBrk",
 		"fileParallelism"
-	], cliOverrides = overridesOptions.reduce((acc, name) => {
+	].reduce((acc, name) => {
 		if (name in cliOptions) acc[name] = cliOptions[name];
 		return acc;
 	}, {}), projectPromises = [], fileProjects = [...configFiles, ...nonConfigDirectories], concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
@@ -7595,19 +8837,13 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 }
 async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	const removeProjects = /* @__PURE__ */ new Set();
-	resolvedProjects.forEach((project) => {
+	return resolvedProjects.forEach((project) => {
 		if (!project.config.browser.enabled) return;
-		const instances = project.config.browser.instances || [], browser = project.config.browser.name;
-		if (instances.length === 0 && browser) instances.push({
-			browser,
-			name: project.name ? `${project.name} (${browser})` : browser
-		}), vitest.logger.warn(withLabel("yellow", "Vitest", [
-			`No browser "instances" were defined`,
-			project.name ? ` for the "${project.name}" project. ` : ". ",
-			`Running tests in "${project.config.browser.name}" browser. `,
-			"The \"browser.name\" field is deprecated since Vitest 3. ",
-			"Read more: https://vitest.dev/guide/browser/config#browser-instances"
-		].filter(Boolean).join("")));
+		const instances = project.config.browser.instances || [];
+		if (instances.length === 0) {
+			removeProjects.add(project);
+			return;
+		}
 		const originalName = project.config.name, filteredInstances = vitest.matchesProjectFilter(originalName) ? instances : instances.filter((instance) => {
 			const newName = instance.name;
 			return vitest.matchesProjectFilter(newName);
@@ -7617,7 +8853,6 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			removeProjects.add(project);
 			return;
 		}
-		if (project.config.browser.providerOptions) vitest.logger.warn(withLabel("yellow", "Vitest", `"providerOptions"${originalName ? ` in "${originalName}" project` : ""} is ignored because it's overridden by the configs. To hide this warning, remove the "providerOptions" property from the browser configuration.`));
 		filteredInstances.forEach((config, index) => {
 			const browser = config.browser;
 			if (!browser) {
@@ -7626,6 +8861,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			}
 			const name = config.name;
 			if (name == null) throw new Error(`The browser configuration must have a "name" property. This is a bug in Vitest. Please, open a new issue with reproduction`);
+			if (config.provider?.name != null && project.config.browser.provider?.name != null && config.provider?.name !== project.config.browser.provider?.name) throw new Error(`The instance cannot have a different provider from its parent. The "${name}" instance specifies "${config.provider?.name}" provider, but its parent has a "${project.config.browser.provider?.name}" provider.`);
 			if (names.has(name)) throw new Error([
 				`Cannot define a nested project for a ${browser} browser. The project name "${name}" was already defined. `,
 				"If you have multiple instances for the same browser, make sure to define a custom \"name\". ",
@@ -7637,29 +8873,10 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			const clone = TestProject._cloneBrowserProject(project, clonedConfig);
 			resolvedProjects.push(clone);
 		}), removeProjects.add(project);
-	}), resolvedProjects = resolvedProjects.filter((project) => !removeProjects.has(project));
-	const headedBrowserProjects = resolvedProjects.filter((project) => {
-		return project.config.browser.enabled && !project.config.browser.headless;
-	});
-	if (headedBrowserProjects.length > 1) {
-		const message = [`Found multiple projects that run browser tests in headed mode: "${headedBrowserProjects.map((p) => p.name).join("\", \"")}".`, ` Vitest cannot run multiple headed browsers at the same time.`].join("");
-		if (!isTTY) throw new Error(`${message} Please, filter projects with --browser=name or --project=name flag or run tests with "headless: true" option.`);
-		const prompts = await import('./index.X0nbfr6-.js').then(function (n) { return n.i; }), { projectName } = await prompts.default({
-			type: "select",
-			name: "projectName",
-			choices: headedBrowserProjects.map((project) => ({
-				title: project.name,
-				value: project.name
-			})),
-			message: `${message} Select a single project to run or cancel and run tests with "headless: true" option. Note that you can also start tests with --browser=name or --project=name flag.`
-		});
-		if (!projectName) throw new Error("The test run was aborted.");
-		return resolvedProjects.filter((project) => project.name === projectName);
-	}
-	return resolvedProjects;
+	}), resolvedProjects.filter((project) => !removeProjects.has(project));
 }
 function cloneConfig(project, { browser,...config }) {
-	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name,...overrideConfig } = config, currentConfig = project.config.browser, clonedConfig = deepClone(project.config);
+	const { locators, viewport, testerHtmlPath, headless, screenshotDirectory, screenshotFailures, browser: _browser, name, provider,...overrideConfig } = config, currentConfig = project.config.browser, clonedConfig = deepClone(project.config);
 	return mergeConfig({
 		...clonedConfig,
 		browser: {
@@ -7670,9 +8887,9 @@ function cloneConfig(project, { browser,...config }) {
 			screenshotDirectory: screenshotDirectory ?? currentConfig.screenshotDirectory,
 			screenshotFailures: screenshotFailures ?? currentConfig.screenshotFailures,
 			headless: headless ?? currentConfig.headless,
+			provider: provider ?? currentConfig.provider,
 			name: browser,
-			providerOptions: config,
-			instances: void 0
+			instances: []
 		},
 		include: overrideConfig.include && overrideConfig.include.length > 0 ? [] : clonedConfig.include,
 		exclude: overrideConfig.exclude && overrideConfig.exclude.length > 0 ? [] : clonedConfig.exclude,
@@ -7692,14 +8909,17 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 				const note = "Projects definition";
 				throw new Error(`${note} references a non-existing file or a directory: ${file}`);
 			}
-			const stats = await promises.stat(file);
+			const stats = statSync(file);
 			// user can specify a config file directly
-			if (stats.isFile()) projectsConfigFiles.push(file);
-			else if (stats.isDirectory()) {
-				const configFile = await resolveDirectoryConfig(file);
+			if (stats.isFile()) {
+				const name = basename(file);
+				if (!CONFIG_REGEXP.test(name)) throw new Error(`The file "${relative(vitest.config.root, file)}" must start with "vitest.config"/"vite.config" or match the pattern "(vitest|vite).*.config.*" to be a valid project config.`);
+				projectsConfigFiles.push(file);
+			} else if (stats.isDirectory()) {
+				const configFile = resolveDirectoryConfig(file);
 				if (configFile) projectsConfigFiles.push(configFile);
 				else {
-					const directory = file[file.length - 1] === "/" ? file : `${file}/`;
+					const directory = file.at(-1) === "/" ? file : `${file}/`;
 					nonConfigProjectDirectories.push(directory);
 				}
 			} else
@@ -7725,16 +8945,20 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 				"**/*.timestamp-*",
 				"**/.DS_Store"
 			]
-		}, projectsFs = await glob(projectsGlobMatches, globOptions);
-		await Promise.all(projectsFs.map(async (path) => {
+		};
+		(await glob(projectsGlobMatches, globOptions)).forEach((path) => {
 			// directories are allowed with a glob like `packages/*`
 			// in this case every directory is treated as a project
 			if (path.endsWith("/")) {
-				const configFile = await resolveDirectoryConfig(path);
+				const configFile = resolveDirectoryConfig(path);
 				if (configFile) projectsConfigFiles.push(configFile);
 				else nonConfigProjectDirectories.push(path);
-			} else projectsConfigFiles.push(path);
-		}));
+			} else {
+				const name = basename(path);
+				if (!CONFIG_REGEXP.test(name)) throw new Error(`The projects glob matched a file "${relative(vitest.config.root, path)}", but it should also either start with "vitest.config"/"vite.config" or match the pattern "(vitest|vite).*.config.*".`);
+				projectsConfigFiles.push(path);
+			}
+		});
 	}
 	const projectConfigFiles = Array.from(new Set(projectsConfigFiles));
 	return {
@@ -7743,16 +8967,13 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 		configFiles: projectConfigFiles
 	};
 }
-async function resolveDirectoryConfig(directory) {
-	const files = new Set(await promises.readdir(directory)), configFile = configFiles.find((file) => files.has(file));
+function resolveDirectoryConfig(directory) {
+	const files = new Set(readdirSync(directory)), configFile = configFiles.find((file) => files.has(file));
 	return configFile ? resolve(directory, configFile) : null;
 }
 function getDefaultTestProject(vitest) {
 	const filter = vitest.config.project, project = vitest._ensureRootProject();
-	if (!filter.length) return project;
-	// check for the project name and browser names
-	const hasProjects = getPotentialProjectNames(project).some((p) => vitest.matchesProjectFilter(p));
-	return hasProjects ? project : null;
+	return !filter.length || getPotentialProjectNames(project).some((p) => vitest.matchesProjectFilter(p)) ? project : null;
 }
 function getPotentialProjectNames(project) {
 	const names = [project.name];
@@ -7775,17 +8996,11 @@ function createReporters(reporterReferences, ctx) {
 	const runner = ctx.runner, promisedReporters = reporterReferences.map(async (referenceOrInstance) => {
 		if (Array.isArray(referenceOrInstance)) {
 			const [reporterName, reporterOptions] = referenceOrInstance;
-			if (reporterName === "html") {
-				await ctx.packageInstaller.ensureInstalled("@vitest/ui", ctx.config.root, ctx.version);
-				const CustomReporter = await loadCustomReporterModule("@vitest/ui/reporter", runner);
-				return new CustomReporter(reporterOptions);
-			} else if (reporterName in ReportersMap) {
+			if (reporterName === "html") return await ctx.packageInstaller.ensureInstalled("@vitest/ui", ctx.config.root, ctx.version), new (await (loadCustomReporterModule("@vitest/ui/reporter", runner)))(reporterOptions);
+			if (reporterName in ReportersMap) {
 				const BuiltinReporter = ReportersMap[reporterName];
 				return new BuiltinReporter(reporterOptions);
-			} else {
-				const CustomReporter = await loadCustomReporterModule(reporterName, runner);
-				return new CustomReporter(reporterOptions);
-			}
+			} else return new (await (loadCustomReporterModule(reporterName, runner)))(reporterOptions);
 		}
 		return referenceOrInstance;
 	});
@@ -7796,10 +9011,7 @@ function createBenchmarkReporters(reporterReferences, runner) {
 		if (typeof referenceOrInstance === "string") if (referenceOrInstance in BenchmarkReportsMap) {
 			const BuiltinReporter = BenchmarkReportsMap[referenceOrInstance];
 			return new BuiltinReporter();
-		} else {
-			const CustomReporter = await loadCustomReporterModule(referenceOrInstance, runner);
-			return new CustomReporter();
-		}
+		} else return new (await (loadCustomReporterModule(referenceOrInstance, runner)))();
 		return referenceOrInstance;
 	});
 	return Promise.all(promisedReporters);
@@ -7817,11 +9029,11 @@ function parseFilter(filter) {
 	return { filename: filter };
 }
 function groupFilters(filters) {
-	const groupedFilters_ = groupBy(filters, (f) => f.filename), groupedFilters = Object.fromEntries(Object.entries(groupedFilters_).map((entry) => {
+	const groupedFilters_ = groupBy(filters, (f) => f.filename);
+	return Object.fromEntries(Object.entries(groupedFilters_).map((entry) => {
 		const [filename, filters] = entry, testLocations = filters.map((f) => f.lineNumber);
 		return [filename, testLocations.filter((l) => l !== void 0)];
 	}));
-	return groupedFilters;
 }
 
 class VitestSpecifications {
@@ -7882,7 +9094,7 @@ class VitestSpecifications {
 	}
 	async filterTestsBySource(specs) {
 		if (this.vitest.config.changed && !this.vitest.config.related) {
-			const { VitestGit } = await import('./git.BFNcloKD.js'), vitestGit = new VitestGit(this.vitest.config.root), related = await vitestGit.findChangedFiles({ changedSince: this.vitest.config.changed });
+			const { VitestGit } = await import('./git.BFNcloKD.js'), related = await new VitestGit(this.vitest.config.root).findChangedFiles({ changedSince: this.vitest.config.changed });
 			if (!related) throw process.exitCode = 1, new GitNotFoundError();
 			this.vitest.config.related = Array.from(new Set(related));
 		}
@@ -7906,7 +9118,7 @@ class VitestSpecifications {
 		const addImports = async (project, filepath) => {
 			if (deps.has(filepath)) return;
 			deps.add(filepath);
-			const mod = project.vite.environments.ssr.moduleGraph.getModuleById(filepath), transformed = mod?.transformResult || await project.vite.environments.ssr.transformRequest(filepath);
+			const transformed = project.vite.environments.ssr.moduleGraph.getModuleById(filepath)?.transformResult || await project.vite.environments.ssr.transformRequest(filepath);
 			if (!transformed) return;
 			const dependencies = [...transformed.deps || [], ...transformed.dynamicDeps || []];
 			await Promise.all(dependencies.map(async (dep) => {
@@ -8044,10 +9256,10 @@ class TestCase extends ReportedTaskImplementation {
 	diagnostic() {
 		const result = this.task.result;
 		// startTime should always be available if the test has properly finished
-		if (!result || !result.startTime) return void 0;
-		const duration = result.duration || 0, slow = duration > this.project.globalConfig.slowTestThreshold;
+		if (!result || !result.startTime) return;
+		const duration = result.duration || 0;
 		return {
-			slow,
+			slow: duration > this.project.globalConfig.slowTestThreshold,
 			heap: result.heap,
 			duration,
 			startTime: result.startTime,
@@ -8186,16 +9398,19 @@ class TestModule extends SuiteImplementation {
 	* This value corresponds to the ID in the Vite's module graph.
 	*/
 	moduleId;
+	/**
+	* Module id relative to the project. This is the same as `task.name`.
+	*/
+	relativeModuleId;
 	/** @internal */
 	constructor(task, project) {
-		super(task, project), this.moduleId = task.filepath;
+		super(task, project), this.moduleId = task.filepath, this.relativeModuleId = task.name;
 	}
 	/**
 	* Checks the running state of the test file.
 	*/
 	state() {
-		const state = this.task.result?.state;
-		return state === "queued" ? "queued" : getSuiteState(this.task);
+		return this.task.result?.state === "queued" ? "queued" : getSuiteState(this.task);
 	}
 	/**
 	* Useful information about the module like duration, memory usage, etc.
@@ -8254,10 +9469,10 @@ class StateManager {
 	idMap = /* @__PURE__ */ new Map();
 	taskFileMap = /* @__PURE__ */ new WeakMap();
 	errorsSet = /* @__PURE__ */ new Set();
-	processTimeoutCauses = /* @__PURE__ */ new Set();
 	reportedTasksMap = /* @__PURE__ */ new WeakMap();
 	blobs;
 	transformTime = 0;
+	metadata = {};
 	onUnhandledError;
 	/** @internal */
 	_data = {
@@ -8288,12 +9503,6 @@ class StateManager {
 	getUnhandledErrors() {
 		return Array.from(this.errorsSet.values());
 	}
-	addProcessTimeoutCause(cause) {
-		this.processTimeoutCauses.add(cause);
-	}
-	getProcessTimeoutCauses() {
-		return Array.from(this.processTimeoutCauses.values());
-	}
 	getPaths() {
 		return Array.from(this.pathsSet);
 	}
@@ -8354,6 +9563,10 @@ class StateManager {
 	getReportedEntity(task) {
 		return this.reportedTasksMap.get(task);
 	}
+	getReportedEntityById(taskId) {
+		const task = this.idMap.get(taskId);
+		return task ? this.reportedTasksMap.get(task) : void 0;
+	}
 	updateTasks(packs) {
 		for (const [id, result, meta] of packs) {
 			const task = this.idMap.get(id);
@@ -8374,7 +9587,12 @@ class StateManager {
 		return Array.from(this.idMap.values()).filter((t) => t.result?.state === "fail").length;
 	}
 	cancelFiles(files, project) {
-		this.collectFiles(project, files.map((filepath) => createFileTask$1(filepath, project.config.root, project.config.name)));
+		// if we don't filter existing modules, they will be overriden by `collectFiles`
+		const nonRegisteredFiles = files.filter(({ filepath }) => {
+			const relativePath = relative(project.config.root, filepath), id = generateFileHash(relativePath, project.name);
+			return !this.idMap.has(id);
+		});
+		this.collectFiles(project, nonRegisteredFiles.map((file) => createFileTask$1(file.filepath, project.config.root, project.config.name)));
 	}
 }
 
@@ -8859,7 +10077,7 @@ class TestRun {
 	async updated(update, events) {
 		this.syncUpdateStacks(update), this.vitest.state.updateTasks(update);
 		for (const [id, event, data] of events) await this.reportEvent(id, event, data).catch((error) => {
-			this.vitest.state.catchError(serializeError$1(error), "Unhandled Reporter Error");
+			this.vitest.state.catchError(serializeValue(error), "Unhandled Reporter Error");
 		});
 		// TODO: what is the order or reports here?
 		// "onTaskUpdate" in parallel with others or before all or after all?
@@ -8871,11 +10089,20 @@ class TestRun {
 		// specification won't have the File task if they were filtered by the --shard command
 		const modules = specifications.map((spec) => spec.testModule).filter((s) => s != null), state = this.vitest.isCancelling ? "interrupted" : this.hasFailed(modules) ? "failed" : "passed";
 		if (state !== "passed") process.exitCode = 1;
-		this.vitest.report("onTestRunEnd", modules, [...errors], state);
+		for (const project in await this.vitest.report("onTestRunEnd", modules, [...errors], state), this.vitest.state.metadata) {
+			const meta = this.vitest.state.metadata[project];
+			if (!meta?.dumpDir) continue;
+			const path = resolve(meta.dumpDir, "vitest-metadata.json");
+			meta.outline = {
+				externalized: Object.keys(meta.externalized).length,
+				inlined: Object.keys(meta.tmps).length
+			}, await writeFile(path, JSON.stringify(meta, null, 2), "utf-8"), this.vitest.logger.log(`Metadata written to ${path}`);
+		}
 	}
 	hasFailed(modules) {
 		return modules.length ? modules.some((m) => !m.ok()) : !this.vitest.config.passWithNoTests;
 	}
+	// make sure the error always has a "stacks" property
 	syncUpdateStacks(update) {
 		update.forEach(([taskId, result]) => {
 			const task = this.vitest.state.idMap.get(taskId), isBrowser = task && task.file.pool === "browser";
@@ -8926,9 +10153,8 @@ class TestRun {
 		const path = attachment.path;
 		if (path && !path.startsWith("http://") && !path.startsWith("https://")) {
 			const currentPath = resolve(project.config.root, path), hash = createHash("sha1").update(currentPath).digest("hex"), newPath = resolve(project.config.attachmentsDir, `${sanitizeFilePath(annotation.message)}-${hash}${extname(currentPath)}`);
-			await mkdir(dirname(newPath), { recursive: true }), await copyFile(currentPath, newPath), attachment.path = newPath;
-			const contentType = attachment.contentType ?? mime.getType(basename(currentPath));
-			attachment.contentType = contentType || void 0;
+			if (!existsSync(project.config.attachmentsDir)) await mkdir(project.config.attachmentsDir, { recursive: true });
+			await copyFile(currentPath, newPath), attachment.path = newPath, attachment.contentType = (attachment.contentType ?? mime.getType(basename(currentPath))) || void 0;
 		}
 		return attachment;
 	}
@@ -8988,21 +10214,14 @@ class VitestWatcher {
 		}), triggered;
 	}
 	onFileChange = (id) => {
-		id = slash(id), this.vitest.logger.clearHighlightCache(id), this.vitest.invalidateFile(id);
-		const testFiles = this.getTestFilesFromWatcherTrigger(id);
-		if (testFiles) this.scheduleRerun(id);
-		else {
-			const needsRerun = this.handleFileChanged(id);
-			if (needsRerun) this.scheduleRerun(id);
-		}
+		if (id = slash(id), this.vitest.logger.clearHighlightCache(id), this.vitest.invalidateFile(id), this.getTestFilesFromWatcherTrigger(id)) this.scheduleRerun(id);
+		else if (this.handleFileChanged(id)) this.scheduleRerun(id);
 	};
 	onFileDelete = (id) => {
 		if (id = slash(id), this.vitest.logger.clearHighlightCache(id), this.invalidates.add(id), this.vitest.state.filesMap.has(id)) this.vitest.projects.forEach((project) => project._removeCachedTestFile(id)), this.vitest.state.filesMap.delete(id), this.vitest.cache.results.removeFromCache(id), this.vitest.cache.stats.removeStats(id), this.changedTests.delete(id), this.vitest.report("onTestRemoved", id);
 	};
 	onFileCreate = (id) => {
-		id = slash(id), this.vitest.invalidateFile(id);
-		const testFiles = this.getTestFilesFromWatcherTrigger(id);
-		if (testFiles) {
+		if (id = slash(id), this.vitest.invalidateFile(id), this.getTestFilesFromWatcherTrigger(id)) {
 			this.scheduleRerun(id);
 			return;
 		}
@@ -9011,11 +10230,7 @@ class VitestWatcher {
 		if (this.vitest.projects.forEach((project) => {
 			if (project.matchesTestGlob(id, () => fileContent ??= readFileSync(id, "utf-8"))) matchingProjects.push(project);
 		}), matchingProjects.length > 0) this.changedTests.add(id), this.scheduleRerun(id);
-		else {
-			// it's possible that file was already there but watcher triggered "add" event instead
-			const needsRerun = this.handleFileChanged(id);
-			if (needsRerun) this.scheduleRerun(id);
-		}
+		else if (this.handleFileChanged(id)) this.scheduleRerun(id);
 	};
 	handleSetupFile(filepath) {
 		let isSetupFile = false;
@@ -9035,8 +10250,7 @@ class VitestWatcher {
 		if (pm.isMatch(filepath, this.vitest.config.forceRerunTriggers)) return this.vitest.state.getFilepaths().forEach((file) => this.changedTests.add(file)), true;
 		if (this.handleSetupFile(filepath)) return true;
 		const projects = this.vitest.projects.filter((project) => {
-			const moduleGraph = project.browser?.vite.moduleGraph || project.vite.moduleGraph;
-			return moduleGraph.getModulesByFile(filepath)?.size;
+			return (project.browser?.vite.moduleGraph || project.vite.moduleGraph).getModulesByFile(filepath)?.size;
 		});
 		if (!projects.length) return this.vitest.state.filesMap.has(filepath) || this.vitest.projects.some((project) => project._isCachedTestFile(filepath)) ? (this.changedTests.add(filepath), true) : false;
 		const files = [];
@@ -9050,9 +10264,7 @@ class VitestWatcher {
 			}
 			let rerun = false;
 			for (const mod of mods) mod.importers.forEach((i) => {
-				if (!i.file) return;
-				const needsRerun = this.handleFileChanged(i.file);
-				if (needsRerun) rerun = true;
+				if (i.file && this.handleFileChanged(i.file)) rerun = true;
 			});
 			if (rerun) files.push(filepath);
 		}
@@ -9112,6 +10324,8 @@ class Vitest {
 	/** @internal */ runner;
 	/** @internal */ _testRun = void 0;
 	/** @internal */ _resolver;
+	/** @internal */ _fetcher;
+	/** @internal */ _tmpDir = join(tmpdir(), nanoid());
 	isFirstRun = true;
 	restartsCount = 0;
 	specifications;
@@ -9167,18 +10381,19 @@ class Vitest {
 		this.watcher.unregisterWatcher(), clearTimeout(this._rerunTimer), this.restartsCount += 1, this.pool?.close?.(), this.pool = void 0, this.closingPromise = void 0, this.projects = [], this.runningPromise = void 0, this.coreWorkspaceProject = void 0, this.specifications.clearCache(), this._coverageProvider = void 0, this._onUserTestsRerun = [], this._vite = server;
 		const resolved = resolveConfig(this, options, server.config);
 		if (this._config = resolved, this._state = new StateManager({ onUnhandledError: resolved.onUnhandledError }), this._cache = new VitestCache(this.version), this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions }), this._testRun = new TestRun(this), this.config.watch) this.watcher.registerWatcher();
-		this._resolver = new VitestResolver(server.config.cacheDir, resolved);
+		this._resolver = new VitestResolver(server.config.cacheDir, resolved), this._fetcher = createFetchModuleFunction(this._resolver, this._tmpDir, {
+			dumpFolder: this.config.dumpDir,
+			readFromDump: this.config.server.debug?.load ?? process.env.VITEST_DEBUG_LOAD_DUMP != null
+		});
 		const environment = server.environments.__vitest__;
-		if (this.runner = new ServerModuleRunner(environment, this._resolver, resolved), this.config.watch) {
+		if (this.runner = new ServerModuleRunner(environment, this._fetcher, resolved), this.config.watch) {
 			// hijack server restart
 			const serverRestart = server.restart;
 			// since we set `server.hmr: false`, Vite does not auto restart itself
 			server.restart = async (...args) => {
 				await Promise.all(this._onRestartListeners.map((fn) => fn())), this.report("onServerRestart"), await this.close(), await serverRestart(...args);
 			}, server.watcher.on("change", async (file) => {
-				file = normalize(file);
-				const isConfig = file === server.config.configFile || this.projects.some((p) => p.vite.config.configFile === file);
-				if (isConfig) await Promise.all(this._onRestartListeners.map((fn) => fn("config"))), this.report("onServerRestart", "config"), await this.close(), await serverRestart();
+				if (file = normalize(file), file === server.config.configFile || this.projects.some((p) => p.vite.config.configFile === file)) await Promise.all(this._onRestartListeners.map((fn) => fn("config"))), this.report("onServerRestart", "config"), await this.close(), await serverRestart();
 			});
 		}
 		this.cache.results.setConfig(resolved.root, resolved.cache);
@@ -9187,19 +10402,22 @@ class Vitest {
 		} catch {}
 		const projects = await this.resolveProjects(this._cliOptions);
 		if (this.projects = projects, await Promise.all(projects.flatMap((project) => {
-			const hooks = project.vite.config.getSortedPluginHooks("configureVitest");
-			return hooks.map((hook) => hook({
+			return project.vite.config.getSortedPluginHooks("configureVitest").map((hook) => hook({
 				project,
 				vitest: this,
 				injectTestProjects: this.injectTestProject
 			}));
 		})), this._cliOptions.browser?.enabled) {
-			const browserProjects = this.projects.filter((p) => p.config.browser.enabled);
-			if (!browserProjects.length) throw new Error(`Vitest received --browser flag, but no project had a browser configuration.`);
+			if (!this.projects.filter((p) => p.config.browser.enabled).length) throw new Error(`Vitest received --browser flag, but no project had a browser configuration.`);
 		}
 		if (!this.projects.length) {
 			const filter = toArray(resolved.project).join("\", \"");
-			throw filter ? new Error(`No projects matched the filter "${filter}".`) : new Error(`Vitest wasn't able to resolve any project.`);
+			if (filter) throw new Error(`No projects matched the filter "${filter}".`);
+			{
+				let error = `Vitest wasn't able to resolve any project.`;
+				if (this.config.browser.enabled && !this.config.browser.instances?.length) error += ` Please, check that you specified the "browser.instances" option.`;
+				throw new Error(error);
+			}
 		}
 		if (!this.coreWorkspaceProject) this.coreWorkspaceProject = TestProject._createBasicProject(this);
 		if (this.config.testNamePattern) this.configOverride.testNamePattern = this.config.testNamePattern;
@@ -9314,7 +10532,7 @@ class Vitest {
 		}, await this.report("onInit", this);
 		const specifications = [];
 		for (const file of files) {
-			const project = this.getProjectByName(file.projectName || ""), specification = project.createSpecification(file.filepath, void 0, file.pool);
+			const specification = this.getProjectByName(file.projectName || "").createSpecification(file.filepath, void 0, file.pool);
 			specifications.push(specification);
 		}
 		await this._testRun.start(specifications).catch(noop);
@@ -9324,6 +10542,12 @@ class Vitest {
 			unhandledErrors: this.state.getUnhandledErrors()
 		};
 	}
+	/**
+	* Returns the seed, if tests are running in a random order.
+	*/
+	getSeed() {
+		return this.config.sequence.seed ?? null;
+	}
 	/** @internal */
 	async _reportFileTask(file) {
 		const project = this.getProjectByName(file.projectName || "");
@@ -9607,6 +10831,12 @@ class Vitest {
 		else this.configOverride.testNamePattern = pattern ? new RegExp(pattern) : void 0;
 	}
 	/**
+	* Returns the regexp used for the global test name pattern.
+	*/
+	getGlobalTestNamePattern() {
+		return this.configOverride.testNamePattern == null ? this.config.testNamePattern : this.configOverride.testNamePattern;
+	}
+	/**
 	* Resets the global test name pattern. This method doesn't run any tests.
 	*/
 	resetGlobalTestNamePattern() {
@@ -9641,10 +10871,8 @@ class Vitest {
 	*/
 	invalidateFile(filepath) {
 		this.projects.forEach(({ vite, browser }) => {
-			const environments = [...Object.values(vite.environments), ...Object.values(browser?.vite.environments || {})];
-			environments.forEach(({ moduleGraph }) => {
-				const modules = moduleGraph.getModulesByFile(filepath);
-				modules?.forEach((module) => moduleGraph.invalidateModule(module));
+			[...Object.values(vite.environments), ...Object.values(browser?.vite.environments || {})].forEach(({ moduleGraph }) => {
+				moduleGraph.getModulesByFile(filepath)?.forEach((module) => moduleGraph.invalidateModule(module));
 			});
 		});
 	}
@@ -9694,7 +10922,7 @@ class Vitest {
 	async exit(force = false) {
 		if (setTimeout(() => {
 			this.report("onProcessTimeout").then(() => {
-				if (console.warn(`close timed out after ${this.config.teardownTimeout}ms`), this.state.getProcessTimeoutCauses().forEach((cause) => console.warn(cause)), !this.pool) {
+				if (console.warn(`close timed out after ${this.config.teardownTimeout}ms`), !this.pool) {
 					const runningServers = [this._vite, ...this.projects.map((p) => p._vite)].filter(Boolean).length;
 					if (runningServers === 1) console.warn("Tests closed successfully but something prevents Vite server from exiting");
 					else if (runningServers > 1) console.warn(`Tests closed successfully but something prevents ${runningServers} Vite servers from exiting`);
@@ -9767,8 +10995,7 @@ class Vitest {
 	matchesProjectFilter(name) {
 		const projects = this._config?.project || this._cliOptions?.project;
 		return !projects || !projects.length ? true : toArray(projects).some((project) => {
-			const regexp = wildcardPatternToRegExp(project);
-			return regexp.test(name);
+			return wildcardPatternToRegExp(project).test(name);
 		});
 	}
 }
@@ -9797,15 +11024,12 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 				// however to allow vitest plugins to modify vitest config values
 				// this is repeated in configResolved where the config is final
 				const testConfig = deepMerge({}, configDefaults, removeUndefinedValues(viteConfig.test ?? {}), options);
-				testConfig.api = resolveApiServerConfig(testConfig, defaultPort);
-				// store defines for globalThis to make them
-				// reassignable when running in worker in src/runtime/setup.ts
-				const defines = deleteDefineConfig(viteConfig);
-				options.defines = defines;
+				testConfig.api = resolveApiServerConfig(testConfig, defaultPort), options.defines = deleteDefineConfig(viteConfig);
 				let open = false;
 				if (testConfig.ui && testConfig.open) open = testConfig.uiBase ?? "/__vitest__/";
 				const resolveOptions = getDefaultResolveOptions();
 				let config = {
+					base: "/",
 					root: viteConfig.test?.root || options.root,
 					define: { "process.env.NODE_ENV": "process.env.NODE_ENV" },
 					resolve: {
@@ -9829,10 +11053,6 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 						__vitest__: { dev: {} }
 					},
 					test: {
-						poolOptions: {
-							threads: { isolate: options.poolOptions?.threads?.isolate ?? options.isolate ?? testConfig.poolOptions?.threads?.isolate ?? viteConfig.test?.isolate },
-							forks: { isolate: options.poolOptions?.forks?.isolate ?? options.isolate ?? testConfig.poolOptions?.forks?.isolate ?? viteConfig.test?.isolate }
-						},
 						root: testConfig.root ?? viteConfig.test?.root,
 						deps: testConfig.deps ?? viteConfig.test?.deps
 					}
@@ -9916,7 +11136,7 @@ function removeUndefinedValues(obj) {
 }
 
 async function createVitest(mode, options, viteOverrides = {}, vitestOptions = {}) {
-	const ctx = new Vitest(mode, deepClone(options), vitestOptions), root = slash(resolve$1(options.root || process.cwd())), configPath = options.config === false ? false : options.config ? resolve$1(root, options.config) : await findUp(configFiles, { cwd: root });
+	const ctx = new Vitest(mode, deepClone(options), vitestOptions), root = slash(resolve$1(options.root || process.cwd())), configPath = options.config === false ? false : options.config ? resolve$1(root, options.config) : any(configFiles, { cwd: root });
 	options.config = configPath;
 	const { browser: _removeBrowser,...restOptions } = options, config = {
 		configFile: configPath,
@@ -9968,9 +11188,11 @@ class WatchFilter {
 					this.write(`${ESC}1G${ESC}0J`), onSubmit(void 0);
 					return;
 				case key?.name === "enter":
-				case key?.name === "return":
-					onSubmit(this.results[this.selectionIndex] || this.currentKeyword || ""), this.currentKeyword = void 0;
+				case key?.name === "return": {
+					const selection = this.results[this.selectionIndex], result = typeof selection === "string" ? selection : selection?.key;
+					onSubmit(result || this.currentKeyword || ""), this.currentKeyword = void 0;
 					break;
+				}
 				case key?.name === "up":
 					if (this.selectionIndex && this.selectionIndex > 0) this.selectionIndex--;
 					else this.selectionIndex = -1;
@@ -10032,7 +11254,7 @@ ${c.dim(`   ...and ${remainingResultCount} more ${remainingResultCount === 1 ? "
 		this.stdout.write(data);
 	}
 	getLastResults() {
-		return this.results;
+		return this.results.map((r) => typeof r === "string" ? r : r.toString());
 	}
 }
 
@@ -10058,6 +11280,26 @@ ${c.bold("  Watch Usage")}
 ${keys.map((i) => c.dim("  press ") + c.reset([i[0]].flat().map(c.bold).join(", ")) + c.dim(` to ${i[1]}`)).join("\n")}
 `);
 }
+function* traverseFilteredTestNames(parentName, filter, t) {
+	if (isTestCase(t)) {
+		if (t.name.match(filter)) {
+			const displayName = `${parentName} > ${t.name}`;
+			yield {
+				key: t.name,
+				toString: () => displayName
+			};
+		}
+	} else {
+		parentName = parentName.length ? `${parentName} > ${t.name}` : t.name;
+		for (const task of t.tasks) yield* traverseFilteredTestNames(parentName, filter, task);
+	}
+}
+function* getFilteredTestNames(pattern, suite) {
+	try {
+		const reg = new RegExp(pattern), files = /* @__PURE__ */ new Set();
+		for (const file of suite) if (!files.has(file.name)) files.add(file.name), yield* traverseFilteredTestNames("", reg, file);
+	} catch {}
+}
 function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 	let latestFilename = "";
 	async function _keypressHandler(str, key) {
@@ -10107,15 +11349,8 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 	}
 	async function inputNamePattern() {
 		off();
-		const watchFilter = new WatchFilter("Input test name pattern (RegExp)", stdin, stdout), filter = await watchFilter.filter((str) => {
-			const files = ctx.state.getFiles(), tests = getTests(files);
-			try {
-				const reg = new RegExp(str);
-				return tests.map((test) => test.name).filter((testName) => testName.match(reg));
-			} catch {
-				// `new RegExp` may throw error when input is invalid regexp
-				return [];
-			}
+		const filter = await new WatchFilter("Input test name pattern (RegExp)", stdin, stdout).filter((str) => {
+			return [...getFilteredTestNames(str, ctx.state.getFiles())];
 		});
 		if (on(), typeof filter === "undefined") return;
 		const files = ctx.state.getFilepaths(), cliFiles = ctx.config.standalone && !files.length ? await ctx._globTestFilepaths() : void 0;
@@ -10134,8 +11369,7 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 	async function inputFilePattern() {
 		off();
 		const watchFilter = new WatchFilter("Input filename pattern", stdin, stdout), filter = await watchFilter.filter(async (str) => {
-			const specifications = await ctx.globTestSpecifications([str]);
-			return specifications.map((specification) => relative(ctx.config.root, specification.moduleId)).filter((file, index, all) => all.indexOf(file) === index);
+			return (await ctx.globTestSpecifications([str])).map((specification) => relative(ctx.config.root, specification.moduleId)).filter((file, index, all) => all.indexOf(file) === index);
 		});
 		if (on(), typeof filter === "undefined") return;
 		latestFilename = filter?.trim() || "";
@@ -10287,4 +11521,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { FilesNotFoundError as F, GitNotFoundError as G, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, experimental_getRunnerTask as d, escapeTestName as e, registerConsoleShortcuts as f, createViteLogger as g, createDebugger as h, isValidApiRequest as i, cliApi as j, resolveFsAllow as r, startVitest as s };
+export { FilesNotFoundError as F, GitNotFoundError as G, ThreadsPoolWorker as T, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, createMethodsRPC as d, escapeTestName as e, ForksPoolWorker as f, getFilePoolName as g, TypecheckPoolWorker as h, isValidApiRequest as i, VmForksPoolWorker as j, VmThreadsPoolWorker as k, experimental_getRunnerTask as l, registerConsoleShortcuts as m, createViteLogger as n, createDebugger as o, cliApi as p, resolveFsAllow as r, startVitest as s };