vitest 4.0.0-beta.8 → 4.0.0

package/dist/chunks/{coverage.DarITf6U.js → coverage.FU3w4IrQ.js}

@@ -1,58 +1,26 @@
-import fs, { statSync, realpathSync, promises as promises$1, mkdirSync, existsSync, readdirSync, writeFileSync } from 'node:fs';
-import path, { win32, dirname, join, resolve } from 'node:path';
-import { isExternalUrl, unwrapId, nanoid, withTrailingSlash as withTrailingSlash$1, cleanUrl, wrapId, createDefer, slash, shuffle, toArray } from '@vitest/utils';
-import { isAbsolute, join as join$1, dirname as dirname$1, resolve as resolve$1, relative, normalize } from 'pathe';
+import fs, { statSync, realpathSync, existsSync, promises, readdirSync, writeFileSync } from 'node:fs';
+import path, { win32, dirname, join } from 'node:path';
+import { slash, shuffle, toArray, cleanUrl } from '@vitest/utils/helpers';
+import { isAbsolute, resolve, relative, normalize } from 'pathe';
 import pm from 'picomatch';
 import { glob } from 'tinyglobby';
 import c from 'tinyrainbow';
-import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.CXFFjsi8.js';
+import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.BOqNVLsY.js';
 import crypto from 'node:crypto';
 import { builtinModules, createRequire } from 'node:module';
 import process$1 from 'node:process';
-import fs$1, { writeFile, rename, stat, unlink } from 'node:fs/promises';
+import fs$1 from 'node:fs/promises';
 import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
 import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
-import { fetchModule, version, mergeConfig } from 'vite';
+import { mergeConfig } from 'vite';
 import { c as configFiles, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.D_Q9UYh-.js';
-import { a as isWindows } from './env.D4Lgay0q.js';
-import * as nodeos from 'node:os';
-import nodeos__default, { tmpdir } from 'node:os';
-import { isatty } from 'node:tty';
-import EventEmitter from 'node:events';
-import { c as createBirpc } from './index.Bgo3tNWt.js';
-import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.DSo_maXz.js';
-import { MessageChannel } from 'node:worker_threads';
-import { hasFailed } from '@vitest/runner/utils';
-import { rootDir } from '../path.js';
+import './env.D4Lgay0q.js';
+import nodeos__default from 'node:os';
 import { isCI, provider } from 'std-env';
 import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 
-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.startsWith("!");
-	if (negated) pattern = pattern.slice(1);
-	let regexp = `${pattern.split("*").map(escapeRegExp).join(".*")}$`;
-	if (negated) regexp = `(?!${regexp})`;
-	return new RegExp(`^${regexp}`, "i");
-}
-
 const hash = crypto.hash ?? ((algorithm, data, outputEncoding) => crypto.createHash(algorithm).update(data).digest(outputEncoding));
 
 const JOIN_LEADING_SLASH_RE = /^\.?\//;
@@ -2014,7 +1982,7 @@ function normalizeid(id) {
   if (typeof id !== "string") {
     id = id.toString();
   }
-  if (/(node|data|http|https|file):/.test(id)) {
+  if (/(?:node|data|http|https|file):/.test(id)) {
     return id;
   }
   if (BUILTIN_MODULES.has(id)) {
@@ -2048,7 +2016,7 @@ function _resolve$1(id, options = {}) {
       throw new TypeError("input must be a `string` or `URL`");
     }
   }
-  if (/(node|data|http|https):/.test(id)) {
+  if (/(?:node|data|http|https):/.test(id)) {
     return id;
   }
   if (BUILTIN_MODULES.has(id)) {
@@ -2386,970 +2354,6 @@ function getWorkersCountByPercentage(percent) {
 	return Math.max(1, Math.min(maxWorkersCount, workersCountByPercentage));
 }
 
-const envsOrder = [
-	"node",
-	"jsdom",
-	"happy-dom",
-	"edge-runtime"
-];
-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"), envKey = env === "happy-dom" ? "happyDOM" : env, environment = {
-			name: env,
-			options: envOptions ? { [envKey]: envOptions } : null
-		};
-		return {
-			file: {
-				filepath,
-				testLocations: testLines
-			},
-			project,
-			environment
-		};
-	}));
-	return groupBy(filesWithEnv, ({ environment }) => environment.name);
-}
-
-const created = /* @__PURE__ */ new Set(), promises = /* @__PURE__ */ new Map();
-function createFetchModuleFunction(resolver, cacheFs = false, tmpDir = join$1(tmpdir(), nanoid())) {
-	const cachedFsResults = /* @__PURE__ */ new Map();
-	return async (url, importer, environment, options) => {
-		// We are copy pasting Vite's externalization logic from `fetchModule` because
-		// we instead rely on our own `shouldExternalize` method because Vite
-		// doesn't support `resolve.external` in non SSR environments (jsdom/happy-dom)
-		if (url.startsWith("data:")) return {
-			externalize: url,
-			type: "builtin"
-		};
-		if (url === "/@vite/client" || url === "@vite/client")
- // this will be stubbed
-		return {
-			externalize: "/@vite/client",
-			type: "module"
-		};
-		const isFileUrl = url.startsWith("file://");
-		if (isExternalUrl(url) && !isFileUrl) return {
-			externalize: url,
-			type: "network"
-		};
-		// Vite does the same in `fetchModule`, but we want to externalize modules ourselves,
-		// so we do this first to resolve the module and check its `id`. The next call of
-		// `ensureEntryFromUrl` inside `fetchModule` is cached and should take no time
-		// This also makes it so externalized modules are inside the module graph.
-		const moduleGraphModule = await environment.moduleGraph.ensureEntryFromUrl(unwrapId(url)), cached = !!moduleGraphModule.transformResult;
-		// if url is already cached, we can just confirm it's also cached on the server
-		if (options?.cached && cached) return { cache: true };
-		if (moduleGraphModule.id) {
-			const externalize = await resolver.shouldExternalize(moduleGraphModule.id);
-			if (externalize) return {
-				externalize,
-				type: "module"
-			};
-		}
-		const moduleRunnerModule = await fetchModule(environment, url, importer, {
-			...options,
-			inlineSourceMap: false
-		}).catch(handleRollupError), result = processResultSource(environment, moduleRunnerModule);
-		if (!cacheFs || !("code" in result)) return result;
-		const code = result.code;
-		// to avoid serialising large chunks of code,
-		// we store them in a tmp file and read in the test thread
-		if (cachedFsResults.has(result.id)) return getCachedResult(result, cachedFsResults);
-		const dir = join$1(tmpDir, environment.name), name = hash("sha1", result.id, "hex"), tmp = join$1(dir, name);
-		if (!created.has(dir)) mkdirSync(dir, { recursive: true }), created.add(dir);
-		return promises.has(tmp) ? (await promises.get(tmp), cachedFsResults.set(result.id, tmp), getCachedResult(result, cachedFsResults)) : (promises.set(tmp, atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp))), await promises.get(tmp), cachedFsResults.set(result.id, tmp), getCachedResult(result, cachedFsResults));
-	};
-}
-let SOURCEMAPPING_URL = "sourceMa";
-SOURCEMAPPING_URL += "ppingURL";
-const MODULE_RUNNER_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-generated";
-function processResultSource(environment, result) {
-	if (!("code" in result)) return result;
-	const node = environment.moduleGraph.getModuleById(result.id);
-	if (node?.transformResult)
- // this also overrides node.transformResult.code which is also what the module
-	// runner does under the hood by default (we disable source maps inlining)
-	inlineSourceMap(node.transformResult);
-	return {
-		...result,
-		code: node?.transformResult?.code || result.code
-	};
-}
-const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, "gm");
-// we have to inline the source map ourselves, because
-// - we don't need //# sourceURL since we are running code in VM
-//   - important in stack traces and the V8 coverage
-// - we need to inject an empty line for --inspect-brk
-function inlineSourceMap(result) {
-	const map = result.map;
-	let code = result.code;
-	if (!map || !("version" in map) || code.includes(MODULE_RUNNER_SOURCEMAPPING_SOURCE)) return result;
-	if (OTHER_SOURCE_MAP_REGEXP.lastIndex = 0, OTHER_SOURCE_MAP_REGEXP.test(code)) code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");
-	const sourceMap = { ...map };
-	// If the first line is not present on source maps, add simple 1:1 mapping ([0,0,0,0], [1,0,0,0])
-	// so that debuggers can be set to break on first line
-	if (sourceMap.mappings.startsWith(";")) sourceMap.mappings = `AAAA,CAAA${sourceMap.mappings}`;
-	return result.code = `${code.trimEnd()}\n${MODULE_RUNNER_SOURCEMAPPING_SOURCE}\n//# ${SOURCEMAPPING_URL}=${genSourceMapUrl(sourceMap)}\n`, result;
-}
-function genSourceMapUrl(map) {
-	if (typeof map !== "string") map = JSON.stringify(map);
-	return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
-}
-function getCachedResult(result, cachedFsResults) {
-	const tmp = cachedFsResults.get(result.id);
-	if (!tmp) throw new Error(`The cached result was returned too early for ${result.id}.`);
-	return {
-		cached: true,
-		file: result.file,
-		id: result.id,
-		tmp,
-		url: result.url,
-		invalidate: result.invalidate
-	};
-}
-// serialize rollup error on server to preserve details as a test error
-function handleRollupError(e) {
-	throw e instanceof Error && ("plugin" in e || "frame" in e || "id" in e) ? {
-		name: e.name,
-		message: e.message,
-		stack: e.stack,
-		cause: e.cause,
-		__vitest_rollup_error__: {
-			plugin: e.plugin,
-			id: e.id,
-			loc: e.loc,
-			frame: e.frame
-		}
-	} : e;
-}
-/**
-* Performs an atomic write operation using the write-then-rename pattern.
-*
-* Why we need this:
-* - Ensures file integrity by never leaving partially written files on disk
-* - Prevents other processes from reading incomplete data during writes
-* - Particularly important for test files where incomplete writes could cause test failures
-*
-* The implementation writes to a temporary file first, then renames it to the target path.
-* This rename operation is atomic on most filesystems (including POSIX-compliant ones),
-* guaranteeing that other processes will only ever see the complete file.
-*
-* Added in https://github.com/vitest-dev/vitest/pull/7531
-*/
-async function atomicWriteFile(realFilePath, data) {
-	const dir = dirname$1(realFilePath), tmpFilePath = join$1(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-	try {
-		await writeFile(tmpFilePath, data, "utf-8"), await rename(tmpFilePath, realFilePath);
-	} finally {
-		try {
-			if (await stat(tmpFilePath)) await unlink(tmpFilePath);
-		} catch {}
-	}
-}
-
-// this is copy pasted from vite
-function normalizeResolvedIdToUrl(environment, resolvedId) {
-	const root = environment.config.root, depsOptimizer = environment.depsOptimizer;
-	let url;
-	// normalize all imports into resolved URLs
-	// e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
-	if (resolvedId.startsWith(withTrailingSlash$1(root)))
- // in root: infer short absolute path from root
-	url = resolvedId.slice(root.length);
-	else if (depsOptimizer?.isOptimizedDepFile(resolvedId) || resolvedId !== "/@react-refresh" && path.isAbsolute(resolvedId) && existsSync(cleanUrl(resolvedId)))
- // an optimized deps may not yet exists in the filesystem, or
-	// a regular file exists but is out of root: rewrite to absolute /@fs/ paths
-	url = path.posix.join("/@fs/", resolvedId);
-	else url = resolvedId;
-	// if the resolved id is not a valid browser import specifier,
-	// prefix it to make it valid. We will strip this before feeding it
-	// back into the transform pipeline
-	if (url[0] !== "." && url[0] !== "/") url = wrapId(resolvedId);
-	return url;
-}
-
-function createMethodsRPC(project, options = {}) {
-	const ctx = project.vitest, cacheFs = options.cacheFs ?? false, fetch = createFetchModuleFunction(project._resolver, cacheFs, project.tmpDir);
-	return {
-		async fetch(url, importer, environmentName, options) {
-			const environment = project.vite.environments[environmentName];
-			if (!environment) throw new Error(`The environment ${environmentName} was not defined in the Vite config.`);
-			const start = performance.now();
-			try {
-				return await fetch(url, importer, environment, options);
-			} finally {
-				project.vitest.state.transformTime += performance.now() - start;
-			}
-		},
-		async resolve(id, importer, environmentName) {
-			const environment = project.vite.environments[environmentName];
-			if (!environment) throw new Error(`The environment ${environmentName} was not defined in the Vite config.`);
-			const resolved = await environment.pluginContainer.resolveId(id, importer);
-			return resolved ? {
-				file: cleanUrl(resolved.id),
-				url: normalizeResolvedIdToUrl(environment, resolved.id),
-				id: resolved.id
-			} : null;
-		},
-		snapshotSaved(snapshot) {
-			ctx.snapshot.add(snapshot);
-		},
-		resolveSnapshotPath(testPath) {
-			return ctx.snapshot.resolvePath(testPath, { config: project.serializedConfig });
-		},
-		async transform(id) {
-			const environment = project.vite.environments.__vitest_vm__;
-			if (!environment) throw new Error(`The VM environment was not defined in the Vite config. This is a bug in Vitest. Please, open a new issue with reproduction.`);
-			const url = normalizeResolvedIdToUrl(environment, fileURLToPath$1(id)), result = await environment.transformRequest(url).catch(handleRollupError);
-			return { code: result?.code };
-		},
-		async onQueued(file) {
-			if (options.collect) ctx.state.collectFiles(project, [file]);
-			else await ctx._testRun.enqueued(project, file);
-		},
-		async onCollected(files) {
-			if (options.collect) ctx.state.collectFiles(project, files);
-			else await ctx._testRun.collected(project, files);
-		},
-		onAfterSuiteRun(meta) {
-			ctx.coverageProvider?.onAfterSuiteRun(meta);
-		},
-		async onTaskAnnotate(testId, annotation) {
-			return ctx._testRun.annotate(testId, annotation);
-		},
-		async onTaskUpdate(packs, events) {
-			if (options.collect) ctx.state.updateTasks(packs);
-			else await ctx._testRun.updated(packs, events);
-		},
-		async onUserConsoleLog(log) {
-			if (options.collect) ctx.state.updateUserLog(log);
-			else await ctx._testRun.log(log);
-		},
-		onUnhandledError(err, type) {
-			ctx.state.catchError(err, type);
-		},
-		onCancel(reason) {
-			ctx.cancelCurrentRun(reason);
-		},
-		getCountOfFailedTests() {
-			return ctx.state.getCountOfFailedTests();
-		}
-	};
-}
-
-function createChildProcessChannel$1(project, collect = false) {
-	const emitter = new EventEmitter(), events = {
-		message: "message",
-		response: "response"
-	}, rpc = createBirpc(createMethodsRPC(project, {
-		cacheFs: true,
-		collect
-	}), {
-		eventNames: ["onCancel"],
-		serialize: v8.serialize,
-		deserialize: (v) => {
-			try {
-				return v8.deserialize(Buffer.from(v));
-			} catch (error) {
-				let stringified = "";
-				try {
-					stringified = `\nReceived value: ${JSON.stringify(v)}`;
-				} 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 });
-			}
-		},
-		post(v) {
-			emitter.emit(events.message, v);
-		},
-		on(fn) {
-			emitter.on(events.response, fn);
-		},
-		timeout: -1
-	});
-	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	const channel = {
-		onMessage: (callback) => emitter.on(events.message, callback),
-		postMessage: (message) => emitter.emit(events.response, message),
-		onClose: () => {
-			emitter.removeAllListeners(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
-		}
-	};
-	return channel;
-}
-function createForksPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.forks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minForks ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/forks.js"), options = {
-		runtime: "child_process",
-		filename: resolve(vitest.distPath, "worker.js"),
-		teardown: "teardown",
-		maxThreads,
-		minThreads,
-		env,
-		execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
-		terminateTimeout: vitest.config.teardownTimeout,
-		concurrentTasksPerWorker: 1
-	}, isolated = poolOptions.isolate ?? true;
-	if (isolated) options.isolateWorkers = true;
-	if (poolOptions.singleFork || !vitest.config.fileParallelism) options.maxThreads = 1, options.minThreads = 1;
-	const pool = new Tinypool(options), runWithFiles = (name) => {
-		let id = 0;
-		async function runFiles(project, config, files, environment, invalidates = []) {
-			const paths = files.map((f) => f.filepath);
-			vitest.state.clearFiles(project, paths);
-			const channel = createChildProcessChannel$1(project, name === "collect"), workerId = ++id, data = {
-				pool: "forks",
-				worker,
-				config,
-				files,
-				invalidates,
-				environment,
-				workerId,
-				projectName: project.name,
-				providedContext: project.getProvidedContext()
-			};
-			try {
-				await pool.run(data, {
-					name,
-					channel
-				});
-			} catch (error) {
-				// Worker got stuck and won't terminate - this may cause process to hang
-				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) vitest.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}.`);
-				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
-				else throw error;
-			}
-		}
-		return async (specs, invalidates) => {
-			// Cancel pending tasks from pool when possible
-			vitest.onCancel(() => pool.cancelPendingTasks());
-			const configs = /* @__PURE__ */ new WeakMap(), getConfig = (project) => {
-				if (configs.has(project)) return configs.get(project);
-				const _config = project.serializedConfig, config = wrapSerializableConfig(_config);
-				return configs.set(project, config), config;
-			}, singleFork = specs.filter((spec) => spec.project.config.poolOptions?.forks?.singleFork), multipleForks = specs.filter((spec) => !spec.project.config.poolOptions?.forks?.singleFork);
-			if (multipleForks.length) {
-				const filesByEnv = await groupFilesByEnv(multipleForks), files = Object.values(filesByEnv).flat(), results = [];
-				if (isolated) results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
-				else {
-					// When isolation is disabled, we still need to isolate environments and workspace projects from each other.
-					// Tasks are still running parallel but environments are isolated between tasks.
-					const grouped = groupBy(files, ({ project, environment }) => project.name + environment.name + JSON.stringify(environment.options));
-					for (const group of Object.values(grouped)) results.push(...await Promise.allSettled(group.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)))), await new Promise((resolve) => pool.queueSize === 0 ? resolve() : pool.once("drain", resolve)), await pool.recycleWorkers();
-				}
-				const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-				if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
-			}
-			if (singleFork.length) {
-				const filesByEnv = await groupFilesByEnv(singleFork), envs = envsOrder.concat(Object.keys(filesByEnv).filter((env) => !envsOrder.includes(env)));
-				for (const env of envs) {
-					const files = filesByEnv[env];
-					if (!files?.length) continue;
-					const filesByOptions = groupBy(files, ({ project, environment }) => project.name + JSON.stringify(environment.options));
-					for (const files of Object.values(filesByOptions)) {
-						// Always run environments isolated between each other
-						await pool.recycleWorkers();
-						const filenames = files.map((f) => f.file);
-						await runFiles(files[0].project, getConfig(files[0].project), filenames, files[0].environment, invalidates);
-					}
-				}
-			}
-		};
-	};
-	return {
-		name: "forks",
-		runTests: runWithFiles("run"),
-		collectTests: runWithFiles("collect"),
-		close: () => pool.destroy()
-	};
-}
-
-function createWorkerChannel$1(project, collect) {
-	const channel = new MessageChannel(), port = channel.port2, workerPort = channel.port1, rpc = createBirpc(createMethodsRPC(project, { collect }), {
-		eventNames: ["onCancel"],
-		post(v) {
-			port.postMessage(v);
-		},
-		on(fn) {
-			port.on("message", fn);
-		},
-		timeout: -1
-	});
-	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	const onClose = () => {
-		port.close(), workerPort.close(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
-	};
-	return {
-		workerPort,
-		port,
-		onClose
-	};
-}
-function createThreadsPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.threads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minThreads ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/threads.js"), options = {
-		filename: resolve(vitest.distPath, "worker.js"),
-		teardown: "teardown",
-		useAtomics: poolOptions.useAtomics ?? false,
-		maxThreads,
-		minThreads,
-		env,
-		execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
-		terminateTimeout: vitest.config.teardownTimeout,
-		concurrentTasksPerWorker: 1
-	}, isolated = poolOptions.isolate ?? true;
-	if (isolated) options.isolateWorkers = true;
-	if (poolOptions.singleThread || !vitest.config.fileParallelism) options.maxThreads = 1, options.minThreads = 1;
-	const pool = new Tinypool$1(options), runWithFiles = (name) => {
-		let id = 0;
-		async function runFiles(project, config, files, environment, invalidates = []) {
-			const paths = files.map((f) => f.filepath);
-			vitest.state.clearFiles(project, paths);
-			const { workerPort, onClose } = createWorkerChannel$1(project, name === "collect"), workerId = ++id, data = {
-				pool: "threads",
-				worker,
-				port: workerPort,
-				config,
-				files,
-				invalidates,
-				environment,
-				workerId,
-				projectName: project.name,
-				providedContext: project.getProvidedContext()
-			};
-			try {
-				await pool.run(data, {
-					transferList: [workerPort],
-					name,
-					channel: { onClose }
-				});
-			} catch (error) {
-				// Worker got stuck and won't terminate - this may cause process to hang
-				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) vitest.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}. \nSee https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`);
-				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
-				else throw error;
-			}
-		}
-		return async (specs, invalidates) => {
-			// Cancel pending tasks from pool when possible
-			vitest.onCancel(() => pool.cancelPendingTasks());
-			const configs = /* @__PURE__ */ new WeakMap(), getConfig = (project) => {
-				if (configs.has(project)) return configs.get(project);
-				const config = project.serializedConfig;
-				return configs.set(project, config), config;
-			}, singleThreads = specs.filter((spec) => spec.project.config.poolOptions?.threads?.singleThread), multipleThreads = specs.filter((spec) => !spec.project.config.poolOptions?.threads?.singleThread);
-			if (multipleThreads.length) {
-				const filesByEnv = await groupFilesByEnv(multipleThreads), files = Object.values(filesByEnv).flat(), results = [];
-				if (isolated) results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
-				else {
-					// When isolation is disabled, we still need to isolate environments and workspace projects from each other.
-					// Tasks are still running parallel but environments are isolated between tasks.
-					const grouped = groupBy(files, ({ project, environment }) => project.name + environment.name + JSON.stringify(environment.options));
-					for (const group of Object.values(grouped)) results.push(...await Promise.allSettled(group.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)))), await new Promise((resolve) => pool.queueSize === 0 ? resolve() : pool.once("drain", resolve)), await pool.recycleWorkers();
-				}
-				const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-				if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
-			}
-			if (singleThreads.length) {
-				const filesByEnv = await groupFilesByEnv(singleThreads), envs = envsOrder.concat(Object.keys(filesByEnv).filter((env) => !envsOrder.includes(env)));
-				for (const env of envs) {
-					const files = filesByEnv[env];
-					if (!files?.length) continue;
-					const filesByOptions = groupBy(files, ({ project, environment }) => project.name + JSON.stringify(environment.options));
-					for (const files of Object.values(filesByOptions)) {
-						// Always run environments isolated between each other
-						await pool.recycleWorkers();
-						const filenames = files.map((f) => f.file);
-						await runFiles(files[0].project, getConfig(files[0].project), filenames, files[0].environment, invalidates);
-					}
-				}
-			}
-		};
-	};
-	return {
-		name: "threads",
-		runTests: runWithFiles("run"),
-		collectTests: runWithFiles("collect"),
-		close: () => pool.destroy()
-	};
-}
-
-function createTypecheckPool(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"));
-		const processError = !hasFailed(files) && !sourceErrors.length && checker.getExitCode();
-		if (processError) {
-			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) {
-		const specsByProject = groupBy(specs, (spec) => spec.project.name);
-		for (const name in specsByProject) {
-			const project = specsByProject[name][0].project, files = specsByProject[name].map((spec) => spec.moduleId), checker = await createWorkspaceTypechecker(project, files);
-			checker.setFiles(files), await checker.collectTests();
-			const testFiles = checker.getTestFiles();
-			vitest.state.collectFiles(project, testFiles);
-		}
-	}
-	async function runTests(specs) {
-		const specsByProject = groupBy(specs, (spec) => spec.project.name), promises = [];
-		for (const name in specsByProject) {
-			const project = specsByProject[name][0].project, files = specsByProject[name].map((spec) => spec.moduleId), promise = createDefer(), _p = new Promise((resolve) => {
-				const _i = setInterval(() => {
-					if (!project.typechecker || rerunTriggered.has(project)) resolve(true), clearInterval(_i);
-				});
-				setTimeout(() => {
-					resolve(false), clearInterval(_i);
-				}, 500).unref();
-			}), triggered = await _p;
-			if (project.typechecker && !triggered) {
-				const testFiles = project.typechecker.getTestFiles();
-				for (const file of testFiles) await vitest._testRun.enqueued(project, file);
-				await vitest._testRun.collected(project, testFiles), await onParseEnd(project, project.typechecker.getResult());
-				continue;
-			}
-			promises.push(promise), promisesMap.set(project, promise), promises.push(startTypechecker(project, files));
-		}
-		await Promise.all(promises);
-	}
-	return {
-		name: "typescript",
-		runTests,
-		collectTests,
-		async close() {
-			const promises = vitest.projects.map((project) => project.typechecker?.stop());
-			await Promise.all(promises);
-		}
-	};
-}
-
-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, pool) {
-	if (pool === "vmForks") {
-		const opts = config.poolOptions?.vmForks ?? {};
-		if (opts.memoryLimit) return opts.memoryLimit;
-		const workers = opts.maxForks ?? getDefaultThreadsCount(config);
-		return 1 / workers;
-	} else {
-		const opts = config.poolOptions?.vmThreads ?? {};
-		if (opts.memoryLimit) return opts.memoryLimit;
-		const workers = opts.maxThreads ?? getDefaultThreadsCount(config);
-		return 1 / workers;
-	}
-}
-/**
-* 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;
-}
-
-const suppressWarningsPath$1 = resolve(rootDir, "./suppress-warnings.cjs");
-function createChildProcessChannel(project, collect) {
-	const emitter = new EventEmitter(), events = {
-		message: "message",
-		response: "response"
-	}, rpc = createBirpc(createMethodsRPC(project, {
-		cacheFs: true,
-		collect
-	}), {
-		eventNames: ["onCancel"],
-		serialize: v8.serialize,
-		deserialize: (v) => {
-			try {
-				return v8.deserialize(Buffer.from(v));
-			} catch (error) {
-				let stringified = "";
-				try {
-					stringified = `\nReceived value: ${JSON.stringify(v)}`;
-				} 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 });
-			}
-		},
-		post(v) {
-			emitter.emit(events.message, v);
-		},
-		on(fn) {
-			emitter.on(events.response, fn);
-		},
-		timeout: -1
-	});
-	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	const channel = {
-		onMessage: (callback) => emitter.on(events.message, callback),
-		postMessage: (message) => emitter.emit(events.response, message),
-		onClose: () => {
-			emitter.removeAllListeners(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
-		}
-	};
-	return { channel };
-}
-function createVmForksPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.vmForks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.maxForks ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/vmForks.js"), options = {
-		runtime: "child_process",
-		filename: resolve(vitest.distPath, "worker.js"),
-		maxThreads,
-		minThreads,
-		env,
-		execArgv: [
-			"--experimental-import-meta-resolve",
-			"--experimental-vm-modules",
-			"--require",
-			suppressWarningsPath$1,
-			...poolOptions.execArgv ?? [],
-			...execArgv
-		],
-		terminateTimeout: vitest.config.teardownTimeout,
-		concurrentTasksPerWorker: 1,
-		maxMemoryLimitBeforeRecycle: getMemoryLimit$1(vitest.config) || void 0
-	};
-	if (poolOptions.singleFork || !vitest.config.fileParallelism) options.maxThreads = 1, options.minThreads = 1;
-	const pool = new Tinypool$1(options), runWithFiles = (name) => {
-		let id = 0;
-		async function runFiles(project, config, files, environment, invalidates = []) {
-			const paths = files.map((f) => f.filepath);
-			vitest.state.clearFiles(project, paths);
-			const { channel } = createChildProcessChannel(project, name === "collect"), workerId = ++id, data = {
-				pool: "forks",
-				worker,
-				config,
-				files,
-				invalidates,
-				environment,
-				workerId,
-				projectName: project.name,
-				providedContext: project.getProvidedContext()
-			};
-			try {
-				await pool.run(data, {
-					name,
-					channel
-				});
-			} catch (error) {
-				// Worker got stuck and won't terminate - this may cause process to hang
-				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) vitest.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}.`);
-				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
-				else throw error;
-			} finally {
-				channel.onClose();
-			}
-		}
-		return async (specs, invalidates) => {
-			// Cancel pending tasks from pool when possible
-			vitest.onCancel(() => pool.cancelPendingTasks());
-			const configs = /* @__PURE__ */ new Map(), getConfig = (project) => {
-				if (configs.has(project)) return configs.get(project);
-				const _config = project.serializedConfig, config = wrapSerializableConfig(_config);
-				return configs.set(project, config), config;
-			}, filesByEnv = await groupFilesByEnv(specs), promises = Object.values(filesByEnv).flat(), results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))), errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-			if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
-		};
-	};
-	return {
-		name: "vmForks",
-		runTests: runWithFiles("run"),
-		collectTests: runWithFiles("collect"),
-		close: () => pool.destroy()
-	};
-}
-function getMemoryLimit$1(config) {
-	const memory = nodeos.totalmem(), limit = getWorkerMemoryLimit(config, "vmForks");
-	// 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;
-}
-
-const suppressWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
-function createWorkerChannel(project, collect) {
-	const channel = new MessageChannel(), port = channel.port2, workerPort = channel.port1, rpc = createBirpc(createMethodsRPC(project, { collect }), {
-		eventNames: ["onCancel"],
-		post(v) {
-			port.postMessage(v);
-		},
-		on(fn) {
-			port.on("message", fn);
-		},
-		timeout: -1
-	});
-	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	function onClose() {
-		workerPort.close(), port.close(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
-	}
-	return {
-		workerPort,
-		onClose
-	};
-}
-function createVmThreadsPool(vitest, { execArgv, env }) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), poolOptions = vitest.config.poolOptions?.vmThreads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount, minThreads = poolOptions.minThreads ?? vitest.config.minWorkers ?? Math.min(threadsCount, maxThreads), worker = resolve(vitest.distPath, "workers/vmThreads.js"), options = {
-		filename: resolve(vitest.distPath, "worker.js"),
-		useAtomics: poolOptions.useAtomics ?? false,
-		maxThreads,
-		minThreads,
-		env,
-		execArgv: [
-			"--experimental-import-meta-resolve",
-			"--experimental-vm-modules",
-			"--require",
-			suppressWarningsPath,
-			...poolOptions.execArgv ?? [],
-			...execArgv
-		],
-		terminateTimeout: vitest.config.teardownTimeout,
-		concurrentTasksPerWorker: 1,
-		maxMemoryLimitBeforeRecycle: getMemoryLimit(vitest.config) || void 0
-	};
-	if (poolOptions.singleThread || !vitest.config.fileParallelism) options.maxThreads = 1, options.minThreads = 1;
-	const pool = new Tinypool$1(options), runWithFiles = (name) => {
-		let id = 0;
-		async function runFiles(project, config, files, environment, invalidates = []) {
-			const paths = files.map((f) => f.filepath);
-			vitest.state.clearFiles(project, paths);
-			const { workerPort, onClose } = createWorkerChannel(project, name === "collect"), workerId = ++id, data = {
-				pool: "vmThreads",
-				worker,
-				port: workerPort,
-				config,
-				files: paths,
-				invalidates,
-				environment,
-				workerId,
-				projectName: project.name,
-				providedContext: project.getProvidedContext()
-			};
-			try {
-				await pool.run(data, {
-					transferList: [workerPort],
-					name
-				});
-			} catch (error) {
-				// Worker got stuck and won't terminate - this may cause process to hang
-				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) vitest.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}. \nSee https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`);
-				else if (vitest.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) vitest.state.cancelFiles(paths, project);
-				else throw error;
-			} finally {
-				onClose();
-			}
-		}
-		return async (specs, invalidates) => {
-			// Cancel pending tasks from pool when possible
-			vitest.onCancel(() => pool.cancelPendingTasks());
-			const configs = /* @__PURE__ */ new Map(), getConfig = (project) => {
-				if (configs.has(project)) return configs.get(project);
-				const config = project.serializedConfig;
-				return configs.set(project, config), config;
-			}, filesByEnv = await groupFilesByEnv(specs), promises = Object.values(filesByEnv).flat(), results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))), errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-			if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
-		};
-	};
-	return {
-		name: "vmThreads",
-		runTests: runWithFiles("run"),
-		collectTests: runWithFiles("collect"),
-		close: () => pool.destroy()
-	};
-}
-function getMemoryLimit(config) {
-	const memory = nodeos.totalmem(), limit = getWorkerMemoryLimit(config, "vmThreads");
-	// 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;
-}
-
-const builtinPools = [
-	"forks",
-	"threads",
-	"browser",
-	"vmThreads",
-	"vmForks",
-	"typescript"
-];
-function getDefaultPoolName(project) {
-	return project.config.browser.enabled ? "browser" : project.config.pool;
-}
-function getFilePoolName(project) {
-	return getDefaultPoolName(project);
-}
-function createPool(ctx) {
-	const pools = {
-		forks: null,
-		threads: null,
-		browser: null,
-		vmThreads: null,
-		vmForks: null,
-		typescript: null
-	}, viteMajor = Number(version.split(".")[0]), potentialConditions = new Set(viteMajor >= 6 ? ctx.vite.config.ssr.resolve?.conditions ?? [] : [
-		"production",
-		"development",
-		...ctx.vite.config.resolve.conditions
-	]), conditions = [...potentialConditions].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]), execArgv = process.execArgv.filter((execArg) => execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"));
-	async function executeTests(method, files, invalidate) {
-		const options = {
-			execArgv: [...execArgv, ...conditions],
-			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];
-		const poolConcurrentPromises = /* @__PURE__ */ new Map(), customPools = /* @__PURE__ */ new Map();
-		async function resolveCustomPool(filepath) {
-			if (customPools.has(filepath)) return customPools.get(filepath);
-			const pool = await ctx.runner.import(filepath);
-			if (typeof pool.default !== "function") throw new TypeError(`Custom pool "${filepath}" must export a function as default export`);
-			const poolInstance = await pool.default(ctx, options);
-			if (typeof poolInstance?.name !== "string") throw new TypeError(`Custom pool "${filepath}" should return an object with "name" property`);
-			if (typeof poolInstance?.[method] !== "function") throw new TypeError(`Custom pool "${filepath}" should return an object with "${method}" method`);
-			return customPools.set(filepath, poolInstance), poolInstance;
-		}
-		function getConcurrentPool(pool, fn) {
-			if (poolConcurrentPromises.has(pool)) return poolConcurrentPromises.get(pool);
-			const promise = fn().finally(() => {
-				poolConcurrentPromises.delete(pool);
-			});
-			return poolConcurrentPromises.set(pool, promise), promise;
-		}
-		function getCustomPool(pool) {
-			return getConcurrentPool(pool, () => resolveCustomPool(pool));
-		}
-		function getBrowserPool() {
-			return getConcurrentPool("browser", async () => {
-				const { createBrowserPool } = await import('@vitest/browser');
-				return createBrowserPool(ctx);
-			});
-		}
-		const groupedSpecifications = {}, groups = /* @__PURE__ */ new Set(), factories = {
-			vmThreads: () => createVmThreadsPool(ctx, options),
-			vmForks: () => createVmForksPool(ctx, options),
-			threads: () => createThreadsPool(ctx, options),
-			forks: () => createForksPool(ctx, options),
-			typescript: () => createTypecheckPool(ctx)
-		};
-		for (const spec of files) {
-			const group = spec.project.config.sequence.groupOrder ?? 0;
-			groups.add(group), groupedSpecifications[group] ??= [], groupedSpecifications[group].push(spec);
-		}
-		const Sequencer = ctx.config.sequence.sequencer, sequencer = new Sequencer(ctx);
-		async function sortSpecs(specs) {
-			if (ctx.config.shard) {
-				if (!ctx.config.passWithNoTests && ctx.config.shard.count > specs.length) throw new Error(`--shard <count> must be a smaller than count of test files. Resolved ${specs.length} test files for --shard=${ctx.config.shard.index}/${ctx.config.shard.count}.`);
-				specs = await sequencer.shard(specs);
-			}
-			return sequencer.sort(specs);
-		}
-		const sortedGroups = Array.from(groups).sort();
-		for (const group of sortedGroups) {
-			const specifications = groupedSpecifications[group];
-			if (!specifications?.length) continue;
-			const filesByPool = {
-				forks: [],
-				threads: [],
-				vmThreads: [],
-				vmForks: [],
-				typescript: []
-			};
-			specifications.forEach((specification) => {
-				const pool = specification.pool;
-				filesByPool[pool] ??= [], filesByPool[pool].push(specification);
-			}), await Promise.all(Object.entries(filesByPool).map(async (entry) => {
-				const [pool, files] = entry;
-				if (!files.length) return null;
-				const specs = await sortSpecs(files);
-				if (pool in factories) {
-					const factory = factories[pool];
-					return pools[pool] ??= factory(), pools[pool][method](specs, invalidate);
-				}
-				if (pool === "browser") return pools.browser ??= await getBrowserPool(), pools.browser[method](specs, invalidate);
-				const poolHandler = await getCustomPool(pool);
-				return pools[poolHandler.name] ??= poolHandler, poolHandler[method](specs, invalidate);
-			}));
-		}
-	}
-	return {
-		name: "default",
-		runTests: (files, invalidates) => executeTests("runTests", files, invalidates),
-		collectTests: (files, invalidates) => executeTests("collectTests", files, invalidates),
-		async close() {
-			await Promise.all(Object.values(pools).map((p) => p?.close?.()));
-		}
-	};
-}
-
 class BaseSequencer {
 	ctx;
 	constructor(ctx) {
@@ -3359,7 +2363,7 @@ class BaseSequencer {
 	async shard(files) {
 		const { config } = this.ctx, { index, count } = config.shard, [shardStart, shardEnd] = this.calculateShardRange(files.length, index, count);
 		return [...files].map((spec) => {
-			const fullPath = resolve$1(slash(config.root), slash(spec.moduleId)), specPath = fullPath?.slice(config.root.length);
+			const specPath = resolve(slash(config.root), slash(spec.moduleId))?.slice(config.root.length);
 			return {
 				spec,
 				hash: hash("sha1", specPath, "hex")
@@ -3400,7 +2404,7 @@ class RandomSequencer extends BaseSequencer {
 }
 
 function resolvePath(path, root) {
-	return normalize(/* @__PURE__ */ resolveModule(path, { paths: [root] }) ?? resolve$1(root, path));
+	return normalize(/* @__PURE__ */ resolveModule(path, { paths: [root] }) ?? resolve(root, path));
 }
 function parseInspector(inspect) {
 	if (typeof inspect === "boolean" || inspect === void 0) return {};
@@ -3442,7 +2446,8 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		root: viteConfig.root,
 		mode
 	};
-	if (resolved.project = toArray(resolved.project), resolved.provide ??= {}, resolved.name = typeof options.name === "string" ? options.name : options.name?.label || "", resolved.color = typeof options.name !== "string" ? options.name?.color : void 0, resolved.environment === "browser") throw new Error(`Looks like you set "test.environment" to "browser". To enabled Browser Mode, use "test.browser.enabled" instead.`);
+	if (options.pool && typeof options.pool !== "string") resolved.pool = options.pool.name, resolved.poolRunner = options.pool;
+	if (resolved.pool ??= "forks", resolved.project = toArray(resolved.project), resolved.provide ??= {}, resolved.name = typeof options.name === "string" ? options.name : options.name?.label || "", resolved.color = typeof options.name !== "string" ? options.name?.color : void 0, resolved.environment === "browser") throw new Error(`Looks like you set "test.environment" to "browser". To enabled Browser Mode, use "test.browser.enabled" instead.`);
 	const inspector = resolved.inspect || resolved.inspectBrk;
 	if (resolved.inspector = {
 		...resolved.inspector,
@@ -3463,14 +2468,14 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	if (resolved.standalone && !resolved.watch) throw new Error(`Vitest standalone mode requires --watch`);
 	if (resolved.mergeReports && resolved.watch) throw new Error(`Cannot merge reports with --watch enabled`);
 	if (resolved.maxWorkers) resolved.maxWorkers = resolveInlineWorkerOption(resolved.maxWorkers);
-	if (resolved.minWorkers) resolved.minWorkers = resolveInlineWorkerOption(resolved.minWorkers);
-	if (resolved.fileParallelism ??= mode !== "benchmark", !resolved.fileParallelism) resolved.maxWorkers = 1, resolved.minWorkers = 1;
+	if (resolved.fileParallelism ??= mode !== "benchmark", !resolved.fileParallelism)
+ // ignore user config, parallelism cannot be implemented without limiting workers
+	resolved.maxWorkers = 1;
 	if (resolved.maxConcurrency === 0) logger.console.warn(c.yellow(`The option "maxConcurrency" cannot be set to 0. Using default value ${configDefaults.maxConcurrency} instead.`)), resolved.maxConcurrency = configDefaults.maxConcurrency;
 	if (resolved.inspect || resolved.inspectBrk) {
-		const isSingleThread = resolved.pool === "threads" && resolved.poolOptions?.threads?.singleThread, isSingleFork = resolved.pool === "forks" && resolved.poolOptions?.forks?.singleFork;
-		if (resolved.fileParallelism && !isSingleThread && !isSingleFork) {
+		if (resolved.fileParallelism) {
 			const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
-			throw new Error(`You cannot use ${inspectOption} without "--no-file-parallelism", "poolOptions.threads.singleThread" or "poolOptions.forks.singleFork"`);
+			throw new Error(`You cannot use ${inspectOption} without "--no-file-parallelism"`);
 		}
 	}
 	// apply browser CLI options only if the config already has the browser config and not disabled manually
@@ -3478,35 +2483,59 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.browser ??= {};
 	const browser = resolved.browser;
 	if (browser.enabled) {
-		if (!browser.name && !browser.instances) throw new Error(`Vitest Browser Mode requires "browser.name" (deprecated) or "browser.instances" options, none were set.`);
 		const instances = browser.instances;
-		if (browser.name && browser.instances)
- // --browser=chromium filters configs to a single one
-		browser.instances = browser.instances.filter((instance) => instance.browser === browser.name);
-		if (browser.instances && !browser.instances.length) throw new Error([`"browser.instances" was set in the config, but the array is empty. Define at least one browser config.`, browser.name && instances?.length ? ` The "browser.name" was set to "${browser.name}" which filtered all configs (${instances.map((c) => c.browser).join(", ")}). Did you mean to use another name?` : ""].join(""));
+		if (!browser.instances) browser.instances = [];
+		// use `chromium` by default when the preview provider is specified
+		// for a smoother experience. if chromium is not available, it will
+		// open the default browser anyway
+		if (!browser.instances.length && browser.provider?.name === "preview") browser.instances = [{ browser: "chromium" }];
+		if (browser.name && instances?.length) {
+			// if `instances` were defined, but now they are empty,
+			// let's throw an error because the filter is invalid
+			if (browser.instances = browser.instances.filter((instance) => instance.browser === browser.name), !browser.instances.length) throw new Error([`"browser.instances" was set in the config, but the array is empty. Define at least one browser config.`, ` The "browser.name" was set to "${browser.name}" which filtered all configs (${instances.map((c) => c.browser).join(", ")}). Did you mean to use another name?`].join(""));
+		}
 	}
-	const playwrightChromiumOnly = isPlaywrightChromiumOnly(vitest, resolved);
-	// Browser-mode "Playwright + Chromium" only features:
-	if (browser.enabled && !playwrightChromiumOnly) {
-		const browserConfig = { browser: {
-			provider: browser.provider,
-			name: browser.name,
-			instances: browser.instances?.map((i) => ({ browser: i.browser }))
-		} };
-		if (resolved.coverage.enabled && resolved.coverage.provider === "v8") throw new Error(`@vitest/coverage-v8 does not work with\n${JSON.stringify(browserConfig, null, 2)}\n\nUse either:\n${JSON.stringify({ browser: {
-			provider: "playwright",
-			instances: [{ browser: "chromium" }]
-		} }, null, 2)}\n\n...or change your coverage provider to:\n${JSON.stringify({ coverage: { provider: "istanbul" } }, null, 2)}\n`);
-		if (resolved.inspect || resolved.inspectBrk) {
+	const containsChromium = hasBrowserChromium(vitest, resolved), hasOnlyChromium = hasOnlyBrowserChromium(vitest, resolved);
+	// Browser-mode "Chromium" only features:
+	if (browser.enabled && (!containsChromium || !hasOnlyChromium)) {
+		const browserConfig = `
+{
+  browser: {
+    provider: ${browser.provider?.name || "preview"}(),
+    instances: [
+      ${(browser.instances || []).map((i) => `{ browser: '${i.browser}' }`).join(",\n      ")}
+    ],
+  },
+}
+    `.trim(), preferredProvider = !browser.provider?.name || browser.provider.name === "preview" ? "playwright" : browser.provider.name, correctExample = `
+{
+  browser: {
+    provider: ${preferredProvider}(),
+    instances: [
+      { browser: '${preferredProvider === "playwright" ? "chromium" : "chrome"}' }
+    ],
+  },
+}
+    `.trim();
+		// requires all projects to be chromium
+		if (!hasOnlyChromium && resolved.coverage.enabled && resolved.coverage.provider === "v8") {
+			const coverageExample = `
+{
+  coverage: {
+    provider: 'istanbul',
+  },
+}
+      `.trim();
+			throw new Error(`@vitest/coverage-v8 does not work with\n${browserConfig}\n\nUse either:\n${correctExample}\n\n...or change your coverage provider to:\n${coverageExample}\n`);
+		}
+		// ignores non-chromium browsers when there is at least one chromium project
+		if (!containsChromium && (resolved.inspect || resolved.inspectBrk)) {
 			const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
-			throw new Error(`${inspectOption} does not work with\n${JSON.stringify(browserConfig, null, 2)}\n\nUse either:\n${JSON.stringify({ browser: {
-				provider: "playwright",
-				instances: [{ browser: "chromium" }]
-			} }, null, 2)}\n\n...or disable ${inspectOption}\n`);
+			throw new Error(`${inspectOption} does not work with\n${browserConfig}\n\nUse either:\n${correctExample}\n\n...or disable ${inspectOption}\n`);
 		}
 	}
 	if (resolved.coverage.reporter = resolveCoverageReporters(resolved.coverage.reporter), resolved.coverage.enabled && resolved.coverage.reportsDirectory) {
-		const reportsDirectory = resolve$1(resolved.root, resolved.coverage.reportsDirectory);
+		const reportsDirectory = resolve(resolved.root, resolved.coverage.reportsDirectory);
 		if (reportsDirectory === resolved.root || reportsDirectory === process.cwd()) throw new Error(`You cannot set "coverage.reportsDirectory" as ${reportsDirectory}. Vitest needs to be able to remove this directory before test run`);
 	}
 	if (resolved.coverage.enabled && resolved.coverage.provider === "custom" && resolved.coverage.customProviderModule) resolved.coverage.customProviderModule = resolvePath(resolved.coverage.customProviderModule, resolved.root);
@@ -3514,7 +2543,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	const envModuleDirectories = process.env.VITEST_MODULE_DIRECTORIES || process.env.npm_config_VITEST_MODULE_DIRECTORIES;
 	if (envModuleDirectories) resolved.deps.moduleDirectories.push(...envModuleDirectories.split(","));
 	if (resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map((dir) => {
-		if (!dir.startsWith("/")) dir = `/${dir}`;
+		if (dir[0] !== "/") dir = `/${dir}`;
 		if (!dir.endsWith("/")) dir += "/";
 		return normalize(dir);
 	}), !resolved.deps.moduleDirectories.includes("/node_modules/")) resolved.deps.moduleDirectories.push("/node_modules/");
@@ -3527,9 +2556,9 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		"**/virtual:*",
 		"**/__x00__*",
 		"**/node_modules/**"
-	].filter((pattern) => pattern != null), resolved.forceRerunTriggers = [...resolved.forceRerunTriggers, ...resolved.setupFiles], resolved.cliExclude) resolved.exclude.push(...resolved.cliExclude);
+	].filter((pattern) => typeof pattern === "string"), resolved.forceRerunTriggers = [...resolved.forceRerunTriggers, ...resolved.setupFiles], resolved.cliExclude) resolved.exclude.push(...resolved.cliExclude);
 	if (resolved.runner) resolved.runner = resolvePath(resolved.runner, resolved.root);
-	if (resolved.attachmentsDir = resolve$1(resolved.root, resolved.attachmentsDir ?? ".vitest-attachments"), resolved.snapshotEnvironment) resolved.snapshotEnvironment = resolvePath(resolved.snapshotEnvironment, resolved.root);
+	if (resolved.attachmentsDir = resolve(resolved.root, resolved.attachmentsDir ?? ".vitest-attachments"), resolved.snapshotEnvironment) resolved.snapshotEnvironment = resolvePath(resolved.snapshotEnvironment, resolved.root);
 	if (resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0, resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) {
 		// TODO: support it via separate config (like DiffOptions) or via `Function.toString()`
 		if (resolved.snapshotFormat.plugins = [], typeof resolved.snapshotFormat.compareKeys === "function") throw new TypeError(`"snapshotFormat.compareKeys" function is not supported.`);
@@ -3542,65 +2571,8 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		resolveSnapshotPath: options.resolveSnapshotPath,
 		snapshotEnvironment: null
 	}, resolved.snapshotSerializers ??= [], resolved.snapshotSerializers = resolved.snapshotSerializers.map((file) => resolvePath(file, resolved.root)), resolved.forceRerunTriggers.push(...resolved.snapshotSerializers), options.resolveSnapshotPath) delete resolved.resolveSnapshotPath;
-	if (resolved.pool ??= "threads", process.env.VITEST_MAX_THREADS) resolved.poolOptions = {
-		...resolved.poolOptions,
-		threads: {
-			...resolved.poolOptions?.threads,
-			maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
-		},
-		vmThreads: {
-			...resolved.poolOptions?.vmThreads,
-			maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
-		}
-	};
-	if (process.env.VITEST_MIN_THREADS) resolved.poolOptions = {
-		...resolved.poolOptions,
-		threads: {
-			...resolved.poolOptions?.threads,
-			minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-		},
-		vmThreads: {
-			...resolved.poolOptions?.vmThreads,
-			minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-		}
-	};
-	if (process.env.VITEST_MAX_FORKS) resolved.poolOptions = {
-		...resolved.poolOptions,
-		forks: {
-			...resolved.poolOptions?.forks,
-			maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
-		},
-		vmForks: {
-			...resolved.poolOptions?.vmForks,
-			maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
-		}
-	};
-	if (process.env.VITEST_MIN_FORKS) resolved.poolOptions = {
-		...resolved.poolOptions,
-		forks: {
-			...resolved.poolOptions?.forks,
-			minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-		},
-		vmForks: {
-			...resolved.poolOptions?.vmForks,
-			minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-		}
-	};
-	const poolThreadsOptions = [
-		["threads", "minThreads"],
-		["threads", "maxThreads"],
-		["vmThreads", "minThreads"],
-		["vmThreads", "maxThreads"]
-	];
-	for (const [poolOptionKey, workerOptionKey] of poolThreadsOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-	const poolForksOptions = [
-		["forks", "minForks"],
-		["forks", "maxForks"],
-		["vmForks", "minForks"],
-		["vmForks", "maxForks"]
-	];
-	for (const [poolOptionKey, workerOptionKey] of poolForksOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-	if (!builtinPools.includes(resolved.pool)) resolved.pool = resolvePath(resolved.pool, resolved.root);
+	if (resolved.execArgv ??= [], resolved.pool ??= "threads", resolved.pool === "vmForks" || resolved.pool === "vmThreads" || resolved.pool === "typescript") resolved.isolate = false;
+	if (process.env.VITEST_MAX_WORKERS) resolved.maxWorkers = Number.parseInt(process.env.VITEST_MAX_WORKERS);
 	if (mode === "benchmark") {
 		resolved.benchmark = {
 			...benchmarkConfigDefaults,
@@ -3615,12 +2587,10 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		if (options.outputJson) resolved.benchmark.outputJson = options.outputJson;
 	}
 	if (typeof resolved.diff === "string") resolved.diff = resolvePath(resolved.diff, resolved.root), resolved.forceRerunTriggers.push(resolved.diff);
-	// the server has been created, we don't need to override vite.server options
-	const api = resolveApiServerConfig(options, defaultPort);
 	if (resolved.api = {
-		...api,
+		...resolveApiServerConfig(options, defaultPort),
 		token: crypto.randomUUID()
-	}, options.related) resolved.related = toArray(options.related).map((file) => resolve$1(resolved.root, file));
+	}, options.related) resolved.related = toArray(options.related).map((file) => resolve(resolved.root, file));
 	/*
 	* Reporters can be defined in many different ways:
 	* { reporter: 'json' }
@@ -3650,7 +2620,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		// @ts-expect-error "reporter" is from CLI, should be absolute to the running directory
 		// it is passed down as "vitest --reporter ../reporter.js"
 		const reportersFromCLI = resolved.reporter, cliReporters = toArray(reportersFromCLI || []).map((reporter) => {
-			return /^\.\.?\//.test(reporter) ? resolve$1(process.cwd(), reporter) : reporter;
+			return /^\.\.?\//.test(reporter) ? resolve(process.cwd(), reporter) : reporter;
 		});
 		if (cliReporters.length) resolved.reporters = Array.from(new Set(toArray(cliReporters))).filter(Boolean).map((reporter) => [reporter, {}]);
 	}
@@ -3676,24 +2646,35 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		...configDefaults.typecheck,
 		...resolved.typecheck
 	}, resolved.typecheck ??= {}, resolved.typecheck.enabled ??= false, resolved.typecheck.enabled) logger.console.warn(c.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."));
-	if (resolved.browser.enabled ??= false, resolved.browser.headless ??= isCI, resolved.browser.isolate ??= true, resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark", resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI, resolved.browser.screenshotDirectory) resolved.browser.screenshotDirectory = resolve$1(resolved.root, resolved.browser.screenshotDirectory);
-	const isPreview = resolved.browser.provider === "preview";
+	if (resolved.browser.enabled ??= false, resolved.browser.headless ??= isCI, resolved.browser.isolate ??= true, resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark", resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI, resolved.browser.commands ??= {}, resolved.browser.screenshotDirectory) resolved.browser.screenshotDirectory = resolve(resolved.root, resolved.browser.screenshotDirectory);
+	if (resolved.inspector.enabled) resolved.browser.trackUnhandledErrors ??= false;
+	if (resolved.browser.viewport ??= {}, resolved.browser.viewport.width ??= 414, resolved.browser.viewport.height ??= 896, resolved.browser.locators ??= {}, resolved.browser.locators.testIdAttribute ??= "data-testid", typeof resolved.browser.provider === "string") {
+		const source = `@vitest/browser-${resolved.browser.provider}`;
+		throw new TypeError(`The \`browser.provider\` configuration was changed to accept a factory instead of a string. Add an import of "${resolved.browser.provider}" from "${source}" instead. See: https://vitest.dev/guide/browser/config#provider`);
+	}
+	const isPreview = resolved.browser.provider?.name === "preview";
+	if (!isPreview && resolved.browser.enabled && provider === "stackblitz") throw new Error(`stackblitz environment does not support the ${resolved.browser.provider?.name} provider. Please, use "@vitest/browser-preview" instead.`);
 	if (isPreview && resolved.browser.screenshotFailures === true) console.warn(c.yellow([
 		`Browser provider "preview" doesn't support screenshots, `,
 		`so "browser.screenshotFailures" option is forcefully disabled. `,
 		`Set "browser.screenshotFailures" to false or remove it from the config to suppress this warning.`
 	].join(""))), resolved.browser.screenshotFailures = false;
 	else resolved.browser.screenshotFailures ??= !isPreview && !resolved.browser.ui;
-	if (resolved.browser.viewport ??= {}, resolved.browser.viewport.width ??= 414, resolved.browser.viewport.height ??= 896, resolved.browser.locators ??= {}, resolved.browser.locators.testIdAttribute ??= "data-testid", resolved.browser.enabled && provider === "stackblitz") resolved.browser.provider = "preview";
+	if (resolved.browser.provider && resolved.browser.provider.options == null) resolved.browser.provider.options = {};
 	// enable includeTaskLocation by default in UI mode
 	if (resolved.browser.api = resolveApiServerConfig(resolved.browser, defaultBrowserPort) || { port: defaultBrowserPort }, resolved.browser.enabled) {
 		if (resolved.browser.ui) resolved.includeTaskLocation ??= true;
 	} else if (resolved.ui) resolved.includeTaskLocation ??= true;
-	const htmlReporter = toArray(resolved.reporters).some((reporter) => {
+	if (typeof resolved.browser.trace === "string" || !resolved.browser.trace) resolved.browser.trace = { mode: resolved.browser.trace || "off" };
+	if (resolved.browser.trace.tracesDir != null) resolved.browser.trace.tracesDir = resolvePath(resolved.browser.trace.tracesDir, resolved.root);
+	if (toArray(resolved.reporters).some((reporter) => {
 		return Array.isArray(reporter) ? reporter[0] === "html" : false;
-	});
-	if (htmlReporter) resolved.includeTaskLocation ??= true;
-	return resolved.server ??= {}, resolved.server.deps ??= {}, resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3, resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4, resolved;
+	})) resolved.includeTaskLocation ??= true;
+	if (resolved.server ??= {}, resolved.server.deps ??= {}, resolved.server.debug?.dump || process.env.VITEST_DEBUG_DUMP) {
+		const userFolder = resolved.server.debug?.dump || process.env.VITEST_DEBUG_DUMP;
+		resolved.dumpDir = resolve(resolved.root, typeof userFolder === "string" && userFolder !== "true" ? userFolder : ".vitest-dump", resolved.name || "root");
+	}
+	return resolved.testTimeout ??= resolved.browser.enabled ? 3e4 : 5e3, resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4, resolved;
 }
 function isBrowserEnabled(config) {
 	return Boolean(config.browser?.enabled);
@@ -3710,18 +2691,22 @@ function resolveCoverageReporters(configReporters) {
 	resolvedReporters.push([reporter, {}]);
 	return resolvedReporters;
 }
-function isPlaywrightChromiumOnly(vitest, config) {
+function isChromiumName(provider, name) {
+	return provider === "playwright" ? name === "chromium" : name === "chrome" || name === "edge";
+}
+function hasBrowserChromium(vitest, config) {
 	const browser = config.browser;
-	if (!browser || browser.provider !== "playwright" || !browser.enabled) return false;
-	if (browser.name) return browser.name === "chromium";
-	if (!browser.instances) return false;
-	for (const instance of browser.instances) {
+	return !browser || !browser.provider || browser.provider.name === "preview" || !browser.enabled ? false : browser.name ? isChromiumName(browser.provider.name, browser.name) : browser.instances ? browser.instances.some((instance) => {
 		const name = instance.name || (config.name ? `${config.name} (${instance.browser})` : instance.browser);
-		// browser config is filtered out
-		if (!vitest.matchesProjectFilter(name)) continue;
-		if (instance.browser !== "chromium") return false;
-	}
-	return true;
+		return vitest.matchesProjectFilter(name) ? isChromiumName(browser.provider.name, instance.browser) : false;
+	}) : false;
+}
+function hasOnlyBrowserChromium(vitest, config) {
+	const browser = config.browser;
+	return !browser || !browser.provider || browser.provider.name === "preview" || !browser.enabled ? false : browser.name ? isChromiumName(browser.provider.name, browser.name) : browser.instances ? browser.instances.every((instance) => {
+		const name = instance.name || (config.name ? `${config.name} (${instance.browser})` : instance.browser);
+		return vitest.matchesProjectFilter(name) ? isChromiumName(browser.provider.name, instance.browser) : true;
+	}) : false;
 }
 
 const THRESHOLD_KEYS = [
@@ -3754,7 +2739,7 @@ Update your dependencies and make sure the versions match.`));
 			...coverageConfigDefaults,
 			...config,
 			provider: this.name,
-			reportsDirectory: resolve$1(ctx.config.root, config.reportsDirectory || coverageConfigDefaults.reportsDirectory),
+			reportsDirectory: resolve(ctx.config.root, config.reportsDirectory || coverageConfigDefaults.reportsDirectory),
 			reporter: resolveCoverageReporters(config.reporter || coverageConfigDefaults.reporter),
 			thresholds: config.thresholds && {
 				...config.thresholds,
@@ -3766,7 +2751,7 @@ Update your dependencies and make sure the versions match.`));
 		};
 		const shard = this.ctx.config.shard, tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
 		// If --project filter is set pick only roots of resolved projects
-		this.coverageFilesDirectory = resolve$1(this.options.reportsDirectory, tempDirectory), this.roots = ctx.config.project?.length ? [...new Set(ctx.projects.map((project) => project.config.root))] : [ctx.config.root];
+		this.coverageFilesDirectory = resolve(this.options.reportsDirectory, tempDirectory), this.roots = ctx.config.project?.length ? [...new Set(ctx.projects.map((project) => project.config.root))] : [ctx.config.root];
 	}
 	/**
 	* Check if file matches `coverage.include` but not `coverage.exclude`
@@ -3802,8 +2787,8 @@ Update your dependencies and make sure the versions match.`));
 	}
 	async getUntestedFiles(testedFiles) {
 		if (this.options.include == null) return [];
-		const rootMapper = this.getUntestedFilesByRoot.bind(this, testedFiles, this.options.include), matrix = await Promise.all(this.roots.map(rootMapper));
-		return matrix.flatMap((files) => files);
+		const rootMapper = this.getUntestedFilesByRoot.bind(this, testedFiles, this.options.include);
+		return (await Promise.all(this.roots.map(rootMapper))).flatMap((files) => files);
 	}
 	createCoverageMap() {
 		throw new Error("BaseReporter's createCoverageMap was not overwritten");
@@ -3818,26 +2803,26 @@ Update your dependencies and make sure the versions match.`));
 		return this.options;
 	}
 	async clean(clean = true) {
-		if (clean && existsSync(this.options.reportsDirectory)) await promises$1.rm(this.options.reportsDirectory, {
+		if (clean && existsSync(this.options.reportsDirectory)) await promises.rm(this.options.reportsDirectory, {
 			recursive: true,
 			force: true,
 			maxRetries: 10
 		});
-		if (existsSync(this.coverageFilesDirectory)) await promises$1.rm(this.coverageFilesDirectory, {
+		if (existsSync(this.coverageFilesDirectory)) await promises.rm(this.coverageFilesDirectory, {
 			recursive: true,
 			force: true,
 			maxRetries: 10
 		});
-		await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true }), this.coverageFiles = /* @__PURE__ */ new Map(), this.pendingPromises = [];
+		await promises.mkdir(this.coverageFilesDirectory, { recursive: true }), this.coverageFiles = /* @__PURE__ */ new Map(), this.pendingPromises = [];
 	}
 	onAfterSuiteRun({ coverage, environment, projectName, testFiles }) {
 		if (!coverage) return;
 		let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
 		if (!entry) entry = {}, this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
-		const testFilenames = testFiles.join(), filename = resolve$1(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
+		const testFilenames = testFiles.join(), filename = resolve(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
 		// If there's a result from previous run, overwrite it
 		entry[environment] ??= {}, entry[environment][testFilenames] = filename;
-		const promise = promises$1.writeFile(filename, JSON.stringify(coverage), "utf-8");
+		const promise = promises.writeFile(filename, JSON.stringify(coverage), "utf-8");
 		this.pendingPromises.push(promise);
 	}
 	async readCoverageFiles({ onFileRead, onFinished, onDebug }) {
@@ -3849,7 +2834,7 @@ Update your dependencies and make sure the versions match.`));
 			for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
 				if (onDebug.enabled) index += chunk.length, onDebug(`Reading coverage results ${index}/${total}`);
 				await Promise.all(chunk.map(async (filename) => {
-					const contents = await promises$1.readFile(filename, "utf-8"), coverage = JSON.parse(contents);
+					const contents = await promises.readFile(filename, "utf-8"), coverage = JSON.parse(contents);
 					onFileRead(coverage);
 				}));
 			}
@@ -3858,16 +2843,13 @@ Update your dependencies and make sure the versions match.`));
 	}
 	async cleanAfterRun() {
 		// Remove empty reports directory, e.g. when only text-reporter is used
-		if (this.coverageFiles = /* @__PURE__ */ new Map(), await promises$1.rm(this.coverageFilesDirectory, { recursive: true }), readdirSync(this.options.reportsDirectory).length === 0) await promises$1.rm(this.options.reportsDirectory, { recursive: true });
+		if (this.coverageFiles = /* @__PURE__ */ new Map(), await promises.rm(this.coverageFilesDirectory, { recursive: true }), readdirSync(this.options.reportsDirectory).length === 0) await promises.rm(this.options.reportsDirectory, { recursive: true });
 	}
 	async onTestFailure() {
 		if (!this.options.reportOnFailure) await this.cleanAfterRun();
 	}
 	async reportCoverage(coverageMap, { allTestsRun }) {
-		await this.generateReports(coverageMap || this.createCoverageMap(), allTestsRun);
-		// In watch mode we need to preserve the previous results if cleanOnRerun is disabled
-		const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
-		if (!keepResults) await this.cleanAfterRun();
+		if (await this.generateReports(coverageMap || this.createCoverageMap(), allTestsRun), !(!this.options.cleanOnRerun && this.ctx.config.watch)) await this.cleanAfterRun();
 	}
 	async reportThresholds(coverageMap, allTestsRun) {
 		const resolvedThresholds = this.resolveThresholds(coverageMap);
@@ -3998,10 +2980,14 @@ Update your dependencies and make sure the versions match.`));
 			}
 			if (thresholdsToUpdate.length === 0) continue;
 			updatedThresholds = true;
-			for (const [threshold, newValue] of thresholdsToUpdate) if (name === GLOBAL_THRESHOLDS_KEY) config.test.coverage.thresholds[threshold] = newValue;
-			else {
-				const glob = config.test.coverage.thresholds[name];
-				glob[threshold] = newValue;
+			const thresholdFormatter = typeof this.options.thresholds?.autoUpdate === "function" ? this.options.thresholds?.autoUpdate : (value) => value;
+			for (const [threshold, newValue] of thresholdsToUpdate) {
+				const formattedValue = thresholdFormatter(newValue);
+				if (name === GLOBAL_THRESHOLDS_KEY) config.test.coverage.thresholds[threshold] = formattedValue;
+				else {
+					const glob = config.test.coverage.thresholds[name];
+					glob[threshold] = formattedValue;
+				}
 			}
 		}
 		if (updatedThresholds) this.ctx.logger.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds."), onUpdate();
@@ -4118,4 +3104,4 @@ function resolveMergeConfig(mod) {
 	}
 }
 
-export { BaseCoverageProvider as B, RandomSequencer as R, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, createFetchModuleFunction as d, isBrowserEnabled as e, groupBy as f, getFilePoolName as g, hash as h, isPackageExists as i, getCoverageProvider as j, createPool as k, normalizeResolvedIdToUrl as n, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };
+export { BaseCoverageProvider as B, RandomSequencer as R, resolveApiServerConfig as a, BaseSequencer as b, isBrowserEnabled as c, getCoverageProvider as g, hash as h, isPackageExists as i, resolveConfig$1 as r };