vitest 3.1.0-beta.1 → 3.1.0-beta.2

package/dist/chunks/{coverage.gV8doR2Y.js → coverage.C2ohxaN0.js}

@@ -4,7 +4,7 @@ import require$$0 from 'util';
 import require$$0$1 from 'path';
 import { relative, resolve, dirname, isAbsolute, join, normalize } from 'pathe';
 import c from 'tinyrainbow';
-import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.C2Ndd9wx.js';
+import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.DmfNPoe5.js';
 import crypto from 'node:crypto';
 import { slash, createDefer, shuffle, toArray } from '@vitest/utils';
 import { writeFile, rename, stat, unlink } from 'node:fs/promises';
@@ -15,8 +15,8 @@ import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL
 import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
-import { e as extraInlineDeps, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.DTYd6dNH.js';
-import { a as isWindows } from './env.D4Lgay0q.js';
+import { e as extraInlineDeps, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.BZZyIeIE.js';
+import { a as isWindows } from './env.Dq0hM4Xv.js';
 import * as nodeos from 'node:os';
 import nodeos__default from 'node:os';
 import { isatty } from 'node:tty';
@@ -24,169 +24,165 @@ import { version } from 'vite';
 import EventEmitter from 'node:events';
 import { c as createBirpc } from './index.68735LiX.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.BlF3eHsb.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.C2IpOhid.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';
 import { slash as slash$1 } from 'vite-node/utils';
 import { isCI, provider } from 'std-env';
-import { r as resolveCoverageProviderModule } from './coverage.A3sS5-Wm.js';
+import { r as resolveCoverageProviderModule } from './coverage.0iPg4Wrz.js';
 
 function groupBy(collection, iteratee) {
-  return collection.reduce((acc, item) => {
-    const key = iteratee(item);
-    acc[key] ||= [];
-    acc[key].push(item);
-    return acc;
-  }, {});
+	return collection.reduce((acc, item) => {
+		const key = iteratee(item);
+		acc[key] ||= [];
+		acc[key].push(item);
+		return acc;
+	}, {});
 }
 function stdout() {
-  return console._stdout || process.stdout;
+	return console._stdout || process.stdout;
 }
 function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	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 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));
 
 class FilesStatsCache {
-  cache = /* @__PURE__ */ new Map();
-  getStats(key) {
-    return this.cache.get(key);
-  }
-  async populateStats(root, specs) {
-    const promises = specs.map((spec) => {
-      const key = `${spec[0].name}:${relative(root, spec.moduleId)}`;
-      return this.updateStats(spec.moduleId, key);
-    });
-    await Promise.all(promises);
-  }
-  async updateStats(fsPath, key) {
-    if (!fs.existsSync(fsPath)) {
-      return;
-    }
-    const stats = await fs.promises.stat(fsPath);
-    this.cache.set(key, { size: stats.size });
-  }
-  removeStats(fsPath) {
-    this.cache.forEach((_, key) => {
-      if (key.endsWith(fsPath)) {
-        this.cache.delete(key);
-      }
-    });
-  }
+	cache = new Map();
+	getStats(key) {
+		return this.cache.get(key);
+	}
+	async populateStats(root, specs) {
+		const promises = specs.map((spec) => {
+			const key = `${spec[0].name}:${relative(root, spec.moduleId)}`;
+			return this.updateStats(spec.moduleId, key);
+		});
+		await Promise.all(promises);
+	}
+	async updateStats(fsPath, key) {
+		if (!fs.existsSync(fsPath)) {
+			return;
+		}
+		const stats = await fs.promises.stat(fsPath);
+		this.cache.set(key, { size: stats.size });
+	}
+	removeStats(fsPath) {
+		this.cache.forEach((_, key) => {
+			if (key.endsWith(fsPath)) {
+				this.cache.delete(key);
+			}
+		});
+	}
 }
 
 class ResultsCache {
-  cache = /* @__PURE__ */ new Map();
-  workspacesKeyMap = /* @__PURE__ */ new Map();
-  cachePath = null;
-  version;
-  root = "/";
-  constructor(version) {
-    this.version = version;
-  }
-  getCachePath() {
-    return this.cachePath;
-  }
-  setConfig(root, config) {
-    this.root = root;
-    if (config) {
-      this.cachePath = resolve(config.dir, "results.json");
-    }
-  }
-  getResults(key) {
-    return this.cache.get(key);
-  }
-  async readFromCache() {
-    if (!this.cachePath) {
-      return;
-    }
-    if (!fs.existsSync(this.cachePath)) {
-      return;
-    }
-    const resultsCache = await fs.promises.readFile(this.cachePath, "utf8");
-    const { results, version } = JSON.parse(resultsCache || "[]");
-    if (Number(version.split(".")[1]) >= 30) {
-      this.cache = new Map(results);
-      this.version = version;
-      results.forEach(([spec]) => {
-        const [projectName, relativePath] = spec.split(":");
-        const keyMap = this.workspacesKeyMap.get(relativePath) || [];
-        keyMap.push(projectName);
-        this.workspacesKeyMap.set(relativePath, keyMap);
-      });
-    }
-  }
-  updateResults(files) {
-    files.forEach((file) => {
-      const result = file.result;
-      if (!result) {
-        return;
-      }
-      const duration = result.duration || 0;
-      const relativePath = relative(this.root, file.filepath);
-      this.cache.set(`${file.projectName || ""}:${relativePath}`, {
-        duration: duration >= 0 ? duration : 0,
-        failed: result.state === "fail"
-      });
-    });
-  }
-  removeFromCache(filepath) {
-    this.cache.forEach((_, key) => {
-      if (key.endsWith(filepath)) {
-        this.cache.delete(key);
-      }
-    });
-  }
-  async writeToCache() {
-    if (!this.cachePath) {
-      return;
-    }
-    const results = Array.from(this.cache.entries());
-    const cacheDirname = dirname(this.cachePath);
-    if (!fs.existsSync(cacheDirname)) {
-      await fs.promises.mkdir(cacheDirname, { recursive: true });
-    }
-    const cache = JSON.stringify({
-      version: this.version,
-      results
-    });
-    await fs.promises.writeFile(this.cachePath, cache);
-  }
+	cache = new Map();
+	workspacesKeyMap = new Map();
+	cachePath = null;
+	version;
+	root = "/";
+	constructor(version) {
+		this.version = version;
+	}
+	getCachePath() {
+		return this.cachePath;
+	}
+	setConfig(root, config) {
+		this.root = root;
+		if (config) {
+			this.cachePath = resolve(config.dir, "results.json");
+		}
+	}
+	getResults(key) {
+		return this.cache.get(key);
+	}
+	async readFromCache() {
+		if (!this.cachePath) {
+			return;
+		}
+		if (!fs.existsSync(this.cachePath)) {
+			return;
+		}
+		const resultsCache = await fs.promises.readFile(this.cachePath, "utf8");
+		const { results, version } = JSON.parse(resultsCache || "[]");
+		if (Number(version.split(".")[1]) >= 30) {
+			this.cache = new Map(results);
+			this.version = version;
+			results.forEach(([spec]) => {
+				const [projectName, relativePath] = spec.split(":");
+				const keyMap = this.workspacesKeyMap.get(relativePath) || [];
+				keyMap.push(projectName);
+				this.workspacesKeyMap.set(relativePath, keyMap);
+			});
+		}
+	}
+	updateResults(files) {
+		files.forEach((file) => {
+			const result = file.result;
+			if (!result) {
+				return;
+			}
+			const duration = result.duration || 0;
+			const relativePath = relative(this.root, file.filepath);
+			this.cache.set(`${file.projectName || ""}:${relativePath}`, {
+				duration: duration >= 0 ? duration : 0,
+				failed: result.state === "fail"
+			});
+		});
+	}
+	removeFromCache(filepath) {
+		this.cache.forEach((_, key) => {
+			if (key.endsWith(filepath)) {
+				this.cache.delete(key);
+			}
+		});
+	}
+	async writeToCache() {
+		if (!this.cachePath) {
+			return;
+		}
+		const results = Array.from(this.cache.entries());
+		const cacheDirname = dirname(this.cachePath);
+		if (!fs.existsSync(cacheDirname)) {
+			await fs.promises.mkdir(cacheDirname, { recursive: true });
+		}
+		const cache = JSON.stringify({
+			version: this.version,
+			results
+		});
+		await fs.promises.writeFile(this.cachePath, cache);
+	}
 }
 
 class VitestCache {
-  results;
-  stats = new FilesStatsCache();
-  constructor(version) {
-    this.results = new ResultsCache(version);
-  }
-  getFileTestResults(key) {
-    return this.results.getResults(key);
-  }
-  getFileStats(key) {
-    return this.stats.getStats(key);
-  }
-  static resolveCacheDir(root, dir, projectName) {
-    const baseDir = slash(dir || "node_modules/.vite/vitest");
-    return projectName ? resolve(
-      root,
-      baseDir,
-      hash("md5", projectName, "hex")
-    ) : resolve(root, baseDir);
-  }
+	results;
+	stats = new FilesStatsCache();
+	constructor(version) {
+		this.results = new ResultsCache(version);
+	}
+	getFileTestResults(key) {
+		return this.results.getResults(key);
+	}
+	getFileStats(key) {
+		return this.stats.getStats(key);
+	}
+	static resolveCacheDir(root, dir, projectName) {
+		const baseDir = slash(dir || "node_modules/.vite/vitest");
+		return projectName ? resolve(root, baseDir, hash("md5", projectName, "hex")) : resolve(root, baseDir);
+	}
 }
 
 const JOIN_LEADING_SLASH_RE = /^\.?\//;
@@ -2306,9 +2302,9 @@ function resolvePackage(name, options = {}) {
 }
 
 function getWorkersCountByPercentage(percent) {
-  const maxWorkersCount = nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length;
-  const workersCountByPercentage = Math.round(Number.parseInt(percent) / 100 * maxWorkersCount);
-  return Math.max(1, Math.min(maxWorkersCount, workersCountByPercentage));
+	const maxWorkersCount = nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length;
+	const workersCountByPercentage = Math.round(Number.parseInt(percent) / 100 * maxWorkersCount);
+	return Math.max(1, Math.min(maxWorkersCount, workersCountByPercentage));
 }
 
 var utils$1 = {};
@@ -6438,2435 +6434,2176 @@ function requireMicromatch () {
 var micromatchExports = requireMicromatch();
 var mm = /*@__PURE__*/getDefaultExportFromCjs(micromatchExports);
 
-const envsOrder = ["node", "jsdom", "happy-dom", "edge-runtime"];
+const envsOrder = [
+	"node",
+	"jsdom",
+	"happy-dom",
+	"edge-runtime"
+];
 function getTransformMode(patterns, filename) {
-  if (patterns.web && mm.isMatch(filename, patterns.web)) {
-    return "web";
-  }
-  if (patterns.ssr && mm.isMatch(filename, patterns.ssr)) {
-    return "ssr";
-  }
-  return void 0;
+	if (patterns.web && mm.isMatch(filename, patterns.web)) {
+		return "web";
+	}
+	if (patterns.ssr && mm.isMatch(filename, patterns.ssr)) {
+		return "ssr";
+	}
+	return undefined;
 }
 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");
-      let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
-      if (!env) {
-        for (const [glob, target] of project.config.environmentMatchGlobs || []) {
-          if (mm.isMatch(filepath, glob, { cwd: project.config.root })) {
-            env = target;
-            break;
-          }
-        }
-      }
-      env ||= project.config.environment || "node";
-      const transformMode = getTransformMode(
-        project.config.testTransformMode,
-        filepath
-      );
-      let envOptionsJson = code.match(/@(?:vitest|jest)-environment-options\s+(.+)/)?.[1];
-      if (envOptionsJson?.endsWith("*/")) {
-        envOptionsJson = envOptionsJson.slice(0, -2);
-      }
-      const envOptions = JSON.parse(envOptionsJson || "null");
-      const envKey = env === "happy-dom" ? "happyDOM" : env;
-      const environment = {
-        name: env,
-        transformMode,
-        options: envOptions ? { [envKey]: envOptions } : null
-      };
-      return {
-        file: {
-          filepath,
-          testLocations: testLines
-        },
-        project,
-        environment
-      };
-    })
-  );
-  return groupBy(filesWithEnv, ({ environment }) => environment.name);
+	const filesWithEnv = await Promise.all(files.map(async ({ moduleId: filepath, project, testLines }) => {
+		const code = await promises$1.readFile(filepath, "utf-8");
+		let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
+		if (!env) {
+			for (const [glob, target] of project.config.environmentMatchGlobs || []) {
+				if (mm.isMatch(filepath, glob, { cwd: project.config.root })) {
+					env = target;
+					break;
+				}
+			}
+		}
+		env ||= project.config.environment || "node";
+		const transformMode = getTransformMode(project.config.testTransformMode, filepath);
+		let envOptionsJson = code.match(/@(?:vitest|jest)-environment-options\s+(.+)/)?.[1];
+		if (envOptionsJson?.endsWith("*/")) {
+			envOptionsJson = envOptionsJson.slice(0, -2);
+		}
+		const envOptions = JSON.parse(envOptionsJson || "null");
+		const envKey = env === "happy-dom" ? "happyDOM" : env;
+		const environment = {
+			name: env,
+			transformMode,
+			options: envOptions ? { [envKey]: envOptions } : null
+		};
+		return {
+			file: {
+				filepath,
+				testLocations: testLines
+			},
+			project,
+			environment
+		};
+	}));
+	return groupBy(filesWithEnv, ({ environment }) => environment.name);
 }
 
-const created = /* @__PURE__ */ new Set();
-const promises = /* @__PURE__ */ new Map();
+const created = new Set();
+const promises = new Map();
 function createMethodsRPC(project, options = {}) {
-  const ctx = project.vitest;
-  const cacheFs = options.cacheFs ?? false;
-  return {
-    snapshotSaved(snapshot) {
-      ctx.snapshot.add(snapshot);
-    },
-    resolveSnapshotPath(testPath) {
-      return ctx.snapshot.resolvePath(testPath, {
-        config: project.serializedConfig
-      });
-    },
-    async getSourceMap(id, force) {
-      if (force) {
-        const mod = project.vite.moduleGraph.getModuleById(id);
-        if (mod) {
-          project.vite.moduleGraph.invalidateModule(mod);
-        }
-      }
-      const r = await project.vitenode.transformRequest(id);
-      return r?.map;
-    },
-    async fetch(id, transformMode) {
-      const result = await project.vitenode.fetchResult(id, transformMode).catch(handleRollupError);
-      const code = result.code;
-      if (!cacheFs || result.externalize) {
-        return result;
-      }
-      if ("id" in result && typeof result.id === "string") {
-        return { id: result.id };
-      }
-      if (code == null) {
-        throw new Error(`Failed to fetch module ${id}`);
-      }
-      const dir = join(project.tmpDir, transformMode);
-      const name = hash("sha1", id, "hex");
-      const tmp = join(dir, name);
-      if (!created.has(dir)) {
-        mkdirSync(dir, { recursive: true });
-        created.add(dir);
-      }
-      if (promises.has(tmp)) {
-        await promises.get(tmp);
-        return { id: tmp };
-      }
-      promises.set(
-        tmp,
-        atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp))
-      );
-      await promises.get(tmp);
-      Object.assign(result, { id: tmp });
-      return { id: tmp };
-    },
-    resolveId(id, importer, transformMode) {
-      return project.vitenode.resolveId(id, importer, transformMode).catch(handleRollupError);
-    },
-    transform(id, environment) {
-      return project.vitenode.transformModule(id, environment).catch(handleRollupError);
-    },
-    async 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 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();
-    }
-  };
+	const ctx = project.vitest;
+	const cacheFs = options.cacheFs ?? false;
+	return {
+		snapshotSaved(snapshot) {
+			ctx.snapshot.add(snapshot);
+		},
+		resolveSnapshotPath(testPath) {
+			return ctx.snapshot.resolvePath(testPath, { config: project.serializedConfig });
+		},
+		async getSourceMap(id, force) {
+			if (force) {
+				const mod = project.vite.moduleGraph.getModuleById(id);
+				if (mod) {
+					project.vite.moduleGraph.invalidateModule(mod);
+				}
+			}
+			const r = await project.vitenode.transformRequest(id);
+			return r?.map;
+		},
+		async fetch(id, transformMode) {
+			const result = await project.vitenode.fetchResult(id, transformMode).catch(handleRollupError);
+			const code = result.code;
+			if (!cacheFs || result.externalize) {
+				return result;
+			}
+			if ("id" in result && typeof result.id === "string") {
+				return { id: result.id };
+			}
+			if (code == null) {
+				throw new Error(`Failed to fetch module ${id}`);
+			}
+			const dir = join(project.tmpDir, transformMode);
+			const name = hash("sha1", id, "hex");
+			const tmp = join(dir, name);
+			if (!created.has(dir)) {
+				mkdirSync(dir, { recursive: true });
+				created.add(dir);
+			}
+			if (promises.has(tmp)) {
+				await promises.get(tmp);
+				return { id: tmp };
+			}
+			promises.set(tmp, atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp)));
+			await promises.get(tmp);
+			Object.assign(result, { id: tmp });
+			return { id: tmp };
+		},
+		resolveId(id, importer, transformMode) {
+			return project.vitenode.resolveId(id, importer, transformMode).catch(handleRollupError);
+		},
+		transform(id, environment) {
+			return project.vitenode.transformModule(id, environment).catch(handleRollupError);
+		},
+		async 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 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 handleRollupError(e) {
-  if (e instanceof Error && ("plugin" in e || "frame" in e || "id" in e)) {
-    throw {
-      name: e.name,
-      message: e.message,
-      stack: e.stack,
-      cause: e.cause,
-      __vitest_rollup_error__: {
-        plugin: e.plugin,
-        id: e.id,
-        loc: e.loc,
-        frame: e.frame
-      }
-    };
-  }
-  throw e;
+	if (e instanceof Error && ("plugin" in e || "frame" in e || "id" in e)) {
+		throw {
+			name: e.name,
+			message: e.message,
+			stack: e.stack,
+			cause: e.cause,
+			__vitest_rollup_error__: {
+				plugin: e.plugin,
+				id: e.id,
+				loc: e.loc,
+				frame: e.frame
+			}
+		};
+	}
+	throw e;
 }
+/**
+* Performs an atomic write operation using the write-then-rename pattern.
+*
+* Why we need this:
+* - Ensures file integrity by never leaving partially written files on disk
+* - Prevents other processes from reading incomplete data during writes
+* - Particularly important for test files where incomplete writes could cause test failures
+*
+* The implementation writes to a temporary file first, then renames it to the target path.
+* This rename operation is atomic on most filesystems (including POSIX-compliant ones),
+* guaranteeing that other processes will only ever see the complete file.
+*
+* Added in https://github.com/vitest-dev/vitest/pull/7531
+*/
 async function atomicWriteFile(realFilePath, data) {
-  const dir = dirname(realFilePath);
-  const tmpFilePath = join(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  try {
-    await writeFile(tmpFilePath, data, "utf-8");
-    await rename(tmpFilePath, realFilePath);
-  } finally {
-    try {
-      if (await stat(tmpFilePath)) {
-        await unlink(tmpFilePath);
-      }
-    } catch {
-    }
-  }
+	const dir = dirname(realFilePath);
+	const tmpFilePath = join(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	try {
+		await writeFile(tmpFilePath, data, "utf-8");
+		await rename(tmpFilePath, realFilePath);
+	} finally {
+		try {
+			if (await stat(tmpFilePath)) {
+				await unlink(tmpFilePath);
+			}
+		} catch {}
+	}
 }
 
 function createChildProcessChannel$1(project, collect = false) {
-  const emitter = new EventEmitter();
-  const cleanup = () => emitter.removeAllListeners();
-  const events = { message: "message", response: "response" };
-  const channel = {
-    onMessage: (callback) => emitter.on(events.message, callback),
-    postMessage: (message) => emitter.emit(events.response, message)
-  };
-  const rpc = createBirpc(createMethodsRPC(project, { cacheFs: true, collect }), {
-    eventNames: ["onCancel"],
-    serialize: v8.serialize,
-    deserialize: (v) => v8.deserialize(Buffer.from(v)),
-    post(v) {
-      emitter.emit(events.message, v);
-    },
-    on(fn) {
-      emitter.on(events.response, fn);
-    },
-    onTimeoutError(functionName) {
-      throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-    }
-  });
-  project.ctx.onCancel((reason) => rpc.onCancel(reason));
-  return { channel, cleanup };
+	const emitter = new EventEmitter();
+	const cleanup = () => emitter.removeAllListeners();
+	const events = {
+		message: "message",
+		response: "response"
+	};
+	const channel = {
+		onMessage: (callback) => emitter.on(events.message, callback),
+		postMessage: (message) => emitter.emit(events.response, message)
+	};
+	const rpc = createBirpc(createMethodsRPC(project, {
+		cacheFs: true,
+		collect
+	}), {
+		eventNames: ["onCancel"],
+		serialize: v8.serialize,
+		deserialize: (v) => v8.deserialize(Buffer.from(v)),
+		post(v) {
+			emitter.emit(events.message, v);
+		},
+		on(fn) {
+			emitter.on(events.response, fn);
+		},
+		onTimeoutError(functionName) {
+			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
+		}
+	});
+	project.ctx.onCancel((reason) => rpc.onCancel(reason));
+	return {
+		channel,
+		cleanup
+	};
 }
 function createForksPool(ctx, { execArgv, env }) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-  const poolOptions = ctx.config.poolOptions?.forks ?? {};
-  const maxThreads = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount;
-  const minThreads = poolOptions.minForks ?? ctx.config.minWorkers ?? threadsCount;
-  const worker = resolve$1(ctx.distPath, "workers/forks.js");
-  const options = {
-    runtime: "child_process",
-    filename: resolve$1(ctx.distPath, "worker.js"),
-    maxThreads,
-    minThreads,
-    env,
-    execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
-    terminateTimeout: ctx.config.teardownTimeout,
-    concurrentTasksPerWorker: 1
-  };
-  const isolated = poolOptions.isolate ?? true;
-  if (isolated) {
-    options.isolateWorkers = true;
-  }
-  if (poolOptions.singleFork || !ctx.config.fileParallelism) {
-    options.maxThreads = 1;
-    options.minThreads = 1;
-  }
-  const pool = new Tinypool(options);
-  const runWithFiles = (name) => {
-    let id = 0;
-    async function runFiles(project, config, files, environment, invalidates = []) {
-      const paths = files.map((f) => f.filepath);
-      ctx.state.clearFiles(project, paths);
-      const { channel, cleanup } = createChildProcessChannel$1(project, name === "collect");
-      const workerId = ++id;
-      const data = {
-        pool: "forks",
-        worker,
-        config,
-        files,
-        invalidates,
-        environment,
-        workerId,
-        projectName: project.name,
-        providedContext: project.getProvidedContext()
-      };
-      try {
-        await pool.run(data, { name, channel });
-      } catch (error) {
-        if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-          ctx.state.addProcessTimeoutCause(
-            `Failed to terminate worker while running ${paths.join(", ")}.`
-          );
-        } else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-          ctx.state.cancelFiles(paths, project);
-        } else {
-          throw error;
-        }
-      } finally {
-        cleanup();
-      }
-    }
-    return async (specs, invalidates) => {
-      ctx.onCancel(() => pool.cancelPendingTasks());
-      const configs = /* @__PURE__ */ new WeakMap();
-      const getConfig = (project) => {
-        if (configs.has(project)) {
-          return configs.get(project);
-        }
-        const _config = project.getSerializableConfig();
-        const config = wrapSerializableConfig(_config);
-        configs.set(project, config);
-        return config;
-      };
-      const singleFork = specs.filter(
-        (spec) => spec.project.config.poolOptions?.forks?.singleFork
-      );
-      const multipleForks = specs.filter(
-        (spec) => !spec.project.config.poolOptions?.forks?.singleFork
-      );
-      if (multipleForks.length) {
-        const filesByEnv = await groupFilesByEnv(multipleForks);
-        const files = Object.values(filesByEnv).flat();
-        const results = [];
-        if (isolated) {
-          results.push(
-            ...await Promise.allSettled(
-              files.map(
-                ({ file, environment, project }) => runFiles(
-                  project,
-                  getConfig(project),
-                  [file],
-                  environment,
-                  invalidates
-                )
-              )
-            )
-          );
-        } else {
-          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(
-              (resolve2) => pool.queueSize === 0 ? resolve2() : pool.once("drain", resolve2)
-            );
-            await pool.recycleWorkers();
-          }
-        }
-        const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-        if (errors.length > 0) {
-          throw new AggregateError(
-            errors,
-            "Errors occurred while running tests. For more information, see serialized error."
-          );
-        }
-      }
-      if (singleFork.length) {
-        const filesByEnv = await groupFilesByEnv(singleFork);
-        const envs = envsOrder.concat(
-          Object.keys(filesByEnv).filter((env2) => !envsOrder.includes(env2))
-        );
-        for (const env2 of envs) {
-          const files = filesByEnv[env2];
-          if (!files?.length) {
-            continue;
-          }
-          const filesByOptions = groupBy(
-            files,
-            ({ project, environment }) => project.name + JSON.stringify(environment.options)
-          );
-          for (const files2 of Object.values(filesByOptions)) {
-            await pool.recycleWorkers();
-            const filenames = files2.map((f) => f.file);
-            await runFiles(
-              files2[0].project,
-              getConfig(files2[0].project),
-              filenames,
-              files2[0].environment,
-              invalidates
-            );
-          }
-        }
-      }
-    };
-  };
-  return {
-    name: "forks",
-    runTests: runWithFiles("run"),
-    collectTests: runWithFiles("collect"),
-    close: () => pool.destroy()
-  };
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
+	const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const poolOptions = ctx.config.poolOptions?.forks ?? {};
+	const maxThreads = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount;
+	const minThreads = poolOptions.minForks ?? ctx.config.minWorkers ?? threadsCount;
+	const worker = resolve$1(ctx.distPath, "workers/forks.js");
+	const options = {
+		runtime: "child_process",
+		filename: resolve$1(ctx.distPath, "worker.js"),
+		maxThreads,
+		minThreads,
+		env,
+		execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
+		terminateTimeout: ctx.config.teardownTimeout,
+		concurrentTasksPerWorker: 1
+	};
+	const isolated = poolOptions.isolate ?? true;
+	if (isolated) {
+		options.isolateWorkers = true;
+	}
+	if (poolOptions.singleFork || !ctx.config.fileParallelism) {
+		options.maxThreads = 1;
+		options.minThreads = 1;
+	}
+	const pool = new Tinypool(options);
+	const runWithFiles = (name) => {
+		let id = 0;
+		async function runFiles(project, config, files, environment, invalidates = []) {
+			const paths = files.map((f) => f.filepath);
+			ctx.state.clearFiles(project, paths);
+			const { channel, cleanup } = createChildProcessChannel$1(project, name === "collect");
+			const workerId = ++id;
+			const data = {
+				pool: "forks",
+				worker,
+				config,
+				files,
+				invalidates,
+				environment,
+				workerId,
+				projectName: project.name,
+				providedContext: project.getProvidedContext()
+			};
+			try {
+				await pool.run(data, {
+					name,
+					channel
+				});
+			} catch (error) {
+				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
+					ctx.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}.`);
+				} else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
+					ctx.state.cancelFiles(paths, project);
+				} else {
+					throw error;
+				}
+			} finally {
+				cleanup();
+			}
+		}
+		return async (specs, invalidates) => {
+			ctx.onCancel(() => pool.cancelPendingTasks());
+			const configs = new WeakMap();
+			const getConfig = (project) => {
+				if (configs.has(project)) {
+					return configs.get(project);
+				}
+				const _config = project.getSerializableConfig();
+				const config = wrapSerializableConfig(_config);
+				configs.set(project, config);
+				return config;
+			};
+			const singleFork = specs.filter((spec) => spec.project.config.poolOptions?.forks?.singleFork);
+			const multipleForks = specs.filter((spec) => !spec.project.config.poolOptions?.forks?.singleFork);
+			if (multipleForks.length) {
+				const filesByEnv = await groupFilesByEnv(multipleForks);
+				const files = Object.values(filesByEnv).flat();
+				const results = [];
+				if (isolated) {
+					results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+				} else {
+					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);
+				const 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)) {
+						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();
-  const port = channel.port2;
-  const workerPort = channel.port1;
-  const rpc = createBirpc(createMethodsRPC(project, { collect }), {
-    eventNames: ["onCancel"],
-    post(v) {
-      port.postMessage(v);
-    },
-    on(fn) {
-      port.on("message", fn);
-    },
-    onTimeoutError(functionName) {
-      throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-    }
-  });
-  project.ctx.onCancel((reason) => rpc.onCancel(reason));
-  return { workerPort, port };
+	const channel = new MessageChannel();
+	const port = channel.port2;
+	const workerPort = channel.port1;
+	const rpc = createBirpc(createMethodsRPC(project, { collect }), {
+		eventNames: ["onCancel"],
+		post(v) {
+			port.postMessage(v);
+		},
+		on(fn) {
+			port.on("message", fn);
+		},
+		onTimeoutError(functionName) {
+			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
+		}
+	});
+	project.ctx.onCancel((reason) => rpc.onCancel(reason));
+	return {
+		workerPort,
+		port
+	};
 }
 function createThreadsPool(ctx, { execArgv, env }) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-  const poolOptions = ctx.config.poolOptions?.threads ?? {};
-  const maxThreads = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount;
-  const minThreads = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount;
-  const worker = resolve$1(ctx.distPath, "workers/threads.js");
-  const options = {
-    filename: resolve$1(ctx.distPath, "worker.js"),
-    // TODO: investigate further
-    // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
-    useAtomics: poolOptions.useAtomics ?? false,
-    maxThreads,
-    minThreads,
-    env,
-    execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
-    terminateTimeout: ctx.config.teardownTimeout,
-    concurrentTasksPerWorker: 1
-  };
-  const isolated = poolOptions.isolate ?? true;
-  if (isolated) {
-    options.isolateWorkers = true;
-  }
-  if (poolOptions.singleThread || !ctx.config.fileParallelism) {
-    options.maxThreads = 1;
-    options.minThreads = 1;
-  }
-  const pool = new Tinypool$1(options);
-  const runWithFiles = (name) => {
-    let id = 0;
-    async function runFiles(project, config, files, environment, invalidates = []) {
-      const paths = files.map((f) => f.filepath);
-      ctx.state.clearFiles(project, paths);
-      const { workerPort, port } = createWorkerChannel$1(project, name === "collect");
-      const workerId = ++id;
-      const 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 });
-      } catch (error) {
-        if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-          ctx.state.addProcessTimeoutCause(
-            `Failed to terminate worker while running ${paths.join(
-              ", "
-            )}. 
-See https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`
-          );
-        } else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-          ctx.state.cancelFiles(paths, project);
-        } else {
-          throw error;
-        }
-      } finally {
-        port.close();
-        workerPort.close();
-      }
-    }
-    return async (specs, invalidates) => {
-      ctx.onCancel(() => pool.cancelPendingTasks());
-      const configs = /* @__PURE__ */ new WeakMap();
-      const getConfig = (project) => {
-        if (configs.has(project)) {
-          return configs.get(project);
-        }
-        const config = project.getSerializableConfig();
-        configs.set(project, config);
-        return config;
-      };
-      const singleThreads = specs.filter(
-        (spec) => spec.project.config.poolOptions?.threads?.singleThread
-      );
-      const multipleThreads = specs.filter(
-        (spec) => !spec.project.config.poolOptions?.threads?.singleThread
-      );
-      if (multipleThreads.length) {
-        const filesByEnv = await groupFilesByEnv(multipleThreads);
-        const files = Object.values(filesByEnv).flat();
-        const results = [];
-        if (isolated) {
-          results.push(
-            ...await Promise.allSettled(
-              files.map(
-                ({ file, environment, project }) => runFiles(
-                  project,
-                  getConfig(project),
-                  [file],
-                  environment,
-                  invalidates
-                )
-              )
-            )
-          );
-        } else {
-          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(
-              (resolve2) => pool.queueSize === 0 ? resolve2() : pool.once("drain", resolve2)
-            );
-            await pool.recycleWorkers();
-          }
-        }
-        const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-        if (errors.length > 0) {
-          throw new AggregateError(
-            errors,
-            "Errors occurred while running tests. For more information, see serialized error."
-          );
-        }
-      }
-      if (singleThreads.length) {
-        const filesByEnv = await groupFilesByEnv(singleThreads);
-        const envs = envsOrder.concat(
-          Object.keys(filesByEnv).filter((env2) => !envsOrder.includes(env2))
-        );
-        for (const env2 of envs) {
-          const files = filesByEnv[env2];
-          if (!files?.length) {
-            continue;
-          }
-          const filesByOptions = groupBy(
-            files,
-            ({ project, environment }) => project.name + JSON.stringify(environment.options)
-          );
-          for (const files2 of Object.values(filesByOptions)) {
-            await pool.recycleWorkers();
-            const filenames = files2.map((f) => f.file);
-            await runFiles(
-              files2[0].project,
-              getConfig(files2[0].project),
-              filenames,
-              files2[0].environment,
-              invalidates
-            );
-          }
-        }
-      }
-    };
-  };
-  return {
-    name: "threads",
-    runTests: runWithFiles("run"),
-    collectTests: runWithFiles("collect"),
-    close: () => pool.destroy()
-  };
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
+	const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const poolOptions = ctx.config.poolOptions?.threads ?? {};
+	const maxThreads = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount;
+	const minThreads = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount;
+	const worker = resolve$1(ctx.distPath, "workers/threads.js");
+	const options = {
+		filename: resolve$1(ctx.distPath, "worker.js"),
+		useAtomics: poolOptions.useAtomics ?? false,
+		maxThreads,
+		minThreads,
+		env,
+		execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
+		terminateTimeout: ctx.config.teardownTimeout,
+		concurrentTasksPerWorker: 1
+	};
+	const isolated = poolOptions.isolate ?? true;
+	if (isolated) {
+		options.isolateWorkers = true;
+	}
+	if (poolOptions.singleThread || !ctx.config.fileParallelism) {
+		options.maxThreads = 1;
+		options.minThreads = 1;
+	}
+	const pool = new Tinypool$1(options);
+	const runWithFiles = (name) => {
+		let id = 0;
+		async function runFiles(project, config, files, environment, invalidates = []) {
+			const paths = files.map((f) => f.filepath);
+			ctx.state.clearFiles(project, paths);
+			const { workerPort, port } = createWorkerChannel$1(project, name === "collect");
+			const workerId = ++id;
+			const 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
+				});
+			} catch (error) {
+				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
+					ctx.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 (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
+					ctx.state.cancelFiles(paths, project);
+				} else {
+					throw error;
+				}
+			} finally {
+				port.close();
+				workerPort.close();
+			}
+		}
+		return async (specs, invalidates) => {
+			ctx.onCancel(() => pool.cancelPendingTasks());
+			const configs = new WeakMap();
+			const getConfig = (project) => {
+				if (configs.has(project)) {
+					return configs.get(project);
+				}
+				const config = project.getSerializableConfig();
+				configs.set(project, config);
+				return config;
+			};
+			const singleThreads = specs.filter((spec) => spec.project.config.poolOptions?.threads?.singleThread);
+			const multipleThreads = specs.filter((spec) => !spec.project.config.poolOptions?.threads?.singleThread);
+			if (multipleThreads.length) {
+				const filesByEnv = await groupFilesByEnv(multipleThreads);
+				const files = Object.values(filesByEnv).flat();
+				const results = [];
+				if (isolated) {
+					results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+				} else {
+					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);
+				const 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)) {
+						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(ctx) {
-  const promisesMap = /* @__PURE__ */ new WeakMap();
-  const rerunTriggered = /* @__PURE__ */ new WeakSet();
-  async function onParseEnd(project, { files, sourceErrors }) {
-    const checker = project.typechecker;
-    const { packs, events } = checker.getTestPacksAndEvents();
-    await ctx._testRun.updated(packs, events);
-    if (!project.config.typecheck.ignoreSourceErrors) {
-      sourceErrors.forEach(
-        (error) => ctx.state.catchError(error, "Unhandled Source Error")
-      );
-    }
-    const processError = !hasFailed(files) && !sourceErrors.length && checker.getExitCode();
-    if (processError) {
-      const error = new Error(checker.getOutput());
-      error.stack = "";
-      ctx.state.catchError(error, "Typecheck Error");
-    }
-    promisesMap.get(project)?.resolve();
-    rerunTriggered.delete(project);
-    if (ctx.config.watch && !ctx.runningPromise) {
-      await ctx.report("onFinished", files, []);
-      await ctx.report("onWatcherStart", files, [
-        ...project.config.typecheck.ignoreSourceErrors ? [] : sourceErrors,
-        ...ctx.state.getUnhandledErrors()
-      ]);
-    }
-  }
-  async function createWorkspaceTypechecker(project, files) {
-    const checker = project.typechecker ?? new Typechecker(project);
-    if (project.typechecker) {
-      return checker;
-    }
-    project.typechecker = checker;
-    checker.setFiles(files);
-    checker.onParseStart(async () => {
-      const files2 = checker.getTestFiles();
-      for (const file of files2) {
-        await ctx._testRun.enqueued(project, file);
-      }
-      await ctx._testRun.collected(project, files2);
-    });
-    checker.onParseEnd((result) => onParseEnd(project, result));
-    checker.onWatcherRerun(async () => {
-      rerunTriggered.add(project);
-      if (!ctx.runningPromise) {
-        ctx.state.clearErrors();
-        await ctx.report(
-          "onWatcherRerun",
-          files,
-          "File change detected. Triggering rerun."
-        );
-      }
-      await checker.collectTests();
-      const testFiles = checker.getTestFiles();
-      for (const file of testFiles) {
-        await ctx._testRun.enqueued(project, file);
-      }
-      await ctx._testRun.collected(project, testFiles);
-      const { packs, events } = checker.getTestPacksAndEvents();
-      await ctx._testRun.updated(packs, events);
-    });
-    await checker.prepare();
-    return checker;
-  }
-  async function startTypechecker(project, files) {
-    if (project.typechecker) {
-      return project.typechecker;
-    }
-    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;
-      const files = specsByProject[name].map((spec) => spec.moduleId);
-      const checker = await createWorkspaceTypechecker(project, files);
-      checker.setFiles(files);
-      await checker.collectTests();
-      const testFiles = checker.getTestFiles();
-      for (const file of testFiles) {
-        await ctx._testRun.enqueued(project, file);
-      }
-      await ctx._testRun.collected(project, testFiles);
-    }
-  }
-  async function runTests(specs) {
-    const specsByProject = groupBy(specs, (spec) => spec.project.name);
-    const promises = [];
-    for (const name in specsByProject) {
-      const project = specsByProject[name][0].project;
-      const files = specsByProject[name].map((spec) => spec.moduleId);
-      const promise = createDefer();
-      const _p = new Promise((resolve) => {
-        const _i = setInterval(() => {
-          if (!project.typechecker || rerunTriggered.has(project)) {
-            resolve(true);
-            clearInterval(_i);
-          }
-        });
-        setTimeout(() => {
-          resolve(false);
-          clearInterval(_i);
-        }, 500).unref();
-      });
-      const triggered = await _p;
-      if (project.typechecker && !triggered) {
-        const testFiles = project.typechecker.getTestFiles();
-        for (const file of testFiles) {
-          await ctx._testRun.enqueued(project, file);
-        }
-        await ctx._testRun.collected(project, testFiles);
-        await onParseEnd(project, project.typechecker.getResult());
-        continue;
-      }
-      promises.push(promise);
-      promisesMap.set(project, promise);
-      startTypechecker(project, files);
-    }
-    await Promise.all(promises);
-  }
-  return {
-    name: "typescript",
-    runTests,
-    collectTests,
-    async close() {
-      const promises = ctx.projects.map(
-        (project) => project.typechecker?.stop()
-      );
-      await Promise.all(promises);
-    }
-  };
+	const promisesMap = new WeakMap();
+	const rerunTriggered = new WeakSet();
+	async function onParseEnd(project, { files, sourceErrors }) {
+		const checker = project.typechecker;
+		const { packs, events } = checker.getTestPacksAndEvents();
+		await ctx._testRun.updated(packs, events);
+		if (!project.config.typecheck.ignoreSourceErrors) {
+			sourceErrors.forEach((error) => ctx.state.catchError(error, "Unhandled Source Error"));
+		}
+		const processError = !hasFailed(files) && !sourceErrors.length && checker.getExitCode();
+		if (processError) {
+			const error = new Error(checker.getOutput());
+			error.stack = "";
+			ctx.state.catchError(error, "Typecheck Error");
+		}
+		promisesMap.get(project)?.resolve();
+		rerunTriggered.delete(project);
+		if (ctx.config.watch && !ctx.runningPromise) {
+			await ctx.report("onFinished", files, []);
+			await ctx.report("onWatcherStart", files, [...project.config.typecheck.ignoreSourceErrors ? [] : sourceErrors, ...ctx.state.getUnhandledErrors()]);
+		}
+	}
+	async function createWorkspaceTypechecker(project, files) {
+		const checker = project.typechecker ?? new Typechecker(project);
+		if (project.typechecker) {
+			return checker;
+		}
+		project.typechecker = checker;
+		checker.setFiles(files);
+		checker.onParseStart(async () => {
+			const files = checker.getTestFiles();
+			for (const file of files) {
+				await ctx._testRun.enqueued(project, file);
+			}
+			await ctx._testRun.collected(project, files);
+		});
+		checker.onParseEnd((result) => onParseEnd(project, result));
+		checker.onWatcherRerun(async () => {
+			rerunTriggered.add(project);
+			if (!ctx.runningPromise) {
+				ctx.state.clearErrors();
+				await ctx.report("onWatcherRerun", files, "File change detected. Triggering rerun.");
+			}
+			await checker.collectTests();
+			const testFiles = checker.getTestFiles();
+			for (const file of testFiles) {
+				await ctx._testRun.enqueued(project, file);
+			}
+			await ctx._testRun.collected(project, testFiles);
+			const { packs, events } = checker.getTestPacksAndEvents();
+			await ctx._testRun.updated(packs, events);
+		});
+		await checker.prepare();
+		return checker;
+	}
+	async function startTypechecker(project, files) {
+		if (project.typechecker) {
+			return project.typechecker;
+		}
+		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;
+			const files = specsByProject[name].map((spec) => spec.moduleId);
+			const checker = await createWorkspaceTypechecker(project, files);
+			checker.setFiles(files);
+			await checker.collectTests();
+			const testFiles = checker.getTestFiles();
+			for (const file of testFiles) {
+				await ctx._testRun.enqueued(project, file);
+			}
+			await ctx._testRun.collected(project, testFiles);
+		}
+	}
+	async function runTests(specs) {
+		const specsByProject = groupBy(specs, (spec) => spec.project.name);
+		const promises = [];
+		for (const name in specsByProject) {
+			const project = specsByProject[name][0].project;
+			const files = specsByProject[name].map((spec) => spec.moduleId);
+			const promise = createDefer();
+			const _p = new Promise((resolve) => {
+				const _i = setInterval(() => {
+					if (!project.typechecker || rerunTriggered.has(project)) {
+						resolve(true);
+						clearInterval(_i);
+					}
+				});
+				setTimeout(() => {
+					resolve(false);
+					clearInterval(_i);
+				}, 500).unref();
+			});
+			const triggered = await _p;
+			if (project.typechecker && !triggered) {
+				const testFiles = project.typechecker.getTestFiles();
+				for (const file of testFiles) {
+					await ctx._testRun.enqueued(project, file);
+				}
+				await ctx._testRun.collected(project, testFiles);
+				await onParseEnd(project, project.typechecker.getResult());
+				continue;
+			}
+			promises.push(promise);
+			promisesMap.set(project, promise);
+			startTypechecker(project, files);
+		}
+		await Promise.all(promises);
+	}
+	return {
+		name: "typescript",
+		runTests,
+		collectTests,
+		async close() {
+			const promises = ctx.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);
+	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) {
-  const memoryLimit = config.poolOptions?.vmThreads?.memoryLimit;
-  if (memoryLimit) {
-    return memoryLimit;
-  }
-  return 1 / (config.poolOptions?.vmThreads?.maxThreads ?? getDefaultThreadsCount(config));
+	const memoryLimit = config.poolOptions?.vmThreads?.memoryLimit;
+	if (memoryLimit) {
+		return memoryLimit;
+	}
+	return 1 / (config.poolOptions?.vmThreads?.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);
-        trailingChars = trailingChars.toLowerCase();
-        switch (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);
-      } else {
-        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;
+	if (input === null || input === undefined) {
+		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);
+				trailingChars = trailingChars.toLowerCase();
+				switch (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);
+			} else {
+				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$1(rootDir, "./suppress-warnings.cjs");
 function createChildProcessChannel(project, collect) {
-  const emitter = new EventEmitter();
-  const cleanup = () => emitter.removeAllListeners();
-  const events = { message: "message", response: "response" };
-  const channel = {
-    onMessage: (callback) => emitter.on(events.message, callback),
-    postMessage: (message) => emitter.emit(events.response, message)
-  };
-  const rpc = createBirpc(
-    createMethodsRPC(project, { cacheFs: true, collect }),
-    {
-      eventNames: ["onCancel"],
-      serialize: v8.serialize,
-      deserialize: (v) => v8.deserialize(Buffer.from(v)),
-      post(v) {
-        emitter.emit(events.message, v);
-      },
-      on(fn) {
-        emitter.on(events.response, fn);
-      },
-      onTimeoutError(functionName) {
-        throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-      }
-    }
-  );
-  project.ctx.onCancel((reason) => rpc.onCancel(reason));
-  return { channel, cleanup };
+	const emitter = new EventEmitter();
+	const cleanup = () => emitter.removeAllListeners();
+	const events = {
+		message: "message",
+		response: "response"
+	};
+	const channel = {
+		onMessage: (callback) => emitter.on(events.message, callback),
+		postMessage: (message) => emitter.emit(events.response, message)
+	};
+	const rpc = createBirpc(createMethodsRPC(project, {
+		cacheFs: true,
+		collect
+	}), {
+		eventNames: ["onCancel"],
+		serialize: v8.serialize,
+		deserialize: (v) => v8.deserialize(Buffer.from(v)),
+		post(v) {
+			emitter.emit(events.message, v);
+		},
+		on(fn) {
+			emitter.on(events.response, fn);
+		},
+		onTimeoutError(functionName) {
+			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
+		}
+	});
+	project.ctx.onCancel((reason) => rpc.onCancel(reason));
+	return {
+		channel,
+		cleanup
+	};
 }
 function createVmForksPool(ctx, { execArgv, env }) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-  const poolOptions = ctx.config.poolOptions?.vmForks ?? {};
-  const maxThreads = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount;
-  const minThreads = poolOptions.maxForks ?? ctx.config.minWorkers ?? threadsCount;
-  const worker = resolve$1(ctx.distPath, "workers/vmForks.js");
-  const options = {
-    runtime: "child_process",
-    filename: resolve$1(ctx.distPath, "worker.js"),
-    maxThreads,
-    minThreads,
-    env,
-    execArgv: [
-      "--experimental-import-meta-resolve",
-      "--experimental-vm-modules",
-      "--require",
-      suppressWarningsPath$1,
-      ...poolOptions.execArgv ?? [],
-      ...execArgv
-    ],
-    terminateTimeout: ctx.config.teardownTimeout,
-    concurrentTasksPerWorker: 1,
-    maxMemoryLimitBeforeRecycle: getMemoryLimit$1(ctx.config) || void 0
-  };
-  if (poolOptions.singleFork || !ctx.config.fileParallelism) {
-    options.maxThreads = 1;
-    options.minThreads = 1;
-  }
-  const pool = new Tinypool$1(options);
-  const runWithFiles = (name) => {
-    let id = 0;
-    async function runFiles(project, config, files, environment, invalidates = []) {
-      const paths = files.map((f) => f.filepath);
-      ctx.state.clearFiles(project, paths);
-      const { channel, cleanup } = createChildProcessChannel(project, name === "collect");
-      const workerId = ++id;
-      const data = {
-        pool: "forks",
-        worker,
-        config,
-        files,
-        invalidates,
-        environment,
-        workerId,
-        projectName: project.name,
-        providedContext: project.getProvidedContext()
-      };
-      try {
-        await pool.run(data, { name, channel });
-      } catch (error) {
-        if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-          ctx.state.addProcessTimeoutCause(
-            `Failed to terminate worker while running ${paths.join(", ")}.`
-          );
-        } else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-          ctx.state.cancelFiles(paths, project);
-        } else {
-          throw error;
-        }
-      } finally {
-        cleanup();
-      }
-    }
-    return async (specs, invalidates) => {
-      ctx.onCancel(() => pool.cancelPendingTasks());
-      const configs = /* @__PURE__ */ new Map();
-      const getConfig = (project) => {
-        if (configs.has(project)) {
-          return configs.get(project);
-        }
-        const _config = project.getSerializableConfig();
-        const config = wrapSerializableConfig(_config);
-        configs.set(project, config);
-        return config;
-      };
-      const filesByEnv = await groupFilesByEnv(specs);
-      const promises = Object.values(filesByEnv).flat();
-      const results = await Promise.allSettled(
-        promises.map(
-          ({ file, environment, project }) => runFiles(
-            project,
-            getConfig(project),
-            [file],
-            environment,
-            invalidates
-          )
-        )
-      );
-      const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-      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();
-  const limit = getWorkerMemoryLimit(config);
-  if (typeof memory === "number") {
-    return stringToBytes(limit, config.watch ? memory / 2 : memory);
-  }
-  if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") {
-    return stringToBytes(limit);
-  }
-  return null;
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
+	const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const poolOptions = ctx.config.poolOptions?.vmForks ?? {};
+	const maxThreads = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount;
+	const minThreads = poolOptions.maxForks ?? ctx.config.minWorkers ?? threadsCount;
+	const worker = resolve$1(ctx.distPath, "workers/vmForks.js");
+	const options = {
+		runtime: "child_process",
+		filename: resolve$1(ctx.distPath, "worker.js"),
+		maxThreads,
+		minThreads,
+		env,
+		execArgv: [
+			"--experimental-import-meta-resolve",
+			"--experimental-vm-modules",
+			"--require",
+			suppressWarningsPath$1,
+			...poolOptions.execArgv ?? [],
+			...execArgv
+		],
+		terminateTimeout: ctx.config.teardownTimeout,
+		concurrentTasksPerWorker: 1,
+		maxMemoryLimitBeforeRecycle: getMemoryLimit$1(ctx.config) || undefined
+	};
+	if (poolOptions.singleFork || !ctx.config.fileParallelism) {
+		options.maxThreads = 1;
+		options.minThreads = 1;
+	}
+	const pool = new Tinypool$1(options);
+	const runWithFiles = (name) => {
+		let id = 0;
+		async function runFiles(project, config, files, environment, invalidates = []) {
+			const paths = files.map((f) => f.filepath);
+			ctx.state.clearFiles(project, paths);
+			const { channel, cleanup } = createChildProcessChannel(project, name === "collect");
+			const workerId = ++id;
+			const data = {
+				pool: "forks",
+				worker,
+				config,
+				files,
+				invalidates,
+				environment,
+				workerId,
+				projectName: project.name,
+				providedContext: project.getProvidedContext()
+			};
+			try {
+				await pool.run(data, {
+					name,
+					channel
+				});
+			} catch (error) {
+				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
+					ctx.state.addProcessTimeoutCause(`Failed to terminate worker while running ${paths.join(", ")}.`);
+				} else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
+					ctx.state.cancelFiles(paths, project);
+				} else {
+					throw error;
+				}
+			} finally {
+				cleanup();
+			}
+		}
+		return async (specs, invalidates) => {
+			ctx.onCancel(() => pool.cancelPendingTasks());
+			const configs = new Map();
+			const getConfig = (project) => {
+				if (configs.has(project)) {
+					return configs.get(project);
+				}
+				const _config = project.getSerializableConfig();
+				const config = wrapSerializableConfig(_config);
+				configs.set(project, config);
+				return config;
+			};
+			const filesByEnv = await groupFilesByEnv(specs);
+			const promises = Object.values(filesByEnv).flat();
+			const results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)));
+			const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+			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();
+	const limit = getWorkerMemoryLimit(config);
+	if (typeof memory === "number") {
+		return stringToBytes(limit, config.watch ? memory / 2 : memory);
+	}
+	if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") {
+		return stringToBytes(limit);
+	}
+	return null;
 }
 
 const suppressWarningsPath = resolve$1(rootDir, "./suppress-warnings.cjs");
 function createWorkerChannel(project, collect) {
-  const channel = new MessageChannel();
-  const port = channel.port2;
-  const workerPort = channel.port1;
-  const rpc = createBirpc(createMethodsRPC(project, { collect }), {
-    eventNames: ["onCancel"],
-    post(v) {
-      port.postMessage(v);
-    },
-    on(fn) {
-      port.on("message", fn);
-    },
-    onTimeoutError(functionName) {
-      throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-    }
-  });
-  project.ctx.onCancel((reason) => rpc.onCancel(reason));
-  return { workerPort, port };
+	const channel = new MessageChannel();
+	const port = channel.port2;
+	const workerPort = channel.port1;
+	const rpc = createBirpc(createMethodsRPC(project, { collect }), {
+		eventNames: ["onCancel"],
+		post(v) {
+			port.postMessage(v);
+		},
+		on(fn) {
+			port.on("message", fn);
+		},
+		onTimeoutError(functionName) {
+			throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
+		}
+	});
+	project.ctx.onCancel((reason) => rpc.onCancel(reason));
+	return {
+		workerPort,
+		port
+	};
 }
 function createVmThreadsPool(ctx, { execArgv, env }) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-  const poolOptions = ctx.config.poolOptions?.vmThreads ?? {};
-  const maxThreads = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount;
-  const minThreads = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount;
-  const worker = resolve$1(ctx.distPath, "workers/vmThreads.js");
-  const options = {
-    filename: resolve$1(ctx.distPath, "worker.js"),
-    // TODO: investigate further
-    // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
-    useAtomics: poolOptions.useAtomics ?? false,
-    maxThreads,
-    minThreads,
-    env,
-    execArgv: [
-      "--experimental-import-meta-resolve",
-      "--experimental-vm-modules",
-      "--require",
-      suppressWarningsPath,
-      ...poolOptions.execArgv ?? [],
-      ...execArgv
-    ],
-    terminateTimeout: ctx.config.teardownTimeout,
-    concurrentTasksPerWorker: 1,
-    maxMemoryLimitBeforeRecycle: getMemoryLimit(ctx.config) || void 0
-  };
-  if (poolOptions.singleThread || !ctx.config.fileParallelism) {
-    options.maxThreads = 1;
-    options.minThreads = 1;
-  }
-  const pool = new Tinypool$1(options);
-  const runWithFiles = (name) => {
-    let id = 0;
-    async function runFiles(project, config, files, environment, invalidates = []) {
-      const paths = files.map((f) => f.filepath);
-      ctx.state.clearFiles(project, paths);
-      const { workerPort, port } = createWorkerChannel(project, name === "collect");
-      const workerId = ++id;
-      const 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) {
-        if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-          ctx.state.addProcessTimeoutCause(
-            `Failed to terminate worker while running ${paths.join(
-              ", "
-            )}. 
-See https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`
-          );
-        } else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-          ctx.state.cancelFiles(paths, project);
-        } else {
-          throw error;
-        }
-      } finally {
-        port.close();
-        workerPort.close();
-      }
-    }
-    return async (specs, invalidates) => {
-      ctx.onCancel(() => pool.cancelPendingTasks());
-      const configs = /* @__PURE__ */ new Map();
-      const getConfig = (project) => {
-        if (configs.has(project)) {
-          return configs.get(project);
-        }
-        const config = project.serializedConfig;
-        configs.set(project, config);
-        return config;
-      };
-      const filesByEnv = await groupFilesByEnv(specs);
-      const promises = Object.values(filesByEnv).flat();
-      const results = await Promise.allSettled(
-        promises.map(
-          ({ file, environment, project }) => runFiles(
-            project,
-            getConfig(project),
-            [file],
-            environment,
-            invalidates
-          )
-        )
-      );
-      const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-      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()
-  };
+	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
+	const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
+	const poolOptions = ctx.config.poolOptions?.vmThreads ?? {};
+	const maxThreads = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount;
+	const minThreads = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount;
+	const worker = resolve$1(ctx.distPath, "workers/vmThreads.js");
+	const options = {
+		filename: resolve$1(ctx.distPath, "worker.js"),
+		useAtomics: poolOptions.useAtomics ?? false,
+		maxThreads,
+		minThreads,
+		env,
+		execArgv: [
+			"--experimental-import-meta-resolve",
+			"--experimental-vm-modules",
+			"--require",
+			suppressWarningsPath,
+			...poolOptions.execArgv ?? [],
+			...execArgv
+		],
+		terminateTimeout: ctx.config.teardownTimeout,
+		concurrentTasksPerWorker: 1,
+		maxMemoryLimitBeforeRecycle: getMemoryLimit(ctx.config) || undefined
+	};
+	if (poolOptions.singleThread || !ctx.config.fileParallelism) {
+		options.maxThreads = 1;
+		options.minThreads = 1;
+	}
+	const pool = new Tinypool$1(options);
+	const runWithFiles = (name) => {
+		let id = 0;
+		async function runFiles(project, config, files, environment, invalidates = []) {
+			const paths = files.map((f) => f.filepath);
+			ctx.state.clearFiles(project, paths);
+			const { workerPort, port } = createWorkerChannel(project, name === "collect");
+			const workerId = ++id;
+			const 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) {
+				if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
+					ctx.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 (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
+					ctx.state.cancelFiles(paths, project);
+				} else {
+					throw error;
+				}
+			} finally {
+				port.close();
+				workerPort.close();
+			}
+		}
+		return async (specs, invalidates) => {
+			ctx.onCancel(() => pool.cancelPendingTasks());
+			const configs = new Map();
+			const getConfig = (project) => {
+				if (configs.has(project)) {
+					return configs.get(project);
+				}
+				const config = project.serializedConfig;
+				configs.set(project, config);
+				return config;
+			};
+			const filesByEnv = await groupFilesByEnv(specs);
+			const promises = Object.values(filesByEnv).flat();
+			const results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)));
+			const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+			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();
-  const limit = getWorkerMemoryLimit(config);
-  if (typeof memory === "number") {
-    return stringToBytes(limit, config.watch ? memory / 2 : memory);
-  }
-  if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") {
-    return stringToBytes(limit);
-  }
-  return null;
+	const memory = nodeos.totalmem();
+	const limit = getWorkerMemoryLimit(config);
+	if (typeof memory === "number") {
+		return stringToBytes(limit, config.watch ? memory / 2 : memory);
+	}
+	if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") {
+		return stringToBytes(limit);
+	}
+	return null;
 }
 
 const builtinPools = [
-  "forks",
-  "threads",
-  "browser",
-  "vmThreads",
-  "vmForks",
-  "typescript"
+	"forks",
+	"threads",
+	"browser",
+	"vmThreads",
+	"vmForks",
+	"typescript"
 ];
 function getDefaultPoolName(project) {
-  if (project.config.browser.enabled) {
-    return "browser";
-  }
-  return project.config.pool;
+	if (project.config.browser.enabled) {
+		return "browser";
+	}
+	return project.config.pool;
 }
 function getFilePoolName(project, file) {
-  for (const [glob, pool] of project.config.poolMatchGlobs) {
-    if (pool === "browser") {
-      throw new Error(
-        'Since Vitest 0.31.0 "browser" pool is not supported in "poolMatchGlobs". You can create a workspace to run some of your tests in browser in parallel. Read more: https://vitest.dev/guide/workspace'
-      );
-    }
-    if (mm.isMatch(file, glob, { cwd: project.config.root })) {
-      return pool;
-    }
-  }
-  return getDefaultPoolName(project);
+	for (const [glob, pool] of project.config.poolMatchGlobs) {
+		if (pool === "browser") {
+			throw new Error("Since Vitest 0.31.0 \"browser\" pool is not supported in \"poolMatchGlobs\". You can create a workspace to run some of your tests in browser in parallel. Read more: https://vitest.dev/guide/workspace");
+		}
+		if (mm.isMatch(file, glob, { cwd: project.config.root })) {
+			return pool;
+		}
+	}
+	return getDefaultPoolName(project);
 }
 function createPool(ctx) {
-  const pools = {
-    forks: null,
-    threads: null,
-    browser: null,
-    vmThreads: null,
-    vmForks: null,
-    typescript: null
-  };
-  const viteMajor = Number(version.split(".")[0]);
-  const potentialConditions = new Set(viteMajor >= 6 ? ctx.vite.config.ssr.resolve?.conditions ?? [] : [
-    "production",
-    "development",
-    ...ctx.vite.config.resolve.conditions
-  ]);
-  const conditions = [...potentialConditions].filter((condition) => {
-    if (condition === "production") {
-      return ctx.vite.config.isProduction;
-    }
-    if (condition === "development") {
-      return !ctx.vite.config.isProduction;
-    }
-    return true;
-  }).map((condition) => {
-    if (viteMajor >= 6 && condition === "development|production") {
-      return ctx.vite.config.isProduction ? "production" : "development";
-    }
-    return condition;
-  }).flatMap((c) => ["--conditions", c]);
-  const 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
-      }
-    };
-    if (isWindows) {
-      for (const name in options.env) {
-        options.env[name.toUpperCase()] = options.env[name];
-      }
-    }
-    const customPools = /* @__PURE__ */ new Map();
-    async function resolveCustomPool(filepath) {
-      if (customPools.has(filepath)) {
-        return customPools.get(filepath);
-      }
-      const pool = await ctx.runner.executeId(filepath);
-      if (typeof pool.default !== "function") {
-        throw new TypeError(
-          `Custom pool "${filepath}" must export a function as default export`
-        );
-      }
-      const poolInstance = await pool.default(ctx, options);
-      if (typeof poolInstance?.name !== "string") {
-        throw new TypeError(
-          `Custom pool "${filepath}" should return an object with "name" property`
-        );
-      }
-      if (typeof poolInstance?.[method] !== "function") {
-        throw new TypeError(
-          `Custom pool "${filepath}" should return an object with "${method}" method`
-        );
-      }
-      customPools.set(filepath, poolInstance);
-      return poolInstance;
-    }
-    const filesByPool = {
-      forks: [],
-      threads: [],
-      vmThreads: [],
-      vmForks: [],
-      typescript: []
-    };
-    const factories = {
-      vmThreads: () => createVmThreadsPool(ctx, options),
-      threads: () => createThreadsPool(ctx, options),
-      forks: () => createForksPool(ctx, options),
-      vmForks: () => createVmForksPool(ctx, options),
-      typescript: () => createTypecheckPool(ctx)
-    };
-    for (const spec of files) {
-      const { pool } = spec[2];
-      filesByPool[pool] ??= [];
-      filesByPool[pool].push(spec);
-    }
-    const Sequencer = ctx.config.sequence.sequencer;
-    const sequencer = new Sequencer(ctx);
-    async function sortSpecs(specs) {
-      if (ctx.config.shard) {
-        specs = await sequencer.shard(specs);
-      }
-      return sequencer.sort(specs);
-    }
-    await Promise.all(
-      Object.entries(filesByPool).map(async (entry) => {
-        const [pool, files2] = entry;
-        if (!files2.length) {
-          return null;
-        }
-        const specs = await sortSpecs(files2);
-        if (pool in factories) {
-          const factory = factories[pool];
-          pools[pool] ??= factory();
-          return pools[pool][method](specs, invalidate);
-        }
-        if (pool === "browser") {
-          pools[pool] ??= await (async () => {
-            const { createBrowserPool } = await import('@vitest/browser');
-            return createBrowserPool(ctx);
-          })();
-          return pools[pool][method](specs, invalidate);
-        }
-        const poolHandler = await resolveCustomPool(pool);
-        pools[poolHandler.name] ??= poolHandler;
-        return 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?.()));
-    }
-  };
+	const pools = {
+		forks: null,
+		threads: null,
+		browser: null,
+		vmThreads: null,
+		vmForks: null,
+		typescript: null
+	};
+	const viteMajor = Number(version.split(".")[0]);
+	const potentialConditions = new Set(viteMajor >= 6 ? ctx.vite.config.ssr.resolve?.conditions ?? [] : [
+		"production",
+		"development",
+		...ctx.vite.config.resolve.conditions
+	]);
+	const conditions = [...potentialConditions].filter((condition) => {
+		if (condition === "production") {
+			return ctx.vite.config.isProduction;
+		}
+		if (condition === "development") {
+			return !ctx.vite.config.isProduction;
+		}
+		return true;
+	}).map((condition) => {
+		if (viteMajor >= 6 && condition === "development|production") {
+			return ctx.vite.config.isProduction ? "production" : "development";
+		}
+		return condition;
+	}).flatMap((c) => ["--conditions", c]);
+	const 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
+			}
+		};
+		if (isWindows) {
+			for (const name in options.env) {
+				options.env[name.toUpperCase()] = options.env[name];
+			}
+		}
+		const customPools = new Map();
+		async function resolveCustomPool(filepath) {
+			if (customPools.has(filepath)) {
+				return customPools.get(filepath);
+			}
+			const pool = await ctx.runner.executeId(filepath);
+			if (typeof pool.default !== "function") {
+				throw new TypeError(`Custom pool "${filepath}" must export a function as default export`);
+			}
+			const poolInstance = await pool.default(ctx, options);
+			if (typeof poolInstance?.name !== "string") {
+				throw new TypeError(`Custom pool "${filepath}" should return an object with "name" property`);
+			}
+			if (typeof poolInstance?.[method] !== "function") {
+				throw new TypeError(`Custom pool "${filepath}" should return an object with "${method}" method`);
+			}
+			customPools.set(filepath, poolInstance);
+			return poolInstance;
+		}
+		const filesByPool = {
+			forks: [],
+			threads: [],
+			vmThreads: [],
+			vmForks: [],
+			typescript: []
+		};
+		const factories = {
+			vmThreads: () => createVmThreadsPool(ctx, options),
+			threads: () => createThreadsPool(ctx, options),
+			forks: () => createForksPool(ctx, options),
+			vmForks: () => createVmForksPool(ctx, options),
+			typescript: () => createTypecheckPool(ctx)
+		};
+		for (const spec of files) {
+			const { pool } = spec[2];
+			filesByPool[pool] ??= [];
+			filesByPool[pool].push(spec);
+		}
+		const Sequencer = ctx.config.sequence.sequencer;
+		const sequencer = new Sequencer(ctx);
+		async function sortSpecs(specs) {
+			if (ctx.config.shard) {
+				specs = await sequencer.shard(specs);
+			}
+			return sequencer.sort(specs);
+		}
+		await Promise.all(Object.entries(filesByPool).map(async (entry) => {
+			const [pool, files] = entry;
+			if (!files.length) {
+				return null;
+			}
+			const specs = await sortSpecs(files);
+			if (pool in factories) {
+				const factory = factories[pool];
+				pools[pool] ??= factory();
+				return pools[pool][method](specs, invalidate);
+			}
+			if (pool === "browser") {
+				pools[pool] ??= await (async () => {
+					const { createBrowserPool } = await import('@vitest/browser');
+					return createBrowserPool(ctx);
+				})();
+				return pools[pool][method](specs, invalidate);
+			}
+			const poolHandler = await resolveCustomPool(pool);
+			pools[poolHandler.name] ??= poolHandler;
+			return 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) {
-    this.ctx = ctx;
-  }
-  // async so it can be extended by other sequelizers
-  async shard(files) {
-    const { config } = this.ctx;
-    const { index, count } = config.shard;
-    const shardSize = Math.ceil(files.length / count);
-    const shardStart = shardSize * (index - 1);
-    const shardEnd = shardSize * index;
-    return [...files].map((spec) => {
-      const fullPath = resolve(slash$1(config.root), slash$1(spec.moduleId));
-      const specPath = fullPath?.slice(config.root.length);
-      return {
-        spec,
-        hash: hash("sha1", specPath, "hex")
-      };
-    }).sort((a, b) => a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0).slice(shardStart, shardEnd).map(({ spec }) => spec);
-  }
-  // async so it can be extended by other sequelizers
-  async sort(files) {
-    const cache = this.ctx.cache;
-    return [...files].sort((a, b) => {
-      const keyA = `${a.project.name}:${relative(this.ctx.config.root, a.moduleId)}`;
-      const keyB = `${b.project.name}:${relative(this.ctx.config.root, b.moduleId)}`;
-      const aState = cache.getFileTestResults(keyA);
-      const bState = cache.getFileTestResults(keyB);
-      if (!aState || !bState) {
-        const statsA = cache.getFileStats(keyA);
-        const statsB = cache.getFileStats(keyB);
-        if (!statsA || !statsB) {
-          return !statsA && statsB ? -1 : !statsB && statsA ? 1 : 0;
-        }
-        return statsB.size - statsA.size;
-      }
-      if (aState.failed && !bState.failed) {
-        return -1;
-      }
-      if (!aState.failed && bState.failed) {
-        return 1;
-      }
-      return bState.duration - aState.duration;
-    });
-  }
+	ctx;
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	async shard(files) {
+		const { config } = this.ctx;
+		const { index, count } = config.shard;
+		const shardSize = Math.ceil(files.length / count);
+		const shardStart = shardSize * (index - 1);
+		const shardEnd = shardSize * index;
+		return [...files].map((spec) => {
+			const fullPath = resolve(slash$1(config.root), slash$1(spec.moduleId));
+			const specPath = fullPath?.slice(config.root.length);
+			return {
+				spec,
+				hash: hash("sha1", specPath, "hex")
+			};
+		}).sort((a, b) => a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0).slice(shardStart, shardEnd).map(({ spec }) => spec);
+	}
+	async sort(files) {
+		const cache = this.ctx.cache;
+		return [...files].sort((a, b) => {
+			const keyA = `${a.project.name}:${relative(this.ctx.config.root, a.moduleId)}`;
+			const keyB = `${b.project.name}:${relative(this.ctx.config.root, b.moduleId)}`;
+			const aState = cache.getFileTestResults(keyA);
+			const bState = cache.getFileTestResults(keyB);
+			if (!aState || !bState) {
+				const statsA = cache.getFileStats(keyA);
+				const statsB = cache.getFileStats(keyB);
+				if (!statsA || !statsB) {
+					return !statsA && statsB ? -1 : !statsB && statsA ? 1 : 0;
+				}
+				return statsB.size - statsA.size;
+			}
+			if (aState.failed && !bState.failed) {
+				return -1;
+			}
+			if (!aState.failed && bState.failed) {
+				return 1;
+			}
+			return bState.duration - aState.duration;
+		});
+	}
 }
 
 class RandomSequencer extends BaseSequencer {
-  async sort(files) {
-    const { sequence } = this.ctx.config;
-    return shuffle(files, sequence.seed);
-  }
+	async sort(files) {
+		const { sequence } = this.ctx.config;
+		return shuffle(files, sequence.seed);
+	}
 }
 
 function resolvePath(path, root) {
-  return normalize(
-    /* @__PURE__ */ resolveModule(path, { paths: [root] }) ?? resolve(root, path)
-  );
+	return normalize(/* @__PURE__ */ resolveModule(path, { paths: [root] }) ?? resolve(root, path));
 }
 function parseInspector(inspect) {
-  if (typeof inspect === "boolean" || inspect === void 0) {
-    return {};
-  }
-  if (typeof inspect === "number") {
-    return { port: inspect };
-  }
-  if (inspect.match(/https?:\//)) {
-    throw new Error(
-      `Inspector host cannot be a URL. Use "host:port" instead of "${inspect}"`
-    );
-  }
-  const [host, port] = inspect.split(":");
-  if (!port) {
-    return { host };
-  }
-  return { host, port: Number(port) || defaultInspectPort };
+	if (typeof inspect === "boolean" || inspect === undefined) {
+		return {};
+	}
+	if (typeof inspect === "number") {
+		return { port: inspect };
+	}
+	if (inspect.match(/https?:\//)) {
+		throw new Error(`Inspector host cannot be a URL. Use "host:port" instead of "${inspect}"`);
+	}
+	const [host, port] = inspect.split(":");
+	if (!port) {
+		return { host };
+	}
+	return {
+		host,
+		port: Number(port) || defaultInspectPort
+	};
 }
-function resolveApiServerConfig(options, defaultPort2) {
-  let api;
-  if (options.ui && !options.api) {
-    api = { port: defaultPort2 };
-  } else if (options.api === true) {
-    api = { port: defaultPort2 };
-  } else if (typeof options.api === "number") {
-    api = { port: options.api };
-  }
-  if (typeof options.api === "object") {
-    if (api) {
-      if (options.api.port) {
-        api.port = options.api.port;
-      }
-      if (options.api.strictPort) {
-        api.strictPort = options.api.strictPort;
-      }
-      if (options.api.host) {
-        api.host = options.api.host;
-      }
-    } else {
-      api = { ...options.api };
-    }
-  }
-  if (api) {
-    if (!api.port && !api.middlewareMode) {
-      api.port = defaultPort2;
-    }
-  } else {
-    api = { middlewareMode: true };
-  }
-  return api;
+function resolveApiServerConfig(options, defaultPort) {
+	let api;
+	if (options.ui && !options.api) {
+		api = { port: defaultPort };
+	} else if (options.api === true) {
+		api = { port: defaultPort };
+	} else if (typeof options.api === "number") {
+		api = { port: options.api };
+	}
+	if (typeof options.api === "object") {
+		if (api) {
+			if (options.api.port) {
+				api.port = options.api.port;
+			}
+			if (options.api.strictPort) {
+				api.strictPort = options.api.strictPort;
+			}
+			if (options.api.host) {
+				api.host = options.api.host;
+			}
+		} else {
+			api = { ...options.api };
+		}
+	}
+	if (api) {
+		if (!api.port && !api.middlewareMode) {
+			api.port = defaultPort;
+		}
+	} else {
+		api = { middlewareMode: true };
+	}
+	return api;
 }
 function resolveInlineWorkerOption(value) {
-  if (typeof value === "string" && value.trim().endsWith("%")) {
-    return getWorkersCountByPercentage(value);
-  } else {
-    return Number(value);
-  }
+	if (typeof value === "string" && value.trim().endsWith("%")) {
+		return getWorkersCountByPercentage(value);
+	} else {
+		return Number(value);
+	}
 }
 function resolveConfig$1(vitest, options, viteConfig) {
-  const mode = vitest.mode;
-  const logger = vitest.logger;
-  if (options.dom) {
-    if (viteConfig.test?.environment != null && viteConfig.test.environment !== "happy-dom") {
-      logger.console.warn(
-        c.yellow(
-          `${c.inverse(c.yellow(" Vitest "))} Your config.test.environment ("${viteConfig.test.environment}") conflicts with --dom flag ("happy-dom"), ignoring "${viteConfig.test.environment}"`
-        )
-      );
-    }
-    options.environment = "happy-dom";
-  }
-  const resolved = {
-    ...configDefaults,
-    ...options,
-    root: viteConfig.root,
-    mode
-  };
-  resolved.project = toArray(resolved.project);
-  resolved.provide ??= {};
-  const inspector = resolved.inspect || resolved.inspectBrk;
-  resolved.inspector = {
-    ...resolved.inspector,
-    ...parseInspector(inspector),
-    enabled: !!inspector,
-    waitForDebugger: options.inspector?.waitForDebugger ?? !!resolved.inspectBrk
-  };
-  if (viteConfig.base !== "/") {
-    resolved.base = viteConfig.base;
-  }
-  resolved.clearScreen = resolved.clearScreen ?? viteConfig.clearScreen ?? true;
-  if (options.shard) {
-    if (resolved.watch) {
-      throw new Error("You cannot use --shard option with enabled watch");
-    }
-    const [indexString, countString] = options.shard.split("/");
-    const index = Math.abs(Number.parseInt(indexString, 10));
-    const count = Math.abs(Number.parseInt(countString, 10));
-    if (Number.isNaN(count) || count <= 0) {
-      throw new Error("--shard <count> must be a positive number");
-    }
-    if (Number.isNaN(index) || index <= 0 || index > count) {
-      throw new Error(
-        "--shard <index> must be a positive number less then <count>"
-      );
-    }
-    resolved.shard = { index, count };
-  }
-  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);
-  }
-  resolved.browser ??= {};
-  resolved.fileParallelism ??= mode !== "benchmark";
-  if (!resolved.fileParallelism) {
-    resolved.maxWorkers = 1;
-    resolved.minWorkers = 1;
-  }
-  if (resolved.maxConcurrency === 0) {
-    logger.console.warn(
-      c.yellow(`The option "maxConcurrency" cannot be set to 0. Using default value ${configDefaults.maxConcurrency} instead.`)
-    );
-    resolved.maxConcurrency = configDefaults.maxConcurrency;
-  }
-  if (resolved.inspect || resolved.inspectBrk) {
-    const isSingleThread = resolved.pool === "threads" && resolved.poolOptions?.threads?.singleThread;
-    const isSingleFork = resolved.pool === "forks" && resolved.poolOptions?.forks?.singleFork;
-    if (resolved.fileParallelism && !isSingleThread && !isSingleFork) {
-      const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
-      throw new Error(
-        `You cannot use ${inspectOption} without "--no-file-parallelism", "poolOptions.threads.singleThread" or "poolOptions.forks.singleFork"`
-      );
-    }
-  }
-  const browser = resolved.browser;
-  if (browser.enabled) {
-    if (!browser.name && !browser.instances) {
-      browser.enabled = false;
-    } else {
-      const instances = browser.instances;
-      if (browser.name && browser.instances) {
-        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((c2) => c2.browser).join(", ")}). Did you mean to use another name?` : ""
-        ].join(""));
-      }
-    }
-  }
-  const playwrightChromiumOnly = isPlaywrightChromiumOnly(vitest, resolved);
-  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
-${JSON.stringify(browserConfig, null, 2)}
-
-Use either:
-${JSON.stringify({ browser: { provider: "playwright", instances: [{ browser: "chromium" }] } }, null, 2)}
-
-...or change your coverage provider to:
-${JSON.stringify({ coverage: { provider: "istanbul" } }, null, 2)}
-`
-      );
-    }
-    if (resolved.inspect || resolved.inspectBrk) {
-      const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
-      throw new Error(
-        `${inspectOption} does not work with
-${JSON.stringify(browserConfig, null, 2)}
-
-Use either:
-${JSON.stringify({ browser: { provider: "playwright", instances: [{ browser: "chromium" }] } }, null, 2)}
-
-...or disable ${inspectOption}
-`
-      );
-    }
-  }
-  resolved.coverage.reporter = resolveCoverageReporters(resolved.coverage.reporter);
-  if (resolved.coverage.enabled && 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
-    );
-  }
-  resolved.expect ??= {};
-  resolved.deps ??= {};
-  resolved.deps.moduleDirectories ??= [];
-  resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map(
-    (dir) => {
-      if (!dir.startsWith("/")) {
-        dir = `/${dir}`;
-      }
-      if (!dir.endsWith("/")) {
-        dir += "/";
-      }
-      return normalize(dir);
-    }
-  );
-  if (!resolved.deps.moduleDirectories.includes("/node_modules/")) {
-    resolved.deps.moduleDirectories.push("/node_modules/");
-  }
-  resolved.deps.optimizer ??= {};
-  resolved.deps.optimizer.ssr ??= {};
-  resolved.deps.optimizer.ssr.enabled ??= true;
-  resolved.deps.optimizer.web ??= {};
-  resolved.deps.optimizer.web.enabled ??= true;
-  resolved.deps.web ??= {};
-  resolved.deps.web.transformAssets ??= true;
-  resolved.deps.web.transformCss ??= true;
-  resolved.deps.web.transformGlobPattern ??= [];
-  resolved.setupFiles = toArray(resolved.setupFiles || []).map(
-    (file) => resolvePath(file, resolved.root)
-  );
-  resolved.globalSetup = toArray(resolved.globalSetup || []).map(
-    (file) => resolvePath(file, resolved.root)
-  );
-  resolved.coverage.exclude.push(
-    ...resolved.setupFiles.map(
-      (file) => `${resolved.coverage.allowExternal ? "**/" : ""}${relative(
-        resolved.root,
-        file
-      )}`
-    )
-  );
-  resolved.coverage.exclude.push(...resolved.include);
-  resolved.forceRerunTriggers = [
-    ...resolved.forceRerunTriggers,
-    ...resolved.setupFiles
-  ];
-  resolved.server ??= {};
-  resolved.server.deps ??= {};
-  const deprecatedDepsOptions = ["inline", "external", "fallbackCJS"];
-  deprecatedDepsOptions.forEach((option) => {
-    if (resolved.deps[option] === void 0) {
-      return;
-    }
-    if (option === "fallbackCJS") {
-      logger.console.warn(
-        c.yellow(
-          `${c.inverse(
-            c.yellow(" Vitest ")
-          )} "deps.${option}" is deprecated. Use "server.deps.${option}" instead`
-        )
-      );
-    } else {
-      const transformMode = resolved.environment === "happy-dom" || resolved.environment === "jsdom" ? "web" : "ssr";
-      logger.console.warn(
-        c.yellow(
-          `${c.inverse(
-            c.yellow(" Vitest ")
-          )} "deps.${option}" is deprecated. If you rely on vite-node directly, use "server.deps.${option}" instead. Otherwise, consider using "deps.optimizer.${transformMode}.${option === "external" ? "exclude" : "include"}"`
-        )
-      );
-    }
-    if (resolved.server.deps[option] === void 0) {
-      resolved.server.deps[option] = resolved.deps[option];
-    }
-  });
-  if (resolved.cliExclude) {
-    resolved.exclude.push(...resolved.cliExclude);
-  }
-  if (resolved.server.deps.inline !== true) {
-    const ssrOptions = viteConfig.ssr;
-    if (ssrOptions?.noExternal === true && resolved.server.deps.inline == null) {
-      resolved.server.deps.inline = true;
-    } else {
-      resolved.server.deps.inline ??= [];
-      resolved.server.deps.inline.push(...extraInlineDeps);
-    }
-  }
-  resolved.server.deps.inlineFiles ??= [];
-  resolved.server.deps.inlineFiles.push(...resolved.setupFiles);
-  resolved.server.deps.moduleDirectories ??= [];
-  resolved.server.deps.moduleDirectories.push(
-    ...resolved.deps.moduleDirectories
-  );
-  if (resolved.runner) {
-    resolved.runner = resolvePath(resolved.runner, resolved.root);
-  }
-  if (resolved.snapshotEnvironment) {
-    resolved.snapshotEnvironment = resolvePath(
-      resolved.snapshotEnvironment,
-      resolved.root
-    );
-  }
-  resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
-  if (resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) {
-    resolved.snapshotFormat.plugins = [];
-  }
-  const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
-  resolved.snapshotOptions = {
-    expand: resolved.expandSnapshotDiff ?? false,
-    snapshotFormat: resolved.snapshotFormat || {},
-    updateSnapshot: isCI && !UPDATE_SNAPSHOT ? "none" : UPDATE_SNAPSHOT ? "all" : "new",
-    resolveSnapshotPath: options.resolveSnapshotPath,
-    // resolved inside the worker
-    snapshotEnvironment: null
-  };
-  resolved.snapshotSerializers ??= [];
-  resolved.snapshotSerializers = resolved.snapshotSerializers.map(
-    (file) => resolvePath(file, resolved.root)
-  );
-  resolved.forceRerunTriggers.push(...resolved.snapshotSerializers);
-  if (options.resolveSnapshotPath) {
-    delete resolved.resolveSnapshotPath;
-  }
-  resolved.pool ??= "threads";
-  if (process.env.VITEST_MAX_THREADS) {
-    resolved.poolOptions = {
-      ...resolved.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 (typeof resolved.workspace === "string") {
-    resolved.workspace = typeof options.workspace === "string" && options.workspace[0] === "." ? resolve(process.cwd(), options.workspace) : resolvePath(resolved.workspace, resolved.root);
-  }
-  if (!builtinPools.includes(resolved.pool)) {
-    resolved.pool = resolvePath(resolved.pool, resolved.root);
-  }
-  if (resolved.poolMatchGlobs) {
-    logger.warn(
-      c.yellow(
-        `${c.inverse(
-          c.yellow(" Vitest ")
-        )} "poolMatchGlobs" is deprecated. Use "workspace" to define different configurations instead.`
-      )
-    );
-  }
-  resolved.poolMatchGlobs = (resolved.poolMatchGlobs || []).map(
-    ([glob, pool]) => {
-      if (!builtinPools.includes(pool)) {
-        pool = resolvePath(pool, resolved.root);
-      }
-      return [glob, pool];
-    }
-  );
-  if (mode === "benchmark") {
-    resolved.benchmark = {
-      ...benchmarkConfigDefaults,
-      ...resolved.benchmark
-    };
-    resolved.coverage.enabled = false;
-    resolved.typecheck.enabled = false;
-    resolved.include = resolved.benchmark.include;
-    resolved.exclude = resolved.benchmark.exclude;
-    resolved.includeSource = resolved.benchmark.includeSource;
-    const reporters = Array.from(
-      /* @__PURE__ */ new Set([
-        ...toArray(resolved.benchmark.reporters),
-        // @ts-expect-error reporter is CLI flag
-        ...toArray(options.reporter)
-      ])
-    ).filter(Boolean);
-    if (reporters.length) {
-      resolved.benchmark.reporters = reporters;
-    } else {
-      resolved.benchmark.reporters = ["default"];
-    }
-    if (options.outputFile) {
-      resolved.benchmark.outputFile = options.outputFile;
-    }
-    if (options.compare) {
-      resolved.benchmark.compare = options.compare;
-    }
-    if (options.outputJson) {
-      resolved.benchmark.outputJson = options.outputJson;
-    }
-  }
-  if (typeof resolved.diff === "string") {
-    resolved.diff = resolvePath(resolved.diff, resolved.root);
-    resolved.forceRerunTriggers.push(resolved.diff);
-  }
-  const api = resolveApiServerConfig(options, defaultPort);
-  resolved.api = { ...api, token: crypto.randomUUID() };
-  if (options.related) {
-    resolved.related = toArray(options.related).map(
-      (file) => resolve(resolved.root, file)
-    );
-  }
-  if (options.reporters) {
-    if (!Array.isArray(options.reporters)) {
-      if (typeof options.reporters === "string") {
-        resolved.reporters = [[options.reporters, {}]];
-      } else {
-        resolved.reporters = [options.reporters];
-      }
-    } else {
-      resolved.reporters = [];
-      for (const reporter of options.reporters) {
-        if (Array.isArray(reporter)) {
-          resolved.reporters.push([reporter[0], reporter[1] || {}]);
-        } else if (typeof reporter === "string") {
-          resolved.reporters.push([reporter, {}]);
-        } else {
-          resolved.reporters.push(reporter);
-        }
-      }
-    }
-  }
-  if (mode !== "benchmark") {
-    const reportersFromCLI = resolved.reporter;
-    const cliReporters = toArray(reportersFromCLI || []).map(
-      (reporter) => {
-        if (/^\.\.?\//.test(reporter)) {
-          return resolve(process.cwd(), reporter);
-        }
-        return reporter;
-      }
-    );
-    if (cliReporters.length) {
-      resolved.reporters = Array.from(new Set(toArray(cliReporters))).filter(Boolean).map((reporter) => [reporter, {}]);
-    }
-  }
-  if (!resolved.reporters.length) {
-    resolved.reporters.push(["default", {}]);
-    if (process.env.GITHUB_ACTIONS === "true") {
-      resolved.reporters.push(["github-actions", {}]);
-    }
-  }
-  if (resolved.changed) {
-    resolved.passWithNoTests ??= true;
-  }
-  resolved.css ??= {};
-  if (typeof resolved.css === "object") {
-    resolved.css.modules ??= {};
-    resolved.css.modules.classNameStrategy ??= "stable";
-  }
-  if (resolved.cache !== false) {
-    let cacheDir = VitestCache.resolveCacheDir(
-      "",
-      viteConfig.cacheDir,
-      resolved.name
-    );
-    if (resolved.cache && resolved.cache.dir) {
-      logger.console.warn(
-        c.yellow(
-          `${c.inverse(
-            c.yellow(" Vitest ")
-          )} "cache.dir" is deprecated, use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir/vitest"`
-        )
-      );
-      cacheDir = VitestCache.resolveCacheDir(
-        resolved.root,
-        resolved.cache.dir,
-        resolved.name
-      );
-    }
-    resolved.cache = { dir: cacheDir };
-  }
-  resolved.sequence ??= {};
-  if (resolved.sequence.shuffle && typeof resolved.sequence.shuffle === "object") {
-    const { files, tests } = resolved.sequence.shuffle;
-    resolved.sequence.sequencer ??= files ? RandomSequencer : BaseSequencer;
-    resolved.sequence.shuffle = tests;
-  }
-  if (!resolved.sequence?.sequencer) {
-    resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
-  }
-  resolved.sequence.hooks ??= "stack";
-  if (resolved.sequence.sequencer === RandomSequencer) {
-    resolved.sequence.seed ??= Date.now();
-  }
-  resolved.typecheck = {
-    ...configDefaults.typecheck,
-    ...resolved.typecheck
-  };
-  if (resolved.environmentMatchGlobs) {
-    logger.warn(
-      c.yellow(
-        `${c.inverse(
-          c.yellow(" Vitest ")
-        )} "environmentMatchGlobs" is deprecated. Use "workspace" to define different configurations instead.`
-      )
-    );
-  }
-  resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map(
-    (i) => [resolve(resolved.root, i[0]), i[1]]
-  );
-  resolved.typecheck ??= {};
-  resolved.typecheck.enabled ??= false;
-  if (resolved.typecheck.enabled) {
-    logger.console.warn(
-      c.yellow(
-        "Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."
-      )
-    );
-  }
-  resolved.browser ??= {};
-  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;
-  if (resolved.browser.screenshotDirectory) {
-    resolved.browser.screenshotDirectory = resolve(
-      resolved.root,
-      resolved.browser.screenshotDirectory
-    );
-  }
-  const isPreview = resolved.browser.provider === "preview";
-  if (isPreview && resolved.browser.screenshotFailures === true) {
-    console.warn(c.yellow(
-      [
-        `Browser provider "preview" doesn't support screenshots, `,
-        `so "browser.screenshotFailures" option is forcefully disabled. `,
-        `Set "browser.screenshotFailures" to false or remove it from the config to suppress this warning.`
-      ].join("")
-    ));
-    resolved.browser.screenshotFailures = false;
-  } else {
-    resolved.browser.screenshotFailures ??= !isPreview && !resolved.browser.ui;
-  }
-  resolved.browser.viewport ??= {};
-  resolved.browser.viewport.width ??= 414;
-  resolved.browser.viewport.height ??= 896;
-  resolved.browser.locators ??= {};
-  resolved.browser.locators.testIdAttribute ??= "data-testid";
-  if (resolved.browser.enabled && provider === "stackblitz") {
-    resolved.browser.provider = "preview";
-  }
-  resolved.browser.api = resolveApiServerConfig(
-    resolved.browser,
-    defaultBrowserPort
-  ) || {
-    port: defaultBrowserPort
-  };
-  if (resolved.browser.enabled) {
-    if (resolved.browser.ui) {
-      resolved.includeTaskLocation ??= true;
-    }
-  } else if (resolved.ui) {
-    resolved.includeTaskLocation ??= true;
-  }
-  const htmlReporter = toArray(resolved.reporters).some((reporter) => {
-    if (Array.isArray(reporter)) {
-      return reporter[0] === "html";
-    }
-    return false;
-  });
-  if (htmlReporter) {
-    resolved.includeTaskLocation ??= true;
-  }
-  resolved.testTransformMode ??= {};
-  resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3;
-  resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4;
-  return resolved;
+	const mode = vitest.mode;
+	const logger = vitest.logger;
+	if (options.dom) {
+		if (viteConfig.test?.environment != null && viteConfig.test.environment !== "happy-dom") {
+			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} Your config.test.environment ("${viteConfig.test.environment}") conflicts with --dom flag ("happy-dom"), ignoring "${viteConfig.test.environment}"`));
+		}
+		options.environment = "happy-dom";
+	}
+	const resolved = {
+		...configDefaults,
+		...options,
+		root: viteConfig.root,
+		mode
+	};
+	resolved.project = toArray(resolved.project);
+	resolved.provide ??= {};
+	const inspector = resolved.inspect || resolved.inspectBrk;
+	resolved.inspector = {
+		...resolved.inspector,
+		...parseInspector(inspector),
+		enabled: !!inspector,
+		waitForDebugger: options.inspector?.waitForDebugger ?? !!resolved.inspectBrk
+	};
+	if (viteConfig.base !== "/") {
+		resolved.base = viteConfig.base;
+	}
+	resolved.clearScreen = resolved.clearScreen ?? viteConfig.clearScreen ?? true;
+	if (options.shard) {
+		if (resolved.watch) {
+			throw new Error("You cannot use --shard option with enabled watch");
+		}
+		const [indexString, countString] = options.shard.split("/");
+		const index = Math.abs(Number.parseInt(indexString, 10));
+		const count = Math.abs(Number.parseInt(countString, 10));
+		if (Number.isNaN(count) || count <= 0) {
+			throw new Error("--shard <count> must be a positive number");
+		}
+		if (Number.isNaN(index) || index <= 0 || index > count) {
+			throw new Error("--shard <index> must be a positive number less then <count>");
+		}
+		resolved.shard = {
+			index,
+			count
+		};
+	}
+	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);
+	}
+	resolved.browser ??= {};
+	resolved.fileParallelism ??= mode !== "benchmark";
+	if (!resolved.fileParallelism) {
+		resolved.maxWorkers = 1;
+		resolved.minWorkers = 1;
+	}
+	if (resolved.maxConcurrency === 0) {
+		logger.console.warn(c.yellow(`The option "maxConcurrency" cannot be set to 0. Using default value ${configDefaults.maxConcurrency} instead.`));
+		resolved.maxConcurrency = configDefaults.maxConcurrency;
+	}
+	if (resolved.inspect || resolved.inspectBrk) {
+		const isSingleThread = resolved.pool === "threads" && resolved.poolOptions?.threads?.singleThread;
+		const isSingleFork = resolved.pool === "forks" && resolved.poolOptions?.forks?.singleFork;
+		if (resolved.fileParallelism && !isSingleThread && !isSingleFork) {
+			const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
+			throw new Error(`You cannot use ${inspectOption} without "--no-file-parallelism", "poolOptions.threads.singleThread" or "poolOptions.forks.singleFork"`);
+		}
+	}
+	const browser = resolved.browser;
+	if (browser.enabled) {
+		if (!browser.name && !browser.instances) {
+			browser.enabled = false;
+		} else {
+			const instances = browser.instances;
+			if (browser.name && browser.instances) {
+				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(""));
+			}
+		}
+	}
+	const playwrightChromiumOnly = isPlaywrightChromiumOnly(vitest, resolved);
+	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 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`);
+		}
+	}
+	resolved.coverage.reporter = resolveCoverageReporters(resolved.coverage.reporter);
+	if (resolved.coverage.enabled && 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);
+	}
+	resolved.expect ??= {};
+	resolved.deps ??= {};
+	resolved.deps.moduleDirectories ??= [];
+	resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map((dir) => {
+		if (!dir.startsWith("/")) {
+			dir = `/${dir}`;
+		}
+		if (!dir.endsWith("/")) {
+			dir += "/";
+		}
+		return normalize(dir);
+	});
+	if (!resolved.deps.moduleDirectories.includes("/node_modules/")) {
+		resolved.deps.moduleDirectories.push("/node_modules/");
+	}
+	resolved.deps.optimizer ??= {};
+	resolved.deps.optimizer.ssr ??= {};
+	resolved.deps.optimizer.ssr.enabled ??= true;
+	resolved.deps.optimizer.web ??= {};
+	resolved.deps.optimizer.web.enabled ??= true;
+	resolved.deps.web ??= {};
+	resolved.deps.web.transformAssets ??= true;
+	resolved.deps.web.transformCss ??= true;
+	resolved.deps.web.transformGlobPattern ??= [];
+	resolved.setupFiles = toArray(resolved.setupFiles || []).map((file) => resolvePath(file, resolved.root));
+	resolved.globalSetup = toArray(resolved.globalSetup || []).map((file) => resolvePath(file, resolved.root));
+	resolved.coverage.exclude.push(...resolved.setupFiles.map((file) => `${resolved.coverage.allowExternal ? "**/" : ""}${relative(resolved.root, file)}`));
+	resolved.coverage.exclude.push(...resolved.include);
+	resolved.forceRerunTriggers = [...resolved.forceRerunTriggers, ...resolved.setupFiles];
+	resolved.server ??= {};
+	resolved.server.deps ??= {};
+	const deprecatedDepsOptions = [
+		"inline",
+		"external",
+		"fallbackCJS"
+	];
+	deprecatedDepsOptions.forEach((option) => {
+		if (resolved.deps[option] === undefined) {
+			return;
+		}
+		if (option === "fallbackCJS") {
+			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. Use "server.deps.${option}" instead`));
+		} else {
+			const transformMode = resolved.environment === "happy-dom" || resolved.environment === "jsdom" ? "web" : "ssr";
+			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. If you rely on vite-node directly, use "server.deps.${option}" instead. Otherwise, consider using "deps.optimizer.${transformMode}.${option === "external" ? "exclude" : "include"}"`));
+		}
+		if (resolved.server.deps[option] === undefined) {
+			resolved.server.deps[option] = resolved.deps[option];
+		}
+	});
+	if (resolved.cliExclude) {
+		resolved.exclude.push(...resolved.cliExclude);
+	}
+	if (resolved.server.deps.inline !== true) {
+		const ssrOptions = viteConfig.ssr;
+		if (ssrOptions?.noExternal === true && resolved.server.deps.inline == null) {
+			resolved.server.deps.inline = true;
+		} else {
+			resolved.server.deps.inline ??= [];
+			resolved.server.deps.inline.push(...extraInlineDeps);
+		}
+	}
+	resolved.server.deps.inlineFiles ??= [];
+	resolved.server.deps.inlineFiles.push(...resolved.setupFiles);
+	resolved.server.deps.moduleDirectories ??= [];
+	resolved.server.deps.moduleDirectories.push(...resolved.deps.moduleDirectories);
+	if (resolved.runner) {
+		resolved.runner = resolvePath(resolved.runner, resolved.root);
+	}
+	if (resolved.snapshotEnvironment) {
+		resolved.snapshotEnvironment = resolvePath(resolved.snapshotEnvironment, resolved.root);
+	}
+	resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : undefined;
+	if (resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) {
+		resolved.snapshotFormat.plugins = [];
+	}
+	const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
+	resolved.snapshotOptions = {
+		expand: resolved.expandSnapshotDiff ?? false,
+		snapshotFormat: resolved.snapshotFormat || {},
+		updateSnapshot: isCI && !UPDATE_SNAPSHOT ? "none" : UPDATE_SNAPSHOT ? "all" : "new",
+		resolveSnapshotPath: options.resolveSnapshotPath,
+		snapshotEnvironment: null
+	};
+	resolved.snapshotSerializers ??= [];
+	resolved.snapshotSerializers = resolved.snapshotSerializers.map((file) => resolvePath(file, resolved.root));
+	resolved.forceRerunTriggers.push(...resolved.snapshotSerializers);
+	if (options.resolveSnapshotPath) {
+		delete resolved.resolveSnapshotPath;
+	}
+	resolved.pool ??= "threads";
+	if (process.env.VITEST_MAX_THREADS) {
+		resolved.poolOptions = {
+			...resolved.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 (typeof resolved.workspace === "string") {
+		resolved.workspace = typeof options.workspace === "string" && options.workspace[0] === "." ? resolve(process.cwd(), options.workspace) : resolvePath(resolved.workspace, resolved.root);
+	}
+	if (!builtinPools.includes(resolved.pool)) {
+		resolved.pool = resolvePath(resolved.pool, resolved.root);
+	}
+	if (resolved.poolMatchGlobs) {
+		logger.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "poolMatchGlobs" is deprecated. Use "workspace" to define different configurations instead.`));
+	}
+	resolved.poolMatchGlobs = (resolved.poolMatchGlobs || []).map(([glob, pool]) => {
+		if (!builtinPools.includes(pool)) {
+			pool = resolvePath(pool, resolved.root);
+		}
+		return [glob, pool];
+	});
+	if (mode === "benchmark") {
+		resolved.benchmark = {
+			...benchmarkConfigDefaults,
+			...resolved.benchmark
+		};
+		resolved.coverage.enabled = false;
+		resolved.typecheck.enabled = false;
+		resolved.include = resolved.benchmark.include;
+		resolved.exclude = resolved.benchmark.exclude;
+		resolved.includeSource = resolved.benchmark.includeSource;
+		const reporters = Array.from(new Set([...toArray(resolved.benchmark.reporters), ...toArray(options.reporter)])).filter(Boolean);
+		if (reporters.length) {
+			resolved.benchmark.reporters = reporters;
+		} else {
+			resolved.benchmark.reporters = ["default"];
+		}
+		if (options.outputFile) {
+			resolved.benchmark.outputFile = options.outputFile;
+		}
+		if (options.compare) {
+			resolved.benchmark.compare = options.compare;
+		}
+		if (options.outputJson) {
+			resolved.benchmark.outputJson = options.outputJson;
+		}
+	}
+	if (typeof resolved.diff === "string") {
+		resolved.diff = resolvePath(resolved.diff, resolved.root);
+		resolved.forceRerunTriggers.push(resolved.diff);
+	}
+	const api = resolveApiServerConfig(options, defaultPort);
+	resolved.api = {
+		...api,
+		token: crypto.randomUUID()
+	};
+	if (options.related) {
+		resolved.related = toArray(options.related).map((file) => resolve(resolved.root, file));
+	}
+	if (options.reporters) {
+		if (!Array.isArray(options.reporters)) {
+			if (typeof options.reporters === "string") {
+				resolved.reporters = [[options.reporters, {}]];
+			} else {
+				resolved.reporters = [options.reporters];
+			}
+		} else {
+			resolved.reporters = [];
+			for (const reporter of options.reporters) {
+				if (Array.isArray(reporter)) {
+					resolved.reporters.push([reporter[0], reporter[1] || {}]);
+				} else if (typeof reporter === "string") {
+					resolved.reporters.push([reporter, {}]);
+				} else {
+					resolved.reporters.push(reporter);
+				}
+			}
+		}
+	}
+	if (mode !== "benchmark") {
+		const reportersFromCLI = resolved.reporter;
+		const cliReporters = toArray(reportersFromCLI || []).map((reporter) => {
+			if (/^\.\.?\//.test(reporter)) {
+				return resolve(process.cwd(), reporter);
+			}
+			return reporter;
+		});
+		if (cliReporters.length) {
+			resolved.reporters = Array.from(new Set(toArray(cliReporters))).filter(Boolean).map((reporter) => [reporter, {}]);
+		}
+	}
+	if (!resolved.reporters.length) {
+		resolved.reporters.push(["default", {}]);
+		if (process.env.GITHUB_ACTIONS === "true") {
+			resolved.reporters.push(["github-actions", {}]);
+		}
+	}
+	if (resolved.changed) {
+		resolved.passWithNoTests ??= true;
+	}
+	resolved.css ??= {};
+	if (typeof resolved.css === "object") {
+		resolved.css.modules ??= {};
+		resolved.css.modules.classNameStrategy ??= "stable";
+	}
+	if (resolved.cache !== false) {
+		let cacheDir = VitestCache.resolveCacheDir("", viteConfig.cacheDir, resolved.name);
+		if (resolved.cache && resolved.cache.dir) {
+			logger.console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "cache.dir" is deprecated, use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir\/vitest"`));
+			cacheDir = VitestCache.resolveCacheDir(resolved.root, resolved.cache.dir, resolved.name);
+		}
+		resolved.cache = { dir: cacheDir };
+	}
+	resolved.sequence ??= {};
+	if (resolved.sequence.shuffle && typeof resolved.sequence.shuffle === "object") {
+		const { files, tests } = resolved.sequence.shuffle;
+		resolved.sequence.sequencer ??= files ? RandomSequencer : BaseSequencer;
+		resolved.sequence.shuffle = tests;
+	}
+	if (!resolved.sequence?.sequencer) {
+		resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
+	}
+	resolved.sequence.hooks ??= "stack";
+	if (resolved.sequence.sequencer === RandomSequencer) {
+		resolved.sequence.seed ??= Date.now();
+	}
+	resolved.typecheck = {
+		...configDefaults.typecheck,
+		...resolved.typecheck
+	};
+	if (resolved.environmentMatchGlobs) {
+		logger.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "environmentMatchGlobs" is deprecated. Use "workspace" to define different configurations instead.`));
+	}
+	resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve(resolved.root, i[0]), i[1]]);
+	resolved.typecheck ??= {};
+	resolved.typecheck.enabled ??= false;
+	if (resolved.typecheck.enabled) {
+		logger.console.warn(c.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."));
+	}
+	resolved.browser ??= {};
+	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;
+	if (resolved.browser.screenshotDirectory) {
+		resolved.browser.screenshotDirectory = resolve(resolved.root, resolved.browser.screenshotDirectory);
+	}
+	const isPreview = resolved.browser.provider === "preview";
+	if (isPreview && resolved.browser.screenshotFailures === true) {
+		console.warn(c.yellow([
+			`Browser provider "preview" doesn't support screenshots, `,
+			`so "browser.screenshotFailures" option is forcefully disabled. `,
+			`Set "browser.screenshotFailures" to false or remove it from the config to suppress this warning.`
+		].join("")));
+		resolved.browser.screenshotFailures = false;
+	} else {
+		resolved.browser.screenshotFailures ??= !isPreview && !resolved.browser.ui;
+	}
+	resolved.browser.viewport ??= {};
+	resolved.browser.viewport.width ??= 414;
+	resolved.browser.viewport.height ??= 896;
+	resolved.browser.locators ??= {};
+	resolved.browser.locators.testIdAttribute ??= "data-testid";
+	if (resolved.browser.enabled && provider === "stackblitz") {
+		resolved.browser.provider = "preview";
+	}
+	resolved.browser.api = resolveApiServerConfig(resolved.browser, defaultBrowserPort) || { port: defaultBrowserPort };
+	if (resolved.browser.enabled) {
+		if (resolved.browser.ui) {
+			resolved.includeTaskLocation ??= true;
+		}
+	} else if (resolved.ui) {
+		resolved.includeTaskLocation ??= true;
+	}
+	const htmlReporter = toArray(resolved.reporters).some((reporter) => {
+		if (Array.isArray(reporter)) {
+			return reporter[0] === "html";
+		}
+		return false;
+	});
+	if (htmlReporter) {
+		resolved.includeTaskLocation ??= true;
+	}
+	resolved.testTransformMode ??= {};
+	resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3;
+	resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4;
+	return resolved;
 }
 function isBrowserEnabled(config) {
-  return Boolean(config.browser?.enabled);
+	return Boolean(config.browser?.enabled);
 }
 function resolveCoverageReporters(configReporters) {
-  if (!Array.isArray(configReporters)) {
-    return [[configReporters, {}]];
-  }
-  const resolvedReporters = [];
-  for (const reporter of configReporters) {
-    if (Array.isArray(reporter)) {
-      resolvedReporters.push([reporter[0], reporter[1] || {}]);
-    } else {
-      resolvedReporters.push([reporter, {}]);
-    }
-  }
-  return resolvedReporters;
+	if (!Array.isArray(configReporters)) {
+		return [[configReporters, {}]];
+	}
+	const resolvedReporters = [];
+	for (const reporter of configReporters) {
+		if (Array.isArray(reporter)) {
+			resolvedReporters.push([reporter[0], reporter[1] || {}]);
+		} else {
+			resolvedReporters.push([reporter, {}]);
+		}
+	}
+	return resolvedReporters;
 }
 function isPlaywrightChromiumOnly(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) {
-    const name = instance.name || (config.name ? `${config.name} (${instance.browser})` : instance.browser);
-    if (!vitest._matchesProjectFilter(name)) {
-      continue;
-    }
-    if (instance.browser !== "chromium") {
-      return false;
-    }
-  }
-  return true;
+	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) {
+		const name = instance.name || (config.name ? `${config.name} (${instance.browser})` : instance.browser);
+		if (!vitest.matchesProjectFilter(name)) {
+			continue;
+		}
+		if (instance.browser !== "chromium") {
+			return false;
+		}
+	}
+	return true;
 }
 
 const THRESHOLD_KEYS = [
-  "lines",
-  "functions",
-  "statements",
-  "branches"
+	"lines",
+	"functions",
+	"statements",
+	"branches"
 ];
 const GLOBAL_THRESHOLDS_KEY = "global";
 const DEFAULT_PROJECT = Symbol.for("default-project");
 let uniqueId = 0;
 async function getCoverageProvider(options, loader) {
-  const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule) {
-    return coverageModule.getProvider();
-  }
-  return null;
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) {
+		return coverageModule.getProvider();
+	}
+	return null;
 }
 class BaseCoverageProvider {
-  ctx;
-  name;
-  version;
-  options;
-  coverageFiles = /* @__PURE__ */ new Map();
-  pendingPromises = [];
-  coverageFilesDirectory;
-  _initialize(ctx) {
-    this.ctx = ctx;
-    if (ctx.version !== this.version) {
-      ctx.logger.warn(
-        c.yellow(
-          `Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.
-Running mixed versions is not supported and may lead into bugs
-Update your dependencies and make sure the versions match.`
-        )
-      );
-    }
-    const config = ctx.config.coverage;
-    this.options = {
-      ...coverageConfigDefaults,
-      // User's options
-      ...config,
-      // Resolved fields
-      provider: this.name,
-      reportsDirectory: resolve(
-        ctx.config.root,
-        config.reportsDirectory || coverageConfigDefaults.reportsDirectory
-      ),
-      reporter: resolveCoverageReporters(
-        config.reporter || coverageConfigDefaults.reporter
-      ),
-      thresholds: config.thresholds && {
-        ...config.thresholds,
-        lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
-        branches: config.thresholds["100"] ? 100 : config.thresholds.branches,
-        functions: config.thresholds["100"] ? 100 : config.thresholds.functions,
-        statements: config.thresholds["100"] ? 100 : config.thresholds.statements
-      }
-    };
-    const shard = this.ctx.config.shard;
-    const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
-    this.coverageFilesDirectory = resolve(
-      this.options.reportsDirectory,
-      tempDirectory
-    );
-  }
-  createCoverageMap() {
-    throw new Error("BaseReporter's createCoverageMap was not overwritten");
-  }
-  async generateReports(_, __) {
-    throw new Error("BaseReporter's generateReports was not overwritten");
-  }
-  async parseConfigModule(_) {
-    throw new Error("BaseReporter's parseConfigModule was not overwritten");
-  }
-  resolveOptions() {
-    return this.options;
-  }
-  async clean(clean = true) {
-    if (clean && existsSync(this.options.reportsDirectory)) {
-      await promises$1.rm(this.options.reportsDirectory, {
-        recursive: true,
-        force: true,
-        maxRetries: 10
-      });
-    }
-    if (existsSync(this.coverageFilesDirectory)) {
-      await promises$1.rm(this.coverageFilesDirectory, {
-        recursive: true,
-        force: true,
-        maxRetries: 10
-      });
-    }
-    await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true });
-    this.coverageFiles = /* @__PURE__ */ new Map();
-    this.pendingPromises = [];
-  }
-  onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }) {
-    if (!coverage) {
-      return;
-    }
-    if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
-      throw new Error(`Invalid transform mode: ${transformMode}`);
-    }
-    let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
-    if (!entry) {
-      entry = { web: {}, ssr: {}, browser: {} };
-      this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
-    }
-    const testFilenames = testFiles.join();
-    const filename = resolve(
-      this.coverageFilesDirectory,
-      `coverage-${uniqueId++}.json`
-    );
-    entry[transformMode][testFilenames] = filename;
-    const promise = promises$1.writeFile(filename, JSON.stringify(coverage), "utf-8");
-    this.pendingPromises.push(promise);
-  }
-  async readCoverageFiles({ onFileRead, onFinished, onDebug }) {
-    let index = 0;
-    const total = this.pendingPromises.length;
-    await Promise.all(this.pendingPromises);
-    this.pendingPromises = [];
-    for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
-      for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
-        const filenames = Object.values(coverageByTestfiles);
-        const project = this.ctx.getProjectByName(projectName);
-        for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
-          if (onDebug.enabled) {
-            index += chunk.length;
-            onDebug("Covered files %d/%d", index, total);
-          }
-          await Promise.all(
-            chunk.map(async (filename) => {
-              const contents = await promises$1.readFile(filename, "utf-8");
-              const coverage = JSON.parse(contents);
-              onFileRead(coverage);
-            })
-          );
-        }
-        await onFinished(project, transformMode);
-      }
-    }
-  }
-  async cleanAfterRun() {
-    this.coverageFiles = /* @__PURE__ */ new Map();
-    await promises$1.rm(this.coverageFilesDirectory, { recursive: true });
-    if (readdirSync(this.options.reportsDirectory).length === 0) {
-      await promises$1.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
-    );
-    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
-    if (!keepResults) {
-      await this.cleanAfterRun();
-    }
-  }
-  async reportThresholds(coverageMap, allTestsRun) {
-    const resolvedThresholds = this.resolveThresholds(coverageMap);
-    this.checkThresholds(resolvedThresholds);
-    if (this.options.thresholds?.autoUpdate && allTestsRun) {
-      if (!this.ctx.server.config.configFile) {
-        throw new Error(
-          'Missing configurationFile. The "coverage.thresholds.autoUpdate" can only be enabled when configuration file is used.'
-        );
-      }
-      const configFilePath = this.ctx.server.config.configFile;
-      const configModule = await this.parseConfigModule(configFilePath);
-      await this.updateThresholds({
-        thresholds: resolvedThresholds,
-        configurationFile: configModule,
-        onUpdate: () => writeFileSync(
-          configFilePath,
-          configModule.generate().code,
-          "utf-8"
-        )
-      });
-    }
-  }
-  /**
-   * Constructs collected coverage and users' threshold options into separate sets
-   * where each threshold set holds their own coverage maps. Threshold set is either
-   * for specific files defined by glob pattern or global for all other files.
-   */
-  resolveThresholds(coverageMap) {
-    const resolvedThresholds = [];
-    const files = coverageMap.files();
-    const globalCoverageMap = this.createCoverageMap();
-    for (const key of Object.keys(this.options.thresholds)) {
-      if (key === "perFile" || key === "autoUpdate" || key === "100" || THRESHOLD_KEYS.includes(key)) {
-        continue;
-      }
-      const glob = key;
-      const globThresholds = resolveGlobThresholds(this.options.thresholds[glob]);
-      const globCoverageMap = this.createCoverageMap();
-      const matchingFiles = files.filter(
-        (file) => mm.isMatch(relative(this.ctx.config.root, file), glob)
-      );
-      for (const file of matchingFiles) {
-        const fileCoverage = coverageMap.fileCoverageFor(file);
-        globCoverageMap.addFileCoverage(fileCoverage);
-      }
-      resolvedThresholds.push({
-        name: glob,
-        coverageMap: globCoverageMap,
-        thresholds: globThresholds
-      });
-    }
-    for (const file of files) {
-      const fileCoverage = coverageMap.fileCoverageFor(file);
-      globalCoverageMap.addFileCoverage(fileCoverage);
-    }
-    resolvedThresholds.unshift({
-      name: GLOBAL_THRESHOLDS_KEY,
-      coverageMap: globalCoverageMap,
-      thresholds: {
-        branches: this.options.thresholds?.branches,
-        functions: this.options.thresholds?.functions,
-        lines: this.options.thresholds?.lines,
-        statements: this.options.thresholds?.statements
-      }
-    });
-    return resolvedThresholds;
-  }
-  /**
-   * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
-   */
-  checkThresholds(allThresholds) {
-    for (const { coverageMap, thresholds, name } of allThresholds) {
-      if (thresholds.branches === void 0 && thresholds.functions === void 0 && thresholds.lines === void 0 && thresholds.statements === void 0) {
-        continue;
-      }
-      const summaries = this.options.thresholds?.perFile ? coverageMap.files().map((file) => ({
-        file,
-        summary: coverageMap.fileCoverageFor(file).toSummary()
-      })) : [{ file: null, summary: coverageMap.getCoverageSummary() }];
-      for (const { summary, file } of summaries) {
-        for (const thresholdKey of THRESHOLD_KEYS) {
-          const threshold = thresholds[thresholdKey];
-          if (threshold === void 0) {
-            continue;
-          }
-          if (threshold >= 0) {
-            const coverage = summary.data[thresholdKey].pct;
-            if (coverage < threshold) {
-              process.exitCode = 1;
-              let errorMessage = `ERROR: Coverage for ${thresholdKey} (${coverage}%) does not meet ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
-              if (this.options.thresholds?.perFile && file) {
-                errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
-              }
-              this.ctx.logger.error(errorMessage);
-            }
-          } else {
-            const uncovered = summary.data[thresholdKey].total - summary.data[thresholdKey].covered;
-            const absoluteThreshold = threshold * -1;
-            if (uncovered > absoluteThreshold) {
-              process.exitCode = 1;
-              let errorMessage = `ERROR: Uncovered ${thresholdKey} (${uncovered}) exceed ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${absoluteThreshold})`;
-              if (this.options.thresholds?.perFile && file) {
-                errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
-              }
-              this.ctx.logger.error(errorMessage);
-            }
-          }
-        }
-      }
-    }
-  }
-  /**
-   * Check if current coverage is above configured thresholds and bump the thresholds if needed
-   */
-  async updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }) {
-    let updatedThresholds = false;
-    const config = resolveConfig(configurationFile);
-    assertConfigurationModule(config);
-    for (const { coverageMap, thresholds, name } of allThresholds) {
-      const summaries = this.options.thresholds?.perFile ? coverageMap.files().map(
-        (file) => coverageMap.fileCoverageFor(file).toSummary()
-      ) : [coverageMap.getCoverageSummary()];
-      const thresholdsToUpdate = [];
-      for (const key of THRESHOLD_KEYS) {
-        const threshold = thresholds[key] ?? 100;
-        if (threshold >= 0) {
-          const actual = Math.min(
-            ...summaries.map((summary) => summary[key].pct)
-          );
-          if (actual > threshold) {
-            thresholdsToUpdate.push([key, actual]);
-          }
-        } else {
-          const absoluteThreshold = threshold * -1;
-          const actual = Math.max(
-            ...summaries.map((summary) => summary[key].total - summary[key].covered)
-          );
-          if (actual < absoluteThreshold) {
-            const updatedThreshold = actual === 0 ? 100 : actual * -1;
-            thresholdsToUpdate.push([key, updatedThreshold]);
-          }
-        }
-      }
-      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;
-        }
-      }
-    }
-    if (updatedThresholds) {
-      this.ctx.logger.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds.");
-      onUpdate();
-    }
-  }
-  async mergeReports(coverageMaps) {
-    const coverageMap = this.createCoverageMap();
-    for (const coverage of coverageMaps) {
-      coverageMap.merge(coverage);
-    }
-    await this.generateReports(coverageMap, true);
-  }
-  hasTerminalReporter(reporters) {
-    return reporters.some(
-      ([reporter]) => reporter === "text" || reporter === "text-summary" || reporter === "text-lcov" || reporter === "teamcity"
-    );
-  }
-  toSlices(array, size) {
-    return array.reduce((chunks, item) => {
-      const index = Math.max(0, chunks.length - 1);
-      const lastChunk = chunks[index] || [];
-      chunks[index] = lastChunk;
-      if (lastChunk.length >= size) {
-        chunks.push([item]);
-      } else {
-        lastChunk.push(item);
-      }
-      return chunks;
-    }, []);
-  }
-  createUncoveredFileTransformer(ctx) {
-    const servers = [
-      ...ctx.projects.map((project) => ({
-        root: project.config.root,
-        isBrowserEnabled: project.isBrowserEnabled(),
-        vitenode: project.vitenode
-      })),
-      // Check core last as it will match all files anyway
-      { root: ctx.config.root, vitenode: ctx.vitenode, isBrowserEnabled: ctx.getRootProject().isBrowserEnabled() }
-    ];
-    return async function transformFile(filename) {
-      let lastError;
-      for (const { root, vitenode, isBrowserEnabled } of servers) {
-        if (!filename.startsWith(root) && !filename.startsWith(`/${root}`)) {
-          continue;
-        }
-        if (isBrowserEnabled) {
-          const result = await vitenode.transformRequest(filename, void 0, "web").catch(() => null);
-          if (result) {
-            return result;
-          }
-        }
-        try {
-          return await vitenode.transformRequest(filename);
-        } catch (error) {
-          lastError = error;
-        }
-      }
-      throw lastError;
-    };
-  }
+	ctx;
+	name;
+	version;
+	options;
+	coverageFiles = new Map();
+	pendingPromises = [];
+	coverageFilesDirectory;
+	_initialize(ctx) {
+		this.ctx = ctx;
+		if (ctx.version !== this.version) {
+			ctx.logger.warn(c.yellow(`Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.` + "\nRunning mixed versions is not supported and may lead into bugs" + "\nUpdate your dependencies and make sure the versions match."));
+		}
+		const config = ctx.config.coverage;
+		this.options = {
+			...coverageConfigDefaults,
+			...config,
+			provider: this.name,
+			reportsDirectory: resolve(ctx.config.root, config.reportsDirectory || coverageConfigDefaults.reportsDirectory),
+			reporter: resolveCoverageReporters(config.reporter || coverageConfigDefaults.reporter),
+			thresholds: config.thresholds && {
+				...config.thresholds,
+				lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
+				branches: config.thresholds["100"] ? 100 : config.thresholds.branches,
+				functions: config.thresholds["100"] ? 100 : config.thresholds.functions,
+				statements: config.thresholds["100"] ? 100 : config.thresholds.statements
+			}
+		};
+		const shard = this.ctx.config.shard;
+		const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
+		this.coverageFilesDirectory = resolve(this.options.reportsDirectory, tempDirectory);
+	}
+	createCoverageMap() {
+		throw new Error("BaseReporter's createCoverageMap was not overwritten");
+	}
+	async generateReports(_, __) {
+		throw new Error("BaseReporter's generateReports was not overwritten");
+	}
+	async parseConfigModule(_) {
+		throw new Error("BaseReporter's parseConfigModule was not overwritten");
+	}
+	resolveOptions() {
+		return this.options;
+	}
+	async clean(clean = true) {
+		if (clean && existsSync(this.options.reportsDirectory)) {
+			await promises$1.rm(this.options.reportsDirectory, {
+				recursive: true,
+				force: true,
+				maxRetries: 10
+			});
+		}
+		if (existsSync(this.coverageFilesDirectory)) {
+			await promises$1.rm(this.coverageFilesDirectory, {
+				recursive: true,
+				force: true,
+				maxRetries: 10
+			});
+		}
+		await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true });
+		this.coverageFiles = new Map();
+		this.pendingPromises = [];
+	}
+	onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }) {
+		if (!coverage) {
+			return;
+		}
+		if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
+			throw new Error(`Invalid transform mode: ${transformMode}`);
+		}
+		let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
+		if (!entry) {
+			entry = {
+				web: {},
+				ssr: {},
+				browser: {}
+			};
+			this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
+		}
+		const testFilenames = testFiles.join();
+		const filename = resolve(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
+		entry[transformMode][testFilenames] = filename;
+		const promise = promises$1.writeFile(filename, JSON.stringify(coverage), "utf-8");
+		this.pendingPromises.push(promise);
+	}
+	async readCoverageFiles({ onFileRead, onFinished, onDebug }) {
+		let index = 0;
+		const total = this.pendingPromises.length;
+		await Promise.all(this.pendingPromises);
+		this.pendingPromises = [];
+		for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
+			for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
+				const filenames = Object.values(coverageByTestfiles);
+				const project = this.ctx.getProjectByName(projectName);
+				for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
+					if (onDebug.enabled) {
+						index += chunk.length;
+						onDebug("Covered files %d/%d", index, total);
+					}
+					await Promise.all(chunk.map(async (filename) => {
+						const contents = await promises$1.readFile(filename, "utf-8");
+						const coverage = JSON.parse(contents);
+						onFileRead(coverage);
+					}));
+				}
+				await onFinished(project, transformMode);
+			}
+		}
+	}
+	async cleanAfterRun() {
+		this.coverageFiles = new Map();
+		await promises$1.rm(this.coverageFilesDirectory, { recursive: true });
+		if (readdirSync(this.options.reportsDirectory).length === 0) {
+			await promises$1.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);
+		const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
+		if (!keepResults) {
+			await this.cleanAfterRun();
+		}
+	}
+	async reportThresholds(coverageMap, allTestsRun) {
+		const resolvedThresholds = this.resolveThresholds(coverageMap);
+		this.checkThresholds(resolvedThresholds);
+		if (this.options.thresholds?.autoUpdate && allTestsRun) {
+			if (!this.ctx.server.config.configFile) {
+				throw new Error("Missing configurationFile. The \"coverage.thresholds.autoUpdate\" can only be enabled when configuration file is used.");
+			}
+			const configFilePath = this.ctx.server.config.configFile;
+			const configModule = await this.parseConfigModule(configFilePath);
+			await this.updateThresholds({
+				thresholds: resolvedThresholds,
+				configurationFile: configModule,
+				onUpdate: () => writeFileSync(configFilePath, configModule.generate().code, "utf-8")
+			});
+		}
+	}
+	/**
+	* Constructs collected coverage and users' threshold options into separate sets
+	* where each threshold set holds their own coverage maps. Threshold set is either
+	* for specific files defined by glob pattern or global for all other files.
+	*/
+	resolveThresholds(coverageMap) {
+		const resolvedThresholds = [];
+		const files = coverageMap.files();
+		const globalCoverageMap = this.createCoverageMap();
+		for (const key of Object.keys(this.options.thresholds)) {
+			if (key === "perFile" || key === "autoUpdate" || key === "100" || THRESHOLD_KEYS.includes(key)) {
+				continue;
+			}
+			const glob = key;
+			const globThresholds = resolveGlobThresholds(this.options.thresholds[glob]);
+			const globCoverageMap = this.createCoverageMap();
+			const matchingFiles = files.filter((file) => mm.isMatch(relative(this.ctx.config.root, file), glob));
+			for (const file of matchingFiles) {
+				const fileCoverage = coverageMap.fileCoverageFor(file);
+				globCoverageMap.addFileCoverage(fileCoverage);
+			}
+			resolvedThresholds.push({
+				name: glob,
+				coverageMap: globCoverageMap,
+				thresholds: globThresholds
+			});
+		}
+		for (const file of files) {
+			const fileCoverage = coverageMap.fileCoverageFor(file);
+			globalCoverageMap.addFileCoverage(fileCoverage);
+		}
+		resolvedThresholds.unshift({
+			name: GLOBAL_THRESHOLDS_KEY,
+			coverageMap: globalCoverageMap,
+			thresholds: {
+				branches: this.options.thresholds?.branches,
+				functions: this.options.thresholds?.functions,
+				lines: this.options.thresholds?.lines,
+				statements: this.options.thresholds?.statements
+			}
+		});
+		return resolvedThresholds;
+	}
+	/**
+	* Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+	*/
+	checkThresholds(allThresholds) {
+		for (const { coverageMap, thresholds, name } of allThresholds) {
+			if (thresholds.branches === undefined && thresholds.functions === undefined && thresholds.lines === undefined && thresholds.statements === undefined) {
+				continue;
+			}
+			const summaries = this.options.thresholds?.perFile ? coverageMap.files().map((file) => ({
+				file,
+				summary: coverageMap.fileCoverageFor(file).toSummary()
+			})) : [{
+				file: null,
+				summary: coverageMap.getCoverageSummary()
+			}];
+			for (const { summary, file } of summaries) {
+				for (const thresholdKey of THRESHOLD_KEYS) {
+					const threshold = thresholds[thresholdKey];
+					if (threshold === undefined) {
+						continue;
+					}
+					/**
+					* Positive thresholds are treated as minimum coverage percentages (X means: X% of lines must be covered),
+					* while negative thresholds are treated as maximum uncovered counts (-X means: X lines may be uncovered).
+					*/
+					if (threshold >= 0) {
+						const coverage = summary.data[thresholdKey].pct;
+						if (coverage < threshold) {
+							process.exitCode = 1;
+							/**
+							* Generate error message based on perFile flag:
+							* - ERROR: Coverage for statements (33.33%) does not meet threshold (85%) for src/math.ts
+							* - ERROR: Coverage for statements (50%) does not meet global threshold (85%)
+							*/
+							let errorMessage = `ERROR: Coverage for ${thresholdKey} (${coverage}%) does not meet ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
+							if (this.options.thresholds?.perFile && file) {
+								errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
+							}
+							this.ctx.logger.error(errorMessage);
+						}
+					} else {
+						const uncovered = summary.data[thresholdKey].total - summary.data[thresholdKey].covered;
+						const absoluteThreshold = threshold * -1;
+						if (uncovered > absoluteThreshold) {
+							process.exitCode = 1;
+							/**
+							* Generate error message based on perFile flag:
+							* - ERROR: Uncovered statements (33) exceed threshold (30) for src/math.ts
+							* - ERROR: Uncovered statements (33) exceed global threshold (30)
+							*/
+							let errorMessage = `ERROR: Uncovered ${thresholdKey} (${uncovered}) exceed ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${absoluteThreshold})`;
+							if (this.options.thresholds?.perFile && file) {
+								errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
+							}
+							this.ctx.logger.error(errorMessage);
+						}
+					}
+				}
+			}
+		}
+	}
+	/**
+	* Check if current coverage is above configured thresholds and bump the thresholds if needed
+	*/
+	async updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }) {
+		let updatedThresholds = false;
+		const config = resolveConfig(configurationFile);
+		assertConfigurationModule(config);
+		for (const { coverageMap, thresholds, name } of allThresholds) {
+			const summaries = this.options.thresholds?.perFile ? coverageMap.files().map((file) => coverageMap.fileCoverageFor(file).toSummary()) : [coverageMap.getCoverageSummary()];
+			const thresholdsToUpdate = [];
+			for (const key of THRESHOLD_KEYS) {
+				const threshold = thresholds[key] ?? 100;
+				/**
+				* Positive thresholds are treated as minimum coverage percentages (X means: X% of lines must be covered),
+				* while negative thresholds are treated as maximum uncovered counts (-X means: X lines may be uncovered).
+				*/
+				if (threshold >= 0) {
+					const actual = Math.min(...summaries.map((summary) => summary[key].pct));
+					if (actual > threshold) {
+						thresholdsToUpdate.push([key, actual]);
+					}
+				} else {
+					const absoluteThreshold = threshold * -1;
+					const actual = Math.max(...summaries.map((summary) => summary[key].total - summary[key].covered));
+					if (actual < absoluteThreshold) {
+						const updatedThreshold = actual === 0 ? 100 : actual * -1;
+						thresholdsToUpdate.push([key, updatedThreshold]);
+					}
+				}
+			}
+			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;
+				}
+			}
+		}
+		if (updatedThresholds) {
+			this.ctx.logger.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds.");
+			onUpdate();
+		}
+	}
+	async mergeReports(coverageMaps) {
+		const coverageMap = this.createCoverageMap();
+		for (const coverage of coverageMaps) {
+			coverageMap.merge(coverage);
+		}
+		await this.generateReports(coverageMap, true);
+	}
+	hasTerminalReporter(reporters) {
+		return reporters.some(([reporter]) => reporter === "text" || reporter === "text-summary" || reporter === "text-lcov" || reporter === "teamcity");
+	}
+	toSlices(array, size) {
+		return array.reduce((chunks, item) => {
+			const index = Math.max(0, chunks.length - 1);
+			const lastChunk = chunks[index] || [];
+			chunks[index] = lastChunk;
+			if (lastChunk.length >= size) {
+				chunks.push([item]);
+			} else {
+				lastChunk.push(item);
+			}
+			return chunks;
+		}, []);
+	}
+	createUncoveredFileTransformer(ctx) {
+		const servers = [...ctx.projects.map((project) => ({
+			root: project.config.root,
+			isBrowserEnabled: project.isBrowserEnabled(),
+			vitenode: project.vitenode
+		})), {
+			root: ctx.config.root,
+			vitenode: ctx.vitenode,
+			isBrowserEnabled: ctx.getRootProject().isBrowserEnabled()
+		}];
+		return async function transformFile(filename) {
+			let lastError;
+			for (const { root, vitenode, isBrowserEnabled } of servers) {
+				if (!filename.startsWith(root) && !filename.startsWith(`/${root}`)) {
+					continue;
+				}
+				if (isBrowserEnabled) {
+					const result = await vitenode.transformRequest(filename, undefined, "web").catch(() => null);
+					if (result) {
+						return result;
+					}
+				}
+				try {
+					return await vitenode.transformRequest(filename);
+				} catch (error) {
+					lastError = error;
+				}
+			}
+			throw lastError;
+		};
+	}
 }
+/**
+* Narrow down `unknown` glob thresholds to resolved ones
+*/
 function resolveGlobThresholds(thresholds) {
-  if (!thresholds || typeof thresholds !== "object") {
-    return {};
-  }
-  if (100 in thresholds && thresholds[100] === true) {
-    return {
-      lines: 100,
-      branches: 100,
-      functions: 100,
-      statements: 100
-    };
-  }
-  return {
-    lines: "lines" in thresholds && typeof thresholds.lines === "number" ? thresholds.lines : void 0,
-    branches: "branches" in thresholds && typeof thresholds.branches === "number" ? thresholds.branches : void 0,
-    functions: "functions" in thresholds && typeof thresholds.functions === "number" ? thresholds.functions : void 0,
-    statements: "statements" in thresholds && typeof thresholds.statements === "number" ? thresholds.statements : void 0
-  };
+	if (!thresholds || typeof thresholds !== "object") {
+		return {};
+	}
+	if (100 in thresholds && thresholds[100] === true) {
+		return {
+			lines: 100,
+			branches: 100,
+			functions: 100,
+			statements: 100
+		};
+	}
+	return {
+		lines: "lines" in thresholds && typeof thresholds.lines === "number" ? thresholds.lines : undefined,
+		branches: "branches" in thresholds && typeof thresholds.branches === "number" ? thresholds.branches : undefined,
+		functions: "functions" in thresholds && typeof thresholds.functions === "number" ? thresholds.functions : undefined,
+		statements: "statements" in thresholds && typeof thresholds.statements === "number" ? thresholds.statements : undefined
+	};
 }
 function assertConfigurationModule(config) {
-  try {
-    if (typeof config.test.coverage.thresholds !== "object") {
-      throw new TypeError(
-        "Expected config.test.coverage.thresholds to be an object"
-      );
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Unable to parse thresholds from configuration file: ${message}`
-    );
-  }
+	try {
+		if (typeof config.test.coverage.thresholds !== "object") {
+			throw new TypeError("Expected config.test.coverage.thresholds to be an object");
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Unable to parse thresholds from configuration file: ${message}`);
+	}
 }
 function resolveConfig(configModule) {
-  const mod = configModule.exports.default;
-  try {
-    if (mod.$type === "object") {
-      return mod;
-    }
-    let config = resolveDefineConfig(mod);
-    if (config) {
-      return config;
-    }
-    if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
-      config = resolveMergeConfig(mod);
-      if (config) {
-        return config;
-      }
-    }
-  } catch (error) {
-    throw new Error(error instanceof Error ? error.message : String(error));
-  }
-  throw new Error(
-    "Failed to update coverage thresholds. Configuration file is too complex."
-  );
+	const mod = configModule.exports.default;
+	try {
+		if (mod.$type === "object") {
+			return mod;
+		}
+		let config = resolveDefineConfig(mod);
+		if (config) {
+			return config;
+		}
+		if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
+			config = resolveMergeConfig(mod);
+			if (config) {
+				return config;
+			}
+		}
+	} catch (error) {
+		throw new Error(error instanceof Error ? error.message : String(error));
+	}
+	throw new Error("Failed to update coverage thresholds. Configuration file is too complex.");
 }
 function resolveDefineConfig(mod) {
-  if (mod.$type === "function-call" && mod.$callee === "defineConfig") {
-    if (mod.$args[0].$type === "object") {
-      return mod.$args[0];
-    }
-    if (mod.$args[0].$type === "arrow-function-expression") {
-      if (mod.$args[0].$body.$type === "object") {
-        return mod.$args[0].$body;
-      }
-      const config = resolveMergeConfig(mod.$args[0].$body);
-      if (config) {
-        return config;
-      }
-    }
-  }
+	if (mod.$type === "function-call" && mod.$callee === "defineConfig") {
+		if (mod.$args[0].$type === "object") {
+			return mod.$args[0];
+		}
+		if (mod.$args[0].$type === "arrow-function-expression") {
+			if (mod.$args[0].$body.$type === "object") {
+				return mod.$args[0].$body;
+			}
+			const config = resolveMergeConfig(mod.$args[0].$body);
+			if (config) {
+				return config;
+			}
+		}
+	}
 }
 function resolveMergeConfig(mod) {
-  if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
-    for (const arg of mod.$args) {
-      const config = resolveDefineConfig(arg);
-      if (config) {
-        return config;
-      }
-    }
-  }
+	if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
+		for (const arg of mod.$args) {
+			const config = resolveDefineConfig(arg);
+			if (config) {
+				return config;
+			}
+		}
+	}
 }
 
 export { BaseCoverageProvider as B, RandomSequencer as R, VitestCache as V, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, isBrowserEnabled as d, groupBy as e, getCoverageProvider as f, getFilePoolName as g, hash as h, isPackageExists as i, createPool as j, mm as m, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };