vitest 4.0.0-beta.17 → 4.0.0-beta.19

package/dist/chunks/{coverage.3htTSxXZ.js → coverage.FU3w4IrQ.js}

@@ -1,64 +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 { createDefer, isExternalUrl, unwrapId, nanoid, withTrailingSlash as withTrailingSlash$1, cleanUrl, wrapId, slash, shuffle, toArray } from '@vitest/utils/helpers';
-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 { rootDir } from '../path.js';
-import { s as stringify, w as wrapSerializableConfig, a as Typechecker } from './typechecker.DsKAhua5.js';
-import createDebug from 'debug';
-import EventEmitter from 'node:events';
-import { c as createBirpc } from './index.Bgo3tNWt.js';
-import Tinypool$1, { Tinypool } from 'tinypool';
-import { MessageChannel } from 'node:worker_threads';
-import { hasFailed } from '@vitest/runner/utils';
+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[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 hash = crypto.hash ?? ((algorithm, data, outputEncoding) => crypto.createHash(algorithm).update(data).digest(outputEncoding));
 
 const JOIN_LEADING_SLASH_RE = /^\.?\//;
@@ -2392,1124 +2354,6 @@ function getWorkersCountByPercentage(percent) {
 	return Math.max(1, Math.min(maxWorkersCount, workersCountByPercentage));
 }
 
-const debug = createDebugger("vitest:browser:pool");
-function createBrowserPool(vitest) {
-	const providers = /* @__PURE__ */ new Set(), 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), 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 } of specs) {
-			const files = groupedFiles.get(project) || [];
-			files.push(moduleId), 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), 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).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";
-}
-
-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");
-		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 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[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$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));
-			return { code: (await environment.transformRequest(url).catch(handleRollupError))?.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
-	});
-	return project.vitest.onCancel((reason) => rpc.onCancel(reason)), {
-		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"));
-		}
-	};
-}
-function createForksPool(vitest, { execArgv, env }, specifications) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.forks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, options = {
-		runtime: "child_process",
-		filename: resolve(vitest.distPath, "worker-base.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",
-				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
-	});
-	return project.vitest.onCancel((reason) => rpc.onCancel(reason)), {
-		workerPort,
-		port,
-		onClose: () => {
-			port.close(), workerPort.close(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
-		}
-	};
-}
-function createThreadsPool(vitest, { execArgv, env }, specifications) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.threads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, options = {
-		filename: resolve(vitest.distPath, "worker-base.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",
-				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"));
-		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) {
-		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(), 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());
-				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 ?? {};
-		return opts.memoryLimit ? opts.memoryLimit : 1 / (opts.maxForks ?? getDefaultThreadsCount(config));
-	} else {
-		const opts = config.poolOptions?.vmThreads ?? {};
-		return opts.memoryLimit ? opts.memoryLimit : 1 / (opts.maxThreads ?? 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;
-}
-
-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
-	});
-	return project.vitest.onCancel((reason) => rpc.onCancel(reason)), { 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"));
-		}
-	} };
-}
-function createVmForksPool(vitest, { execArgv, env }, specifications) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.vmForks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, options = {
-		runtime: "child_process",
-		filename: resolve(vitest.distPath, "worker-vm.js"),
-		maxThreads,
-		minThreads,
-		env,
-		execArgv: [
-			"--experimental-vm-modules",
-			...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: "vmForks",
-				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(), errors = (await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)))).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;
-}
-
-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 }, specifications) {
-	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.vmThreads ?? {}, maxThreads = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, options = {
-		filename: resolve(vitest.distPath, "worker-vm.js"),
-		useAtomics: poolOptions.useAtomics ?? false,
-		maxThreads,
-		minThreads,
-		env,
-		execArgv: [
-			"--experimental-vm-modules",
-			...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",
-				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(), errors = (await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)))).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 suppressWarningsPath = resolve$1(rootDir, "./suppress-warnings.cjs");
-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]), 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]), 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,
-				"--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];
-		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));
-		}
-		const groupedSpecifications = {}, groups = /* @__PURE__ */ new Set(), factories = {
-			vmThreads: (specs) => createVmThreadsPool(ctx, options, specs),
-			vmForks: (specs) => createVmForksPool(ctx, options, specs),
-			threads: (specs) => createThreadsPool(ctx, options, specs),
-			forks: (specs) => createForksPool(ctx, options, specs),
-			typescript: () => createTypecheckPool(ctx),
-			browser: () => createBrowserPool(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(specs), pools[pool][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) {
@@ -3519,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 specPath = resolve$1(slash(config.root), slash(spec.moduleId))?.slice(config.root.length);
+			const specPath = resolve(slash(config.root), slash(spec.moduleId))?.slice(config.root.length);
 			return {
 				spec,
 				hash: hash("sha1", specPath, "hex")
@@ -3560,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 {};
@@ -3602,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,
@@ -3628,10 +2473,9 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	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
@@ -3691,7 +2535,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		}
 	}
 	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);
@@ -3712,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.`);
@@ -3727,31 +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_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)
-		}
-	};
-	for (const [poolOptionKey, workerOptionKey] of [["threads", "maxThreads"], ["vmThreads", "maxThreads"]]) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-	for (const [poolOptionKey, workerOptionKey] of [["forks", "maxForks"], ["vmForks", "maxForks"]]) 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,
@@ -3769,7 +2590,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	if (resolved.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' }
@@ -3799,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, {}]);
 	}
@@ -3825,7 +2646,8 @@ 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.commands ??= {}, resolved.browser.screenshotDirectory) resolved.browser.screenshotDirectory = resolve$1(resolved.root, resolved.browser.screenshotDirectory);
+	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`);
@@ -3848,7 +2670,11 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	if (toArray(resolved.reporters).some((reporter) => {
 		return Array.isArray(reporter) ? reporter[0] === "html" : false;
 	})) resolved.includeTaskLocation ??= true;
-	return resolved.server ??= {}, resolved.server.deps ??= {}, resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3, resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4, resolved;
+	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);
@@ -3913,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,
@@ -3925,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`
@@ -3977,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 }) {
@@ -4008,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);
 				}));
 			}
@@ -4017,7 +2843,7 @@ 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();
@@ -4278,4 +3104,4 @@ function resolveMergeConfig(mod) {
 	}
 }
 
-export { BaseCoverageProvider as B, RandomSequencer as R, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, createDebugger as d, createFetchModuleFunction as e, isBrowserEnabled as f, getFilePoolName as g, hash as h, isPackageExists as i, groupBy as j, getCoverageProvider as k, createPool as l, 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 };