vitest 4.0.0-beta.18 → 4.0.0-beta.19

package/dist/chunks/{cli-api.xhe4uqTX.js → cli-api.BjHteKX0.js}

@@ -1,18 +1,19 @@
-import fs, { promises, existsSync, readFileSync, statSync, readdirSync, 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, toArray, cleanUrl, deepMerge, nanoid, deepClone, isPrimitive, notNullish } from '@vitest/utils/helpers';
+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, isTestCase } 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.DYnuYoJK.js';
+import { v as version$1 } from './cac.DCrQhweU.js';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { p as parse, s as stringify, b as TraceMap, o as originalPositionFor, c as ancestor, d as createDefinesScript, e as convertTasksToEvents } from './typechecker.DsKAhua5.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,27 +26,32 @@ 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 { d as createDebugger, h as hash, e as createFetchModuleFunction, n as normalizeResolvedIdToUrl, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, f as isBrowserEnabled, r as resolveConfig, j as groupBy, k as getCoverageProvider, l as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.Ds84cgzV.js';
+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 { VitestModuleEvaluator } from '#module-evaluator';
 import { ModuleRunner } from 'vite/module-runner';
+import { writeFile, rename, stat, unlink, readFile, rm, mkdir, copyFile } from 'node:fs/promises';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
 import { highlight } from '@vitest/utils/highlight';
-import { p as printError, f as formatProjectName, w as withLabel, e as errorBanner, d as divider, h as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.D2gVI9Ck.js';
 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, writeFile, 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 { 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.eEkl9h8v.js';
+import { a as BenchmarkReportsMap } from './index.BdSLhLDZ.js';
 import assert$1 from 'node:assert';
 import { serializeValue } from '@vitest/utils/serialize';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
@@ -5108,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);
@@ -5133,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;
 				}
@@ -5229,11 +5235,39 @@ var setup$1 = /*#__PURE__*/Object.freeze({
   setup: setup
 });
 
-const debug = createDebugger("vitest:ast-collect-info"), verbose = createDebugger("vitest:ast-collect-verbose");
+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$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;
@@ -5297,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,
@@ -5381,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,
@@ -5437,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 });
@@ -5602,6 +5636,189 @@ class VitestCache {
 	}
 }
 
+const created = /* @__PURE__ */ new Set(), promises = /* @__PURE__ */ new Map();
+function createFetchModuleFunction(resolver, cacheFs = false, tmpDir = join(tmpdir(), nanoid()), dump) {
+	const cachedFsResults = /* @__PURE__ */ new Map();
+	return async (url, importer, environment, options) => {
+		// We are copy pasting Vite's externalization logic from `fetchModule` because
+		// we instead rely on our own `shouldExternalize` method because Vite
+		// doesn't support `resolve.external` in non SSR environments (jsdom/happy-dom)
+		if (url.startsWith("data:")) return {
+			externalize: url,
+			type: "builtin"
+		};
+		if (url === "/@vite/client" || url === "@vite/client")
+ // this will be stubbed
+		return {
+			externalize: "/@vite/client",
+			type: "module"
+		};
+		const isFileUrl = url.startsWith("file://");
+		if (isExternalUrl(url) && !isFileUrl) return {
+			externalize: url,
+			type: "network"
+		};
+		// Vite does the same in `fetchModule`, but we want to externalize modules ourselves,
+		// so we do this first to resolve the module and check its `id`. The next call of
+		// `ensureEntryFromUrl` inside `fetchModule` is cached and should take no time
+		// This also makes it so externalized modules are inside the module graph.
+		const moduleGraphModule = await environment.moduleGraph.ensureEntryFromUrl(unwrapId(url)), cached = !!moduleGraphModule.transformResult;
+		// if url is already cached, we can just confirm it's also cached on the server
+		if (options?.cached && cached) return { cache: true };
+		if (moduleGraphModule.id) {
+			const externalize = await resolver.shouldExternalize(moduleGraphModule.id);
+			if (externalize) return {
+				externalize,
+				type: "module"
+			};
+		}
+		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;
+		// to avoid serialising large chunks of code,
+		// we store them in a tmp file and read in the test thread
+		if (cachedFsResults.has(result.id)) return getCachedResult(result, cachedFsResults);
+		const dir = join(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), cachedFsResults.set(result.id, tmp), getCachedResult(result, cachedFsResults)) : (promises.set(tmp, atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp))), await promises.get(tmp), cachedFsResults.set(result.id, tmp), getCachedResult(result, cachedFsResults));
+	};
+}
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+const MODULE_RUNNER_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-generated";
+function processResultSource(environment, result) {
+	if (!("code" in result)) return result;
+	const node = environment.moduleGraph.getModuleById(result.id);
+	if (node?.transformResult)
+ // this also overrides node.transformResult.code which is also what the module
+	// runner does under the hood by default (we disable source maps inlining)
+	inlineSourceMap(node.transformResult);
+	return {
+		...result,
+		code: node?.transformResult?.code || result.code
+	};
+}
+const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, "gm");
+// we have to inline the source map ourselves, because
+// - we don't need //# sourceURL since we are running code in VM
+//   - important in stack traces and the V8 coverage
+// - we need to inject an empty line for --inspect-brk
+function inlineSourceMap(result) {
+	const map = result.map;
+	let code = result.code;
+	if (!map || !("version" in map) || code.includes(MODULE_RUNNER_SOURCEMAPPING_SOURCE)) return result;
+	if (OTHER_SOURCE_MAP_REGEXP.lastIndex = 0, OTHER_SOURCE_MAP_REGEXP.test(code)) code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");
+	const sourceMap = { ...map };
+	// If the first line is not present on source maps, add simple 1:1 mapping ([0,0,0,0], [1,0,0,0])
+	// so that debuggers can be set to break on first line
+	if (sourceMap.mappings[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, cachedFsResults) {
+	const tmp = cachedFsResults.get(result.id);
+	if (!tmp) throw new Error(`The cached result was returned too early for ${result.id}.`);
+	return {
+		cached: true,
+		file: result.file,
+		id: result.id,
+		tmp,
+		url: result.url,
+		invalidate: result.invalidate
+	};
+}
+// serialize rollup error on server to preserve details as a test error
+function handleRollupError(e) {
+	throw e instanceof Error && ("plugin" in e || "frame" in e || "id" in e) ? {
+		name: e.name,
+		message: e.message,
+		stack: e.stack,
+		cause: e.cause,
+		__vitest_rollup_error__: {
+			plugin: e.plugin,
+			id: e.id,
+			loc: e.loc,
+			frame: e.frame
+		}
+	} : e;
+}
+/**
+* Performs an atomic write operation using the write-then-rename pattern.
+*
+* Why we need this:
+* - Ensures file integrity by never leaving partially written files on disk
+* - Prevents other processes from reading incomplete data during writes
+* - Particularly important for test files where incomplete writes could cause test failures
+*
+* The implementation writes to a temporary file first, then renames it to the target path.
+* This rename operation is atomic on most filesystems (including POSIX-compliant ones),
+* guaranteeing that other processes will only ever see the complete file.
+*
+* Added in https://github.com/vitest-dev/vitest/pull/7531
+*/
+async function atomicWriteFile(realFilePath, data) {
+	const dir = dirname(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);
@@ -5808,7 +6025,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();
@@ -5855,12 +6073,1070 @@ class VitestPackageInstaller {
 	}
 }
 
+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 groupFilesByEnv(files) {
+	const filesWithEnv = await Promise.all(files.map(async ({ moduleId: filepath, project, testLines }) => {
+		const code = await promises$1.readFile(filepath, "utf-8");
+		// 1. Check for control comments in the file
+		let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
+		// 2. 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");
+		return {
+			file: {
+				filepath,
+				testLocations: testLines
+			},
+			project,
+			environment: {
+				name: env,
+				options: envOptions ? { [env === "happy-dom" ? "happyDOM" : env]: envOptions } : null
+			}
+		};
+	}));
+	return groupBy(filesWithEnv, ({ environment }) => environment.name);
+}
+
+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 });
+	project.vitest.state.metadata[project.name].dumpDir = project.config.dumpDir;
+	const fetch = createFetchModuleFunction(project._resolver, cacheFs, project.tmpDir, {
+		dumpFolder: project.config.dumpDir,
+		readFromDump: project.config.server.debug?.load ?? process.env.VITEST_DEBUG_LOAD_DUMP != null
+	});
+	return {
+		async fetch(url, importer, environmentName, options) {
+			const environment = project.vite.environments[environmentName];
+			if (!environment) throw new Error(`The environment ${environmentName} was not defined in the Vite config.`);
+			const start = performance.now();
+			return await fetch(url, importer, environment, 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 stopped, cannot restart
+			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);
+				// Wait for 'started' message with timeout
+				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 never started, just mark as stopped
+			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";
+	execArgv;
+	env;
+	cacheFs = true;
+	entrypoint;
+	_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";
+	execArgv;
+	env;
+	entrypoint;
+	_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";
+	execArgv;
+	env;
+	project;
+	_eventEmitter = new EventEmitter$1();
+	constructor(options) {
+		this.execArgv = options.execArgv, this.env = options.env, this.project = options.project;
+	}
+	async start() {
+		// noop, onMessage handles it
+	}
+	async stop() {
+		// noop, onMessage handles it
+	}
+	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,
+			execArgv: [...options.execArgv, "--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,
+			execArgv: [...options.execArgv, "--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.execArgv.every((arg, index) => task.execArgv[index] === arg) && isEnvEqual(runner.worker.env, task.env);
+}
+function isEnvEqual(a, b) {
+	const keys = Object.keys(a);
+	return keys.length === Object.keys(b).length ? keys.every((key) => a[key] === b[key]) : false;
+}
+
+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), 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 byEnv = await groupFilesByEnv(specs), env = Object.values(byEnv)[0][0];
+				taskGroup.push({
+					context: {
+						pool,
+						config: project.serializedConfig,
+						files: specs.map((spec) => ({
+							filepath: spec.moduleId,
+							testLocations: spec.testLines
+						})),
+						invalidates,
+						environment: env.environment,
+						projectName: project.name,
+						providedContext: project.getProvidedContext(),
+						workerId: workerId++
+					},
+					project,
+					env: options.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 = {};
+	for (const project in 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]);
+	}), typechecks) {
+		const order = Math.max(0, ...groups.keys()) + 1;
+		groups[order] ||= {
+			specs: [],
+			maxWorkers: resolveMaxWorkers(typechecks[project][0].project)
+		}, groups[order].specs.push(typechecks[project]);
+	}
+	if (sequential.specs.length) groups.push(sequential);
+	return groups;
+}
+
 function serializeConfig(project) {
-	const { config, globalConfig } = project, viteConfig = project._vite?.config, optimizer = config.deps?.optimizer || {}, poolOptions = config.poolOptions, isolate = viteConfig?.test?.isolate;
+	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,
@@ -5900,18 +7176,6 @@ function serializeConfig(project) {
 			};
 		})(config.coverage),
 		fakeTimers: config.fakeTimers,
-		poolOptions: {
-			forks: {
-				singleFork: poolOptions?.forks?.singleFork ?? globalConfig.poolOptions?.forks?.singleFork ?? false,
-				isolate: poolOptions?.forks?.isolate ?? isolate ?? globalConfig.poolOptions?.forks?.isolate ?? true
-			},
-			threads: {
-				singleThread: poolOptions?.threads?.singleThread ?? globalConfig.poolOptions?.threads?.singleThread ?? false,
-				isolate: poolOptions?.threads?.isolate ?? isolate ?? globalConfig.poolOptions?.threads?.isolate ?? true
-			},
-			vmThreads: { singleThread: poolOptions?.vmThreads?.singleThread ?? globalConfig.poolOptions?.vmThreads?.singleThread ?? false },
-			vmForks: { singleFork: poolOptions?.vmForks?.singleFork ?? globalConfig.poolOptions?.vmForks?.singleFork ?? false }
-		},
 		deps: {
 			web: config.deps.web || {},
 			optimizer: Object.entries(optimizer).reduce((acc, [name, option]) => {
@@ -7018,7 +8282,7 @@ async function isValidNodeImport(id) {
 	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;
@@ -7274,7 +8538,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;
@@ -8203,7 +9467,6 @@ 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;
@@ -8238,12 +9501,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);
 	}
@@ -8328,7 +9585,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)));
 	}
 }
 
@@ -8838,6 +10100,7 @@ class TestRun {
 	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";
@@ -9652,7 +10915,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`);
@@ -9782,10 +11045,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
 					}
@@ -10254,4 +11513,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, cliApi as h, isValidApiRequest as i, 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 };