vitest 4.0.0-beta.11 → 4.0.0-beta.12

package/dist/chunks/{coverage.CG6Uhorw.js → coverage.CiB0fs_7.js}

@@ -20,13 +20,13 @@ import { a as isWindows } from './env.D4Lgay0q.js';
 import * as nodeos from 'node:os';
 import nodeos__default, { tmpdir } from 'node:os';
 import { isatty } from 'node:tty';
+import { rootDir } from '../path.js';
 import EventEmitter from 'node:events';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.gXq-5P3n.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.BfOQ86_a.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
-import { rootDir } from '../path.js';
 import { isCI, provider } from 'std-env';
 import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 
@@ -2403,17 +2403,17 @@ async function groupFilesByEnv(files) {
 		if (envOptionsJson?.endsWith("*/"))
  // Trim closing Docblock characters the above regex might have captured
 		envOptionsJson = envOptionsJson.slice(0, -2);
-		const envOptions = JSON.parse(envOptionsJson || "null"), envKey = env === "happy-dom" ? "happyDOM" : env, environment = {
-			name: env,
-			options: envOptions ? { [envKey]: envOptions } : null
-		};
+		const envOptions = JSON.parse(envOptionsJson || "null");
 		return {
 			file: {
 				filepath,
 				testLocations: testLines
 			},
 			project,
-			environment
+			environment: {
+				name: env,
+				options: envOptions ? { [env === "happy-dom" ? "happyDOM" : env]: envOptions } : null
+			}
 		};
 	}));
 	return groupBy(filesWithEnv, ({ environment }) => environment.name);
@@ -2609,8 +2609,8 @@ function createMethodsRPC(project, options = {}) {
 		async transform(id) {
 			const environment = project.vite.environments.__vitest_vm__;
 			if (!environment) throw new Error(`The VM environment was not defined in the Vite config. This is a bug in Vitest. Please, open a new issue with reproduction.`);
-			const url = normalizeResolvedIdToUrl(environment, fileURLToPath$1(id)), result = await environment.transformRequest(url).catch(handleRollupError);
-			return { code: result?.code };
+			const url = normalizeResolvedIdToUrl(environment, fileURLToPath$1(id));
+			return { code: (await environment.transformRequest(url).catch(handleRollupError))?.code };
 		},
 		async onQueued(file) {
 			if (options.collect) ctx.state.collectFiles(project, [file]);
@@ -2675,15 +2675,13 @@ function createChildProcessChannel$1(project, collect = false) {
 		},
 		timeout: -1
 	});
-	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	const channel = {
+	return project.vitest.onCancel((reason) => rpc.onCancel(reason)), {
 		onMessage: (callback) => emitter.on(events.message, callback),
 		postMessage: (message) => emitter.emit(events.response, message),
 		onClose: () => {
 			emitter.removeAllListeners(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
 		}
 	};
-	return channel;
 }
 function createForksPool(vitest, { execArgv, env }, specifications) {
 	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.forks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, options = {
@@ -2781,14 +2779,12 @@ function createWorkerChannel$1(project, collect) {
 		},
 		timeout: -1
 	});
-	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	const onClose = () => {
-		port.close(), workerPort.close(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
-	};
-	return {
+	return project.vitest.onCancel((reason) => rpc.onCancel(reason)), {
 		workerPort,
 		port,
-		onClose
+		onClose: () => {
+			port.close(), workerPort.close(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
+		}
 	};
 }
 function createThreadsPool(vitest, { execArgv, env }, specifications) {
@@ -2883,8 +2879,7 @@ function createTypecheckPool(vitest) {
 	async function onParseEnd(project, { files, sourceErrors }) {
 		const checker = project.typechecker, { packs, events } = checker.getTestPacksAndEvents();
 		if (await vitest._testRun.updated(packs, events), !project.config.typecheck.ignoreSourceErrors) sourceErrors.forEach((error) => vitest.state.catchError(error, "Unhandled Source Error"));
-		const processError = !hasFailed(files) && !sourceErrors.length && checker.getExitCode();
-		if (processError) {
+		if (!hasFailed(files) && !sourceErrors.length && checker.getExitCode()) {
 			const error = new Error(checker.getOutput());
 			error.stack = "", vitest.state.catchError(error, "Typecheck Error");
 		}
@@ -2927,14 +2922,14 @@ function createTypecheckPool(vitest) {
 	async function runTests(specs) {
 		const specsByProject = groupBy(specs, (spec) => spec.project.name), promises = [];
 		for (const name in specsByProject) {
-			const project = specsByProject[name][0].project, files = specsByProject[name].map((spec) => spec.moduleId), promise = createDefer(), _p = new Promise((resolve) => {
+			const project = specsByProject[name][0].project, files = specsByProject[name].map((spec) => spec.moduleId), promise = createDefer(), triggered = await new Promise((resolve) => {
 				const _i = setInterval(() => {
 					if (!project.typechecker || rerunTriggered.has(project)) resolve(true), clearInterval(_i);
 				});
 				setTimeout(() => {
 					resolve(false), clearInterval(_i);
 				}, 500).unref();
-			}), triggered = await _p;
+			});
 			if (project.typechecker && !triggered) {
 				const testFiles = project.typechecker.getTestFiles();
 				for (const file of testFiles) await vitest._testRun.enqueued(project, file);
@@ -2963,14 +2958,10 @@ function getDefaultThreadsCount(config) {
 function getWorkerMemoryLimit(config, pool) {
 	if (pool === "vmForks") {
 		const opts = config.poolOptions?.vmForks ?? {};
-		if (opts.memoryLimit) return opts.memoryLimit;
-		const workers = opts.maxForks ?? getDefaultThreadsCount(config);
-		return 1 / workers;
+		return opts.memoryLimit ? opts.memoryLimit : 1 / (opts.maxForks ?? getDefaultThreadsCount(config));
 	} else {
 		const opts = config.poolOptions?.vmThreads ?? {};
-		if (opts.memoryLimit) return opts.memoryLimit;
-		const workers = opts.maxThreads ?? getDefaultThreadsCount(config);
-		return 1 / workers;
+		return opts.memoryLimit ? opts.memoryLimit : 1 / (opts.maxThreads ?? getDefaultThreadsCount(config));
 	}
 }
 /**
@@ -3009,7 +3000,6 @@ function stringToBytes(input, percentageReference) {
 	return null;
 }
 
-const suppressWarningsPath$1 = resolve(rootDir, "./suppress-warnings.cjs");
 function createChildProcessChannel(project, collect) {
 	const emitter = new EventEmitter(), events = {
 		message: "message",
@@ -3039,15 +3029,13 @@ function createChildProcessChannel(project, collect) {
 		},
 		timeout: -1
 	});
-	project.vitest.onCancel((reason) => rpc.onCancel(reason));
-	const channel = {
+	return project.vitest.onCancel((reason) => rpc.onCancel(reason)), { channel: {
 		onMessage: (callback) => emitter.on(events.message, callback),
 		postMessage: (message) => emitter.emit(events.response, message),
 		onClose: () => {
 			emitter.removeAllListeners(), rpc.$close(/* @__PURE__ */ new Error("[vitest-pool]: Pending methods while closing rpc"));
 		}
-	};
-	return { channel };
+	} };
 }
 function createVmForksPool(vitest, { execArgv, env }, specifications) {
 	const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length, threadsCount = vitest.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1), recommendedCount = vitest.config.watch ? threadsCount : Math.min(threadsCount, specifications.length), poolOptions = vitest.config.poolOptions?.vmForks ?? {}, maxThreads = poolOptions.maxForks ?? vitest.config.maxWorkers ?? recommendedCount, minThreads = vitest.config.watch ? Math.min(recommendedCount, maxThreads) : 0, options = {
@@ -3057,10 +3045,7 @@ function createVmForksPool(vitest, { execArgv, env }, specifications) {
 		minThreads,
 		env,
 		execArgv: [
-			"--experimental-import-meta-resolve",
 			"--experimental-vm-modules",
-			"--require",
-			suppressWarningsPath$1,
 			...poolOptions.execArgv ?? [],
 			...execArgv
 		],
@@ -3105,7 +3090,7 @@ function createVmForksPool(vitest, { execArgv, env }, specifications) {
 				if (configs.has(project)) return configs.get(project);
 				const _config = project.serializedConfig, config = wrapSerializableConfig(_config);
 				return configs.set(project, config), config;
-			}, filesByEnv = await groupFilesByEnv(specs), promises = Object.values(filesByEnv).flat(), results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))), errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+			}, filesByEnv = await groupFilesByEnv(specs), promises = Object.values(filesByEnv).flat(), errors = (await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)))).filter((r) => r.status === "rejected").map((r) => r.reason);
 			if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
 		};
 	};
@@ -3122,7 +3107,6 @@ function getMemoryLimit$1(config) {
 	return typeof memory === "number" ? stringToBytes(limit, config.watch ? memory / 2 : memory) : typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%" ? stringToBytes(limit) : null;
 }
 
-const suppressWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
 function createWorkerChannel(project, collect) {
 	const channel = new MessageChannel(), port = channel.port2, workerPort = channel.port1, rpc = createBirpc(createMethodsRPC(project, { collect }), {
 		eventNames: ["onCancel"],
@@ -3151,10 +3135,7 @@ function createVmThreadsPool(vitest, { execArgv, env }, specifications) {
 		minThreads,
 		env,
 		execArgv: [
-			"--experimental-import-meta-resolve",
 			"--experimental-vm-modules",
-			"--require",
-			suppressWarningsPath,
 			...poolOptions.execArgv ?? [],
 			...execArgv
 		],
@@ -3200,7 +3181,7 @@ function createVmThreadsPool(vitest, { execArgv, env }, specifications) {
 				if (configs.has(project)) return configs.get(project);
 				const config = project.serializedConfig;
 				return configs.set(project, config), config;
-			}, filesByEnv = await groupFilesByEnv(specs), promises = Object.values(filesByEnv).flat(), results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))), errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+			}, filesByEnv = await groupFilesByEnv(specs), promises = Object.values(filesByEnv).flat(), errors = (await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)))).filter((r) => r.status === "rejected").map((r) => r.reason);
 			if (errors.length > 0) throw new AggregateError(errors, "Errors occurred while running tests. For more information, see serialized error.");
 		};
 	};
@@ -3217,6 +3198,7 @@ function getMemoryLimit(config) {
 	return typeof memory === "number" ? stringToBytes(limit, config.watch ? memory / 2 : memory) : typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%" ? stringToBytes(limit) : null;
 }
 
+const suppressWarningsPath = resolve$1(rootDir, "./suppress-warnings.cjs");
 const builtinPools = [
 	"forks",
 	"threads",
@@ -3239,18 +3221,24 @@ function createPool(ctx) {
 		vmThreads: null,
 		vmForks: null,
 		typescript: null
-	}, viteMajor = Number(version.split(".")[0]), potentialConditions = new Set(viteMajor >= 6 ? ctx.vite.config.ssr.resolve?.conditions ?? [] : [
+	}, viteMajor = Number(version.split(".")[0]), conditions = [...new Set(viteMajor >= 6 ? ctx.vite.config.ssr.resolve?.conditions ?? [] : [
 		"production",
 		"development",
 		...ctx.vite.config.resolve.conditions
-	]), conditions = [...potentialConditions].filter((condition) => {
+	])].filter((condition) => {
 		return condition === "production" ? ctx.vite.config.isProduction : condition === "development" ? !ctx.vite.config.isProduction : true;
 	}).map((condition) => {
 		return viteMajor >= 6 && condition === "development|production" ? ctx.vite.config.isProduction ? "production" : "development" : condition;
 	}).flatMap((c) => ["--conditions", c]), execArgv = process.execArgv.filter((execArg) => execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"));
 	async function executeTests(method, files, invalidate) {
 		const options = {
-			execArgv: [...execArgv, ...conditions],
+			execArgv: [
+				...execArgv,
+				...conditions,
+				"--experimental-import-meta-resolve",
+				"--require",
+				suppressWarningsPath
+			],
 			env: {
 				TEST: "true",
 				VITEST: "true",
@@ -3355,7 +3343,7 @@ class BaseSequencer {
 	async shard(files) {
 		const { config } = this.ctx, { index, count } = config.shard, [shardStart, shardEnd] = this.calculateShardRange(files.length, index, count);
 		return [...files].map((spec) => {
-			const fullPath = resolve$1(slash(config.root), slash(spec.moduleId)), specPath = fullPath?.slice(config.root.length);
+			const specPath = resolve$1(slash(config.root), slash(spec.moduleId))?.slice(config.root.length);
 			return {
 				spec,
 				hash: hash("sha1", specPath, "hex")
@@ -3578,10 +3566,8 @@ function resolveConfig$1(vitest, options, viteConfig) {
 			maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
 		}
 	};
-	const poolThreadsOptions = [["threads", "maxThreads"], ["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", "maxForks"], ["vmForks", "maxForks"]];
-	for (const [poolOptionKey, workerOptionKey] of poolForksOptions) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
+	for (const [poolOptionKey, workerOptionKey] of [["threads", "maxThreads"], ["vmThreads", "maxThreads"]]) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
+	for (const [poolOptionKey, workerOptionKey] of [["forks", "maxForks"], ["vmForks", "maxForks"]]) if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
 	if (!builtinPools.includes(resolved.pool)) resolved.pool = resolvePath(resolved.pool, resolved.root);
 	if (mode === "benchmark") {
 		resolved.benchmark = {
@@ -3597,10 +3583,8 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		if (options.outputJson) resolved.benchmark.outputJson = options.outputJson;
 	}
 	if (typeof resolved.diff === "string") resolved.diff = resolvePath(resolved.diff, resolved.root), resolved.forceRerunTriggers.push(resolved.diff);
-	// the server has been created, we don't need to override vite.server options
-	const api = resolveApiServerConfig(options, defaultPort);
 	if (resolved.api = {
-		...api,
+		...resolveApiServerConfig(options, defaultPort),
 		token: crypto.randomUUID()
 	}, options.related) resolved.related = toArray(options.related).map((file) => resolve$1(resolved.root, file));
 	/*
@@ -3675,10 +3659,11 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	if (resolved.browser.api = resolveApiServerConfig(resolved.browser, defaultBrowserPort) || { port: defaultBrowserPort }, resolved.browser.enabled) {
 		if (resolved.browser.ui) resolved.includeTaskLocation ??= true;
 	} else if (resolved.ui) resolved.includeTaskLocation ??= true;
-	const htmlReporter = toArray(resolved.reporters).some((reporter) => {
+	if (typeof resolved.browser.trace === "string" || !resolved.browser.trace) resolved.browser.trace = { mode: resolved.browser.trace || "off" };
+	if (resolved.browser.trace.tracesDir != null) resolved.browser.trace.tracesDir = resolvePath(resolved.browser.trace.tracesDir, resolved.root);
+	if (toArray(resolved.reporters).some((reporter) => {
 		return Array.isArray(reporter) ? reporter[0] === "html" : false;
-	});
-	if (htmlReporter) resolved.includeTaskLocation ??= true;
+	})) resolved.includeTaskLocation ??= true;
 	return resolved.server ??= {}, resolved.server.deps ??= {}, resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3, resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4, resolved;
 }
 function isBrowserEnabled(config) {
@@ -3788,8 +3773,8 @@ Update your dependencies and make sure the versions match.`));
 	}
 	async getUntestedFiles(testedFiles) {
 		if (this.options.include == null) return [];
-		const rootMapper = this.getUntestedFilesByRoot.bind(this, testedFiles, this.options.include), matrix = await Promise.all(this.roots.map(rootMapper));
-		return matrix.flatMap((files) => files);
+		const rootMapper = this.getUntestedFilesByRoot.bind(this, testedFiles, this.options.include);
+		return (await Promise.all(this.roots.map(rootMapper))).flatMap((files) => files);
 	}
 	createCoverageMap() {
 		throw new Error("BaseReporter's createCoverageMap was not overwritten");
@@ -3850,10 +3835,7 @@ Update your dependencies and make sure the versions match.`));
 		if (!this.options.reportOnFailure) await this.cleanAfterRun();
 	}
 	async reportCoverage(coverageMap, { allTestsRun }) {
-		await this.generateReports(coverageMap || this.createCoverageMap(), allTestsRun);
-		// In watch mode we need to preserve the previous results if cleanOnRerun is disabled
-		const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
-		if (!keepResults) await this.cleanAfterRun();
+		if (await this.generateReports(coverageMap || this.createCoverageMap(), allTestsRun), !(!this.options.cleanOnRerun && this.ctx.config.watch)) await this.cleanAfterRun();
 	}
 	async reportThresholds(coverageMap, allTestsRun) {
 		const resolvedThresholds = this.resolveThresholds(coverageMap);

package/dist/chunks/{creator.08Gi-vCA.js → creator.DfXDsUyL.js}

@@ -2,11 +2,12 @@ import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { resolve, dirname, relative } from 'node:path';
 import { detectPackageManager, installPackage } from './index.D3XRDfWc.js';
-import { p as prompt, f as findUp } from './index.X0nbfr6-.js';
+import { p as prompt, a as any } from './index.Dc3xnDvT.js';
 import { x } from 'tinyexec';
 import c from 'tinyrainbow';
 import { c as configFiles } from './constants.D_Q9UYh-.js';
 import 'node:process';
+import 'node:module';
 import 'node:url';
 import './_commonjsHelpers.BFTU3MAI.js';
 import 'readline';
@@ -297,12 +298,11 @@ async function generateExampleFiles(framework, lang) {
 // eslint-disable-next-line no-console
 const log = console.log;
 function getProviderOptions() {
-	const providers = {
+	return Object.entries({
 		playwright: "Playwright relies on Chrome DevTools protocol. Read more: https://playwright.dev",
 		webdriverio: "WebdriverIO uses WebDriver protocol. Read more: https://webdriver.io",
 		preview: "Preview is useful to quickly run your tests in the browser, but not suitable for CI."
-	};
-	return Object.entries(providers).map(([provider, description]) => {
+	}).map(([provider, description]) => {
 		return {
 			title: provider,
 			description,
@@ -476,9 +476,7 @@ function getProviderDocsLink(provider) {
 }
 function sort(choices, value) {
 	const index = choices.findIndex((i) => i.value === value);
-	if (index === -1) return choices;
-	const item = choices.splice(index, 1)[0];
-	return [item, ...choices];
+	return index === -1 ? choices : [choices.splice(index, 1)[0], ...choices];
 }
 function fail() {
 	process.exitCode = 1;
@@ -603,7 +601,7 @@ async function create() {
 	if (frameworkPlugin) dependenciesToInstall.push(frameworkPlugin);
 	const pkgManager = await detectPackageManager();
 	log(), await installPackages(pkgManager, dependenciesToInstall.filter((pkg) => !dependencies[pkg]));
-	const rootConfig = await findUp(configFiles, { cwd: process.cwd() });
+	const rootConfig = any(configFiles, { cwd: process.cwd() });
 	let scriptCommand = "vitest";
 	if (log(), rootConfig) {
 		const configPath = resolve(dirname(rootConfig), `vitest.browser.config.${lang}`);

package/dist/chunks/{global.d.BK3X7FW1.d.ts → global.d.BcFPD2LN.d.ts}

@@ -4,19 +4,6 @@ import { SnapshotState } from '@vitest/snapshot';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
 import { U as UserConsoleLog } from './environment.d.BsToaxti.js';
 
-declare global {
-	namespace Chai {
-		interface ContainSubset {
-			(expected: any): Assertion;
-		}
-		interface Assertion {
-			containSubset: ContainSubset;
-		}
-		interface Assert {
-			containSubset(val: any, exp: any, msg?: string): void;
-		}
-	}
-}
 interface SnapshotMatcher<T> {
 	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;
 	(hint?: string): void;

package/dist/chunks/{globals.BjvYA-AD.js → globals.DC4ntO86.js}

@@ -1,20 +1,20 @@
 import { g as globalApis } from './constants.D_Q9UYh-.js';
-import { i as index } from './index.AZOjjqWP.js';
-import './vi.CiJ0Laa6.js';
+import { i as index } from './index.Dnl38iQ_.js';
+import './vi.B2--mG9U.js';
 import '@vitest/expect';
 import '@vitest/runner';
 import '@vitest/runner/utils';
-import './utils.DGKhod2J.js';
+import './utils.CG9h5ccR.js';
 import '@vitest/utils/timers';
-import './_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/utils/helpers';
 import '@vitest/spy';
 import '@vitest/utils/offset';
 import '@vitest/utils/source-map';
+import './_commonjsHelpers.BFTU3MAI.js';
 import './date.-jtEtIeV.js';
-import './benchmark.LXhJ0F0X.js';
+import './benchmark.DHKMYAts.js';
 import 'expect-type';
 import 'vite/module-runner';
 

package/dist/chunks/{index.DIWhzsUh.js → index.Bt-upxGS.js}

@@ -238,10 +238,10 @@ const skipKeys = [
 	"parent"
 ];
 function getWindowKeys(global, win, additionalKeys = []) {
-	const keysArray = [...additionalKeys, ...KEYS], keys = new Set(keysArray.concat(Object.getOwnPropertyNames(win)).filter((k) => {
+	const keysArray = [...additionalKeys, ...KEYS];
+	return new Set(keysArray.concat(Object.getOwnPropertyNames(win)).filter((k) => {
 		return skipKeys.includes(k) ? false : k in global ? keysArray.includes(k) : true;
 	}));
-	return keys;
 }
 function isClassLikeName(name) {
 	return name[0] === name[0].toUpperCase();
@@ -393,23 +393,18 @@ var jsdom = {
 		});
 		const clearWindowErrors = catchWindowErrors(dom.window);
 		dom.window.Buffer = Buffer, dom.window.jsdom = dom;
-		// inject web globals if they missing in JSDOM but otherwise available in Nodejs
-		// https://nodejs.org/dist/latest/docs/api/globals.html
-		const globalNames = [
+		for (const name of [
 			"structuredClone",
 			"BroadcastChannel",
 			"MessageChannel",
 			"MessagePort",
 			"TextEncoder",
 			"TextDecoder"
-		];
-		for (const name of globalNames) {
+		]) {
 			const value = globalThis[name];
 			if (typeof value !== "undefined" && typeof dom.window[name] === "undefined") dom.window[name] = value;
 		}
-		// since we are providing Node.js's Fetch API,
-		// we also should override other APIs they use
-		const overrideGlobals = [
+		for (const name of [
 			"fetch",
 			"Request",
 			"Response",
@@ -418,8 +413,7 @@ var jsdom = {
 			"AbortSignal",
 			"URL",
 			"URLSearchParams"
-		];
-		for (const name of overrideGlobals) {
+		]) {
 			const value = globalThis[name];
 			if (typeof value !== "undefined") dom.window[name] = value;
 		}

package/dist/chunks/{index.BwBttQPf.js → index.CHrBLuEH.js}

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, promises } from 'node:fs';
 import { mkdir, writeFile, readdir, stat, readFile } from 'node:fs/promises';
 import { resolve, dirname, isAbsolute, relative, basename, normalize } from 'pathe';
-import { g as getOutputFile, h as hasFailedSnapshot, T as TypeCheckError } from './typechecker.gXq-5P3n.js';
+import { g as getOutputFile, h as hasFailedSnapshot, T as TypeCheckError } from './typechecker.BfOQ86_a.js';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { getTestName, hasFailed, getTests, getSuites, getTasks, getFullName } from '@vitest/runner/utils';
 import { slash, toArray, isPrimitive } from '@vitest/utils/helpers';
@@ -171,9 +171,9 @@ async function writeBlob(content, filename) {
 }
 async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
 	// using process.cwd() because --merge-reports can only be used in CLI
-	const resolvedDir = resolve(process.cwd(), blobsDirectory), blobsFiles = await readdir(resolvedDir), promises = blobsFiles.map(async (filename) => {
-		const fullPath = resolve(resolvedDir, filename), stats = await stat(fullPath);
-		if (!stats.isFile()) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
+	const resolvedDir = resolve(process.cwd(), blobsDirectory), promises = (await readdir(resolvedDir)).map(async (filename) => {
+		const fullPath = resolve(resolvedDir, filename);
+		if (!(await stat(fullPath)).isFile()) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
 		const content = await readFile(fullPath, "utf-8"), [version, files, errors, moduleKeys, coverage, executionTime] = parse(content);
 		if (!version) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a valid blob file`);
 		return {
@@ -456,8 +456,7 @@ class BaseReporter {
 		let suffix = c.dim("(") + state + c.dim(")") + this.getDurationPrefix(testModule.task);
 		const diagnostic = testModule.diagnostic();
 		if (diagnostic.heap != null) suffix += c.magenta(` ${Math.floor(diagnostic.heap / 1024 / 1024)} MB heap used`);
-		const title = this.getEntityPrefix(testModule);
-		return ` ${title} ${testModule.task.name} ${suffix}`;
+		return ` ${this.getEntityPrefix(testModule)} ${testModule.task.name} ${suffix}`;
 	}
 	printTestSuite(testSuite) {
 		if (!this.renderSucceed) return;
@@ -479,12 +478,16 @@ class BaseReporter {
 	printAnnotations(test, console, padding = 0) {
 		const annotations = test.annotations();
 		if (!annotations.length) return;
-		const PADDING = " ".repeat(padding);
-		annotations.forEach(({ location, type, message }) => {
+		const PADDING = " ".repeat(padding), groupedAnnotations = {};
+		for (const group in annotations.forEach((annotation) => {
+			const { location, type } = annotation;
+			let group;
 			if (location) {
 				const file = relative(test.project.config.root, location.file);
-				this[console](`${PADDING}${c.blue(F_POINTER)} ${c.gray(`${file}:${location.line}:${location.column}`)} ${c.bold(type)}`);
-			} else this[console](`${PADDING}${c.blue(F_POINTER)} ${c.bold(type)}`);
+				group = `${c.gray(`${file}:${location.line}:${location.column}`)} ${c.bold(type)}`;
+			} else group = c.bold(type);
+			groupedAnnotations[group] ??= [], groupedAnnotations[group].push(annotation);
+		}), groupedAnnotations) this[console](`${PADDING}${c.blue(F_POINTER)} ${group}`), groupedAnnotations[group].forEach(({ message }) => {
 			this[console](`${PADDING}  ${c.blue(F_DOWN_RIGHT)} ${message}`);
 		});
 	}
@@ -508,13 +511,10 @@ class BaseReporter {
 	}
 	getDurationPrefix(task) {
 		const duration = task.result?.duration && Math.round(task.result?.duration);
-		if (duration == null) return "";
-		const color = duration > this.ctx.config.slowTestThreshold ? c.yellow : c.green;
-		return color(` ${duration}${c.dim("ms")}`);
+		return duration == null ? "" : (duration > this.ctx.config.slowTestThreshold ? c.yellow : c.green)(` ${duration}${c.dim("ms")}`);
 	}
 	onWatcherStart(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-		const failed = errors.length > 0 || hasFailed(files);
-		if (failed) this.log(withLabel("red", "FAIL", "Tests failed. Watching for file changes..."));
+		if (errors.length > 0 || hasFailed(files)) this.log(withLabel("red", "FAIL", "Tests failed. Watching for file changes..."));
 		else if (this.ctx.isCancelling) this.log(withLabel("red", "CANCELLED", "Test run cancelled. Watching for file changes..."));
 		else this.log(withLabel("green", "PASS", "Waiting for file changes..."));
 		const hints = [c.dim("press ") + c.bold("h") + c.dim(" to show help")];
@@ -564,8 +564,8 @@ class BaseReporter {
 	shouldLog(log, taskState) {
 		if (this.ctx.config.silent === true || this.ctx.config.silent === "passed-only" && taskState !== "failed") return false;
 		if (this.ctx.config.onConsoleLog) {
-			const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0, entity = task && this.ctx.state.getReportedEntity(task), shouldLog = this.ctx.config.onConsoleLog(log.content, log.type, entity);
-			if (shouldLog === false) return false;
+			const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0, entity = task && this.ctx.state.getReportedEntity(task);
+			if (this.ctx.config.onConsoleLog(log.content, log.type, entity) === false) return false;
 		}
 		return true;
 	}
@@ -615,7 +615,7 @@ class BaseReporter {
 		if (errors.length) this.ctx.logger.printUnhandledErrors(errors), this.error();
 	}
 	reportBenchmarkSummary(files) {
-		const benches = getTests(files), topBenches = benches.filter((i) => i.result?.benchmark?.rank === 1);
+		const topBenches = getTests(files).filter((i) => i.result?.benchmark?.rank === 1);
 		this.log(`\n${withLabel("cyan", "BENCH", "Summary\n")}`);
 		for (const bench of topBenches) {
 			const group = bench.suite || bench.file;
@@ -893,11 +893,10 @@ class SummaryReporter {
 		else if (state === "failed") this.modules.failed++;
 		else if (module.task.mode === "todo" && state === "skipped") this.modules.todo++;
 		else if (state === "skipped") this.modules.skipped++;
-		const left = this.modules.total - this.modules.completed;
 		// Keep finished tests visible in summary for a while if there are more tests left.
 		// When a new test starts in onTestModuleQueued it will take this ones place.
 		// This reduces flickering by making summary more stable.
-		if (left > this.maxParallelTests) this.finishedModules.set(module.id, setTimeout(() => {
+		if (this.modules.total - this.modules.completed > this.maxParallelTests) this.finishedModules.set(module.id, setTimeout(() => {
 			this.removeTestModule(module.id);
 		}, FINISHED_TEST_CLEANUP_TIME_MS).unref());
 		else
@@ -1122,12 +1121,12 @@ function capturePrintError(error, ctx, options) {
 	} }), console = new Console(writable), logger = {
 		error: console.error.bind(console),
 		highlight: ctx.logger.highlight.bind(ctx.logger)
-	}, result = printError(error, ctx, logger, {
-		showCodeFrame: false,
-		...options
-	});
+	};
 	return {
-		nearest: result?.nearest,
+		nearest: printError(error, ctx, logger, {
+			showCodeFrame: false,
+			...options
+		})?.nearest,
 		output
 	};
 }
@@ -1175,19 +1174,17 @@ function printErrorInner(error, project, options) {
 	const stacks = options.parseErrorStacktrace(e), nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find((stack) => {
 		// we are checking that this module was processed by us at one point
 		try {
-			const environments = [...Object.values(project._vite?.environments || {}), ...Object.values(project.browser?.vite.environments || {})], hasResult = environments.some((environment) => {
-				const modules = environment.moduleGraph.getModulesByFile(stack.file);
-				return [...modules?.values() || []].some((module) => !!module.transformResult);
-			});
-			return hasResult && existsSync(stack.file);
+			return [...Object.values(project._vite?.environments || {}), ...Object.values(project.browser?.vite.environments || {})].some((environment) => {
+				return [...environment.moduleGraph.getModulesByFile(stack.file)?.values() || []].some((module) => !!module.transformResult);
+			}) && existsSync(stack.file);
 		} catch {
 			return false;
 		}
 	});
 	if (type) printErrorType(type, project.vitest);
 	if (printErrorMessage(e, logger), options.screenshotPaths?.length) {
-		const length = options.screenshotPaths.length;
-		if (logger.error(`\nFailure screenshot${length > 1 ? "s" : ""}:`), logger.error(options.screenshotPaths.map((p) => `  - ${c.dim(relative(process.cwd(), p))}`).join("\n")), !e.diff) logger.error();
+		const uniqueScreenshots = Array.from(new Set(options.screenshotPaths)), length = uniqueScreenshots.length;
+		if (logger.error(`\nFailure screenshot${length > 1 ? "s" : ""}:`), logger.error(uniqueScreenshots.map((p) => `  - ${c.dim(relative(process.cwd(), p))}`).join("\n")), !e.diff) logger.error();
 	}
 	if (e.codeFrame) logger.error(`${e.codeFrame}\n`);
 	if ("__vitest_rollup_error__" in e) {
@@ -1426,7 +1423,7 @@ const BUILT_IN_TYPES = [
 	"warning"
 ];
 function getTitle(type) {
-	return BUILT_IN_TYPES.includes(type) ? void 0 : type;
+	if (!BUILT_IN_TYPES.includes(type)) return type;
 }
 function getType(type) {
 	return BUILT_IN_TYPES.includes(type) ? type : "notice";
@@ -1453,8 +1450,7 @@ function escapeProperty(s) {
 class HangingProcessReporter {
 	whyRunning;
 	onInit() {
-		const _require = createRequire(import.meta.url);
-		this.whyRunning = _require("why-is-node-running");
+		this.whyRunning = createRequire(import.meta.url)("why-is-node-running");
 	}
 	onProcessTimeout() {
 		this.whyRunning?.();
@@ -1614,8 +1610,7 @@ class JUnitReporter {
 			this.reportFile = resolve(this.ctx.config.root, outputFile);
 			const outputDirectory = dirname(this.reportFile);
 			if (!existsSync(outputDirectory)) await promises.mkdir(outputDirectory, { recursive: true });
-			const fileFd = await promises.open(this.reportFile, "w+");
-			this.fileFd = fileFd, this.baseLog = async (text) => {
+			this.fileFd = await promises.open(this.reportFile, "w+"), this.baseLog = async (text) => {
 				if (!this.fileFd) this.fileFd = await promises.open(this.reportFile, "w+");
 				await promises.writeFile(this.fileFd, `${text}\n`);
 			};
@@ -1778,7 +1773,7 @@ class TapReporter {
 					this.logger.log(`# ${type}: ${message}`);
 				}), this.logger.unindent();
 				if (task.result?.state === "fail" && task.result.errors) this.logger.indent(), task.result.errors.forEach((error) => {
-					const stacks = task.file.pool === "browser" ? project.browser?.parseErrorStacktrace(error) || [] : parseErrorStacktrace(error, { frameFilter: this.ctx.config.onStackTrace }), stack = stacks[0];
+					const stack = (task.file.pool === "browser" ? project.browser?.parseErrorStacktrace(error) || [] : parseErrorStacktrace(error, { frameFilter: this.ctx.config.onStackTrace }))[0];
 					if (this.logger.log("---"), this.logger.log("error:"), this.logger.indent(), this.logErrorDetails(error), this.logger.unindent(), stack) this.logger.log(`at: ${yamlString(`${stack.file}:${stack.line}:${stack.column}`)}`);
 					if (error.showDiff) this.logger.log(`actual: ${yamlString(error.actual)}`), this.logger.log(`expected: ${yamlString(error.expected)}`);
 				}), this.logger.log("..."), this.logger.unindent();