vitest 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/chunks/{cli-api.B0RFke2g.js → cli-api.DJMXq34b.js}

@@ -1,6 +1,5 @@
 import * as fs from 'node:fs';
 import fs__default, { promises, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, statSync } from 'node:fs';
-import * as pathe from 'pathe';
 import { join, dirname, basename, isAbsolute, resolve as resolve$1, relative, normalize, extname } from 'pathe';
 import { r as resolveCoverageProviderModule, C as CoverageProviderMap } from './coverage.CTzCuANN.js';
 import path, { resolve as resolve$2 } from 'node:path';
@@ -8,13 +7,13 @@ import { unique, createDefer, slash, shuffle, toArray, cleanUrl, withTrailingSla
 import { a as any, p as prompt } from './index.og1WyBLx.js';
 import { r as resolveModule, i as isPackageExists, N as NativeModuleRunner } from './nativeModuleRunner.BOeMnHl4.js';
 import * as vite from 'vite';
-import { parseAst, searchForWorkspaceRoot, mergeConfig, fetchModule, parseAstAsync, version, createServer, isFileLoadingAllowed, normalizePath as normalizePath$1, isRunnableDevEnvironment } from 'vite';
+import { parseAst, searchForWorkspaceRoot, mergeConfig, fetchModule, version, createServer, isFileLoadingAllowed, normalizePath as normalizePath$1, isRunnableDevEnvironment } from 'vite';
 import { c as configFiles, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort, A as API_PATH } from './constants.-juJ8b_4.js';
 import * as nodeos from 'node:os';
 import nodeos__default, { tmpdir, hostname } from 'node:os';
-import { getTests, createFileTask as createFileTask$1, createTaskName, validateTags, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, hasFailed, generateFileHash, limitConcurrency, getTestName, getSuites, getTasks, getFullName, createTagsFilter, isTestCase } from '@vitest/runner/utils';
+import { getTests, createFileTask as createFileTask$1, createTaskName, validateTags, calculateSuiteHash, hasFailed, generateFileHash, limitConcurrency, getTestName, getSuites, getTasks, getFullName, createTagsFilter, someTasksAreOnly, interpretTaskModes, isTestCase } from '@vitest/runner/utils';
 import { serializeValue } from '@vitest/utils/serialize';
-import { v as version$1 } from './cac.8N4bOkkB.js';
+import { v as version$1 } from './cac.CyXAEMkE.js';
 import { distDir, rootDir } from '../path.js';
 import { Traces } from '../traces.js';
 import { createDebug } from 'obug';
@@ -23,8 +22,8 @@ import { rm, readFile, writeFile, rename, stat, unlink, mkdir, readdir, copyFile
 import c from 'tinyrainbow';
 import url, { pathToFileURL, fileURLToPath } from 'node:url';
 import { isDynamicPattern, glob } from 'tinyglobby';
-import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.szbHWQun.js';
-import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
+import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.CUUnbOrq.js';
+import { a as isTTY, b as isWindows, i as isForceColor } from './env.BKKtU2WC.js';
 import { w as withLabel, t as truncateString, e as errorBanner, F as F_POINTER, d as divider, f as formatProjectName, a as formatTimeString, b as taskFail, s as separator, c as F_CHECK, g as F_DOWN_RIGHT, h as getStateSymbol, r as renderSnapshotSummary, p as padSummaryTitle, i as getStateString$1, j as formatTime, k as countTestErrors, l as F_TREE_NODE_END, m as F_TREE_NODE_MIDDLE, n as noun, o as F_RIGHT } from './utils.DKODp04v.js';
 import { isAgent, isCI, provider } from 'std-env';
 import module$1, { createRequire, builtinModules, isBuiltin as isBuiltin$1 } from 'node:module';
@@ -1222,6 +1221,15 @@ function detectCodeBlock(content) {
 
 const debug$1 = createDebugger("vitest:ast-collect-info");
 const verbose = createDebugger("vitest:ast-collect-verbose");
+const INTERMEDIATE_CALL_PROPERTIES = new Set([
+	"each",
+	"for",
+	"skipIf",
+	"runIf",
+	"extend",
+	"scoped",
+	"override"
+]);
 function isTestFunctionName(name) {
 	return name === "it" || name === "test" || name.startsWith("test") || name.endsWith("Test");
 }
@@ -1274,15 +1282,7 @@ function astParseFile(filepath, code) {
 		const properties = getProperties(callee);
 		const property = callee?.property?.name;
 		// intermediate calls like .each(), .for() will be picked up in the next iteration
-		if (property && [
-			"each",
-			"for",
-			"skipIf",
-			"runIf",
-			"extend",
-			"scoped",
-			"override"
-		].includes(property)) return;
+		if (property && INTERMEDIATE_CALL_PROPERTIES.has(property)) return;
 		// skip properties on return values of calls - e.g., test('name', fn).skip()
 		if (callee.type === "MemberExpression" && callee.object?.type === "CallExpression") return;
 		// derive mode from the full chain (handles any order like .skip.concurrent or .concurrent.skip)
@@ -1349,11 +1349,12 @@ function astParseFile(filepath, code) {
 		definitions
 	};
 }
-function createFailedFileTask(project, filepath, error) {
+function createFailedFileTask(project, filepath, error, options) {
 	const config = project.serializedConfig;
+	const pool = options?.pool ?? config.pool;
 	const file = {
-		...createFileTask$1(filepath, config.root, config.name, config.pool, void 0, {
-			typecheck: config.pool === "typescript",
+		...createFileTask$1(filepath, config.root, config.name, pool, void 0, {
+			typecheck: pool === "typescript",
 			__vitest_label__: config.mergeReportsLabel
 		}),
 		mode: "run",
@@ -1381,12 +1382,13 @@ function serializeError(ctx, error) {
 		message: error.message
 	}];
 }
-function createFileTask(project, testFilepath, code, requestMap, filepath, fileTags) {
+function createFileTask(project, testFilepath, code, requestMap, filepath, fileTags, options) {
 	const { definitions, ast } = astParseFile(testFilepath, code);
 	const config = project.serializedConfig;
+	const pool = options?.pool ?? config.pool;
 	const file = {
-		...createFileTask$1(filepath, config.root, config.name, config.pool, void 0, {
-			typecheck: config.pool === "typescript",
+		...createFileTask$1(filepath, config.root, config.name, pool, void 0, {
+			typecheck: pool === "typescript",
 			__vitest_label__: config.mergeReportsLabel
 		}),
 		mode: "run",
@@ -1416,10 +1418,10 @@ function createFileTask(project, testFilepath, code, requestMap, filepath, fileT
 				column: processedLocation.column
 			});
 			if (originalLocation.column != null) {
-				verbose?.(`Found location for`, definition.type, definition.name, `${processedLocation.line}:${processedLocation.column}`, "->", `${originalLocation.line}:${originalLocation.column}`);
+				verbose?.(`Found location for`, definition.type, definition.name, `${processedLocation.line}:${processedLocation.column + 1}`, "->", `${originalLocation.line}:${originalLocation.column + 1}`);
 				location = {
 					line: originalLocation.line,
-					column: originalLocation.column
+					column: originalLocation.column + 1
 				};
 			} else debug$1?.("Cannot find original location for", definition.type, definition.name, `${processedLocation.column}:${processedLocation.line}`);
 		} else debug$1?.("Cannot find original location for", definition.type, definition.name, `${definition.start}`);
@@ -1471,6 +1473,7 @@ function createFileTask(project, testFilepath, code, requestMap, filepath, fileT
 			timeout: 0,
 			annotations: [],
 			artifacts: [],
+			benchmarks: [],
 			tags: taskTags
 		};
 		definition.task = task;
@@ -1485,16 +1488,35 @@ function createFileTask(project, testFilepath, code, requestMap, filepath, fileT
 			message: `No test suite found in file ${filepath}`
 		}]
 	};
-	return file;
+	return {
+		file,
+		definitions
+	};
 }
 async function astCollectTests(project, filepath) {
+	return (await astCollectFileInformation(project, filepath)).file;
+}
+async function astCollectFileInformation(project, filepath, options) {
 	const request = await transformSSR(project, filepath);
 	const testFilepath = relative(project.config.root, filepath);
 	if (!request) {
 		debug$1?.("Cannot parse", testFilepath, "(vite didn't return anything)");
-		return createFailedFileTask(project, filepath, /* @__PURE__ */ new Error(`Failed to parse ${testFilepath}. Vite didn't return anything.`));
+		return {
+			file: createFailedFileTask(project, filepath, /* @__PURE__ */ new Error(`Failed to parse ${testFilepath}. Vite didn't return anything.`), options),
+			filepath,
+			parsed: "",
+			map: null,
+			definitions: []
+		};
 	}
-	return createFileTask(project, testFilepath, request.code, request.map, filepath, request.fileTags);
+	const { file, definitions } = createFileTask(project, testFilepath, request.code, request.map, filepath, request.fileTags, options);
+	return {
+		file,
+		filepath,
+		parsed: request.code,
+		map: request.map,
+		definitions
+	};
 }
 async function transformSSR(project, filepath) {
 	const { env: pragmaEnv, tags: fileTags } = detectCodeBlock(await promises.readFile(filepath, "utf-8").catch(() => ""));
@@ -1544,7 +1566,7 @@ class BrowserSessions {
 	destroySession(sessionId) {
 		this.sessions.delete(sessionId);
 	}
-	createSession(sessionId, project, pool) {
+	createSession(sessionId, project, pool, options) {
 		// this promise only waits for the WS connection with the orchestrator to be established
 		const defer = createDefer();
 		const timeout = setTimeout(() => {
@@ -1552,6 +1574,7 @@ class BrowserSessions {
 		}, project.vitest.config.browser.connectTimeout ?? 6e4).unref();
 		this.sessions.set(sessionId, {
 			project,
+			otelCarrier: options?.otelCarrier,
 			connected: () => {
 				defer.resolve();
 				clearTimeout(timeout);
@@ -2260,8 +2283,10 @@ function resolveInlineWorkerOption(value) {
 	if (typeof value === "string" && value.trim().endsWith("%")) return getWorkersCountByPercentage(value);
 	else return Number(value);
 }
+// warn only once, check one PER PROCESS, not per instance,
+// that's why it's on a module-level
+let warnedTypeCheck = false;
 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(withLabel("yellow", "Vitest", `Your config.test.environment ("${viteConfig.test.environment}") conflicts with --dom flag ("happy-dom"), ignoring "${viteConfig.test.environment}"`));
@@ -2270,9 +2295,9 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	const resolved = {
 		...configDefaults,
 		...options,
-		root: viteConfig.root,
-		mode
+		root: viteConfig.root
 	};
+	resolved.mode ??= viteConfig.mode ?? "test";
 	if (resolved.retry && typeof resolved.retry === "object" && typeof resolved.retry.condition === "function") {
 		logger.console.warn(c.yellow("Warning: retry.condition function cannot be used inside a config file. Use a RegExp pattern instead, or define the function in your test file."));
 		resolved.retry = {
@@ -2304,6 +2329,10 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.name = typeof options.name === "string" ? options.name : options.name?.label || "";
 	resolved.color = typeof options.name !== "string" ? options.name?.color : void 0;
 	if (resolved.environment === "browser") throw new Error(`Looks like you set "test.environment" to "browser". To enable Browser Mode, use "test.browser.enabled" instead.`);
+	resolved.benchmark = {
+		...benchmarkConfigDefaults,
+		...resolved.benchmark
+	};
 	const inspector = resolved.inspect || resolved.inspectBrk;
 	resolved.inspector = {
 		...resolved.inspector,
@@ -2328,7 +2357,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	if (resolved.standalone && !resolved.watch) throw new Error(`Vitest standalone mode requires --watch`);
 	if (resolved.mergeReports && resolved.watch) throw new Error(`Cannot merge reports with --watch enabled`);
 	if (resolved.maxWorkers) resolved.maxWorkers = resolveInlineWorkerOption(resolved.maxWorkers);
-	if (!(options.fileParallelism ?? mode !== "benchmark"))
+	if (!(options.fileParallelism ?? true))
  // ignore user config, parallelism cannot be implemented without limiting workers
 	resolved.maxWorkers = 1;
 	if (resolved.maxConcurrency === 0) {
@@ -2457,7 +2486,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.coverage.exclude = [
 		...resolved.coverage.exclude,
 		...resolved.setupFiles.map((file) => `${resolved.coverage.allowExternal ? "**/" : ""}${relative(resolved.root, file)}`),
-		...resolved.include,
+		...resolved.include.filter((pattern) => !pattern.startsWith("!")),
 		resolved.config && slash(resolved.config),
 		...configFiles,
 		"**/virtual:*",
@@ -2491,25 +2520,6 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.pool ??= "threads";
 	if (resolved.pool === "vmForks" || resolved.pool === "vmThreads" || resolved.pool === "typescript") resolved.isolate = false;
 	if (process.env.VITEST_MAX_WORKERS) resolved.maxWorkers = Number.parseInt(process.env.VITEST_MAX_WORKERS);
-	if (mode === "benchmark") {
-		resolved.benchmark = {
-			...benchmarkConfigDefaults,
-			...resolved.benchmark
-		};
-		// override test config
-		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;
-		// --compare from cli
-		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);
@@ -2545,25 +2555,23 @@ function resolveConfig$1(vitest, options, viteConfig) {
  // Inline reporter, e.g. { reporter: [{ onFinish() { method() } }] }
 		resolved.reporters.push(reporter);
 	}
-	if (mode !== "benchmark") {
-		// @ts-expect-error "reporter" is from CLI, should be absolute to the running directory
-		// it is passed down as "vitest --reporter ../reporter.js"
-		const reportersFromCLI = resolved.reporter;
-		const cliReporters = toArray(reportersFromCLI || []).map((reporter) => {
-			// ./reporter.js || ../reporter.js, but not .reporters/reporter.js
-			if (/^\.\.?\//.test(reporter)) return resolve$1(process.cwd(), reporter);
-			return reporter;
-		});
-		if (cliReporters.length) {
-			// When CLI reporters are specified, preserve options from config file
-			const configReportersMap = /* @__PURE__ */ new Map();
-			// Build a map of reporter names to their options from the config
-			for (const reporter of resolved.reporters) if (Array.isArray(reporter)) {
-				const [reporterName, reporterOptions] = reporter;
-				if (typeof reporterName === "string") configReportersMap.set(reporterName, reporterOptions);
-			}
-			resolved.reporters = Array.from(new Set(toArray(cliReporters))).filter(Boolean).map((reporter) => [reporter, configReportersMap.get(reporter) || {}]);
+	// @ts-expect-error "reporter" is from CLI, should be absolute to the running directory
+	// it is passed down as "vitest --reporter ../reporter.js"
+	const reportersFromCLI = resolved.reporter;
+	const cliReporters = toArray(reportersFromCLI || []).map((reporter) => {
+		// ./reporter.js || ../reporter.js, but not .reporters/reporter.js
+		if (/^\.\.?\//.test(reporter)) return resolve$1(process.cwd(), reporter);
+		return reporter;
+	});
+	if (cliReporters.length) {
+		// When CLI reporters are specified, preserve options from config file
+		const configReportersMap = /* @__PURE__ */ new Map();
+		// Build a map of reporter names to their options from the config
+		for (const reporter of resolved.reporters) if (Array.isArray(reporter)) {
+			const [reporterName, reporterOptions] = reporter;
+			if (typeof reporterName === "string") configReportersMap.set(reporterName, reporterOptions);
 		}
+		resolved.reporters = Array.from(new Set(toArray(cliReporters))).filter(Boolean).map((reporter) => [reporter, configReportersMap.get(reporter) || {}]);
 	}
 	resolved.mergeReportsLabel = process.env.VITEST_BLOB_LABEL;
 	for (const reporter of resolved.reporters) if (Array.isArray(reporter) && reporter[0] === "blob") {
@@ -2599,12 +2607,15 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	};
 	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."));
+	if (resolved.typecheck.enabled && !warnedTypeCheck) {
+		warnedTypeCheck = true;
+		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.enabled ??= false;
 	resolved.browser.headless ??= isCI;
 	if (resolved.browser.isolate) logger.console.warn(c.yellow("`browser.isolate` is deprecated. Use top-level `isolate` instead."));
 	resolved.browser.isolate ??= resolved.isolate ?? true;
-	resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark";
+	resolved.browser.fileParallelism ??= options.fileParallelism ?? true;
 	// disable in headless mode by default, and if CI is detected
 	resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI;
 	resolved.browser.commands ??= {};
@@ -2616,7 +2627,8 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	resolved.browser.viewport.height ??= 896;
 	resolved.browser.locators ??= {};
 	resolved.browser.locators.testIdAttribute ??= "data-testid";
-	resolved.browser.locators.exact ??= false;
+	resolved.browser.locators.exact ??= true;
+	resolved.browser.locators.errorFormat ??= "all";
 	if (typeof resolved.browser.provider === "string") {
 		const source = `@vitest/browser-${resolved.browser.provider}`;
 		throw new TypeError(`The \`browser.provider\` configuration was changed to accept a factory instead of a string. Add an import of "${resolved.browser.provider}" from "${source}" instead. See: https://vitest.dev/config/browser/provider`);
@@ -3567,8 +3579,8 @@ class ServerModuleRunner extends ModuleRunner {
 
 class FilesNotFoundError extends Error {
 	code = "VITEST_FILES_NOT_FOUND";
-	constructor(mode) {
-		super(`No ${mode} files found`);
+	constructor() {
+		super(`No test files found`);
 	}
 }
 class GitNotFoundError extends Error {
@@ -4146,144 +4158,6 @@ function getDefs(c) {
 	};
 }
 
-async function collectTests(ctx, filepath) {
-	const request = await ctx.vite.environments.ssr.transformRequest(filepath);
-	if (!request) return null;
-	const ast = await parseAstAsync(request.code);
-	const projectName = ctx.name;
-	const file = {
-		...createFileTask$1(filepath, ctx.config.root, projectName, void 0, void 0, { typecheck: true }),
-		start: ast.start,
-		end: ast.end,
-		mode: "run"
-	};
-	file.file = file;
-	const definitions = [];
-	const getName = (callee) => {
-		if (!callee) return null;
-		if (callee.type === "Identifier") return callee.name;
-		if (callee.type === "CallExpression") return getName(callee.callee);
-		if (callee.type === "TaggedTemplateExpression") return getName(callee.tag);
-		if (callee.type === "MemberExpression") {
-			if (callee.object?.type === "Identifier" && [
-				"it",
-				"test",
-				"describe",
-				"suite"
-			].includes(callee.object.name)) return callee.object?.name;
-			// direct call as `__vite_ssr_exports_0__.test()`
-			if (callee.object?.name?.startsWith("__vite_ssr_")) return getName(callee.property);
-			// call as `__vite_ssr__.test.skip()`
-			return getName(callee.object?.property);
-		}
-		// unwrap (0, ...)
-		if (callee.type === "SequenceExpression" && callee.expressions.length === 2) {
-			const [e0, e1] = callee.expressions;
-			if (e0.type === "Literal" && e0.value === 0) return getName(e1);
-		}
-		return null;
-	};
-	ancestor(ast, { CallExpression(node) {
-		const { callee } = node;
-		const name = getName(callee);
-		if (!name) return;
-		if (![
-			"it",
-			"test",
-			"describe",
-			"suite"
-		].includes(name)) return;
-		const property = callee?.property?.name;
-		let mode = !property || property === name ? "run" : property;
-		// they will be picked up in the next iteration
-		if ([
-			"each",
-			"for",
-			"skipIf",
-			"runIf"
-		].includes(mode)) return;
-		let start;
-		const end = node.end;
-		// .each
-		if (callee.type === "CallExpression") start = callee.end;
-		else if (callee.type === "TaggedTemplateExpression") start = callee.end + 1;
-		else start = node.start;
-		const { arguments: [messageNode] } = node;
-		const message = messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral" ? request.code.slice(messageNode.start + 1, messageNode.end - 1) : request.code.slice(messageNode.start, messageNode.end);
-		// cannot statically analyze, so we always skip it
-		if (mode === "skipIf" || mode === "runIf") mode = "skip";
-		definitions.push({
-			start,
-			end,
-			name: message,
-			type: name === "it" || name === "test" ? "test" : "suite",
-			mode,
-			task: null
-		});
-	} });
-	let lastSuite = file;
-	const updateLatestSuite = (index) => {
-		while (lastSuite.suite && lastSuite.end < index) lastSuite = lastSuite.suite;
-		return lastSuite;
-	};
-	definitions.sort((a, b) => a.start - b.start).forEach((definition) => {
-		const latestSuite = updateLatestSuite(definition.start);
-		let mode = definition.mode;
-		if (latestSuite.mode !== "run")
- // inherit suite mode, if it's set
-		mode = latestSuite.mode;
-		if (definition.type === "suite") {
-			const task = {
-				type: definition.type,
-				id: "",
-				suite: latestSuite,
-				file,
-				tasks: [],
-				mode,
-				name: definition.name,
-				fullName: createTaskName([lastSuite.fullName, definition.name]),
-				fullTestName: createTaskName([lastSuite.fullTestName, definition.name]),
-				end: definition.end,
-				start: definition.start,
-				meta: { typecheck: true }
-			};
-			definition.task = task;
-			latestSuite.tasks.push(task);
-			lastSuite = task;
-			return;
-		}
-		const task = {
-			type: definition.type,
-			id: "",
-			suite: latestSuite,
-			file,
-			mode,
-			timeout: 0,
-			context: {},
-			name: definition.name,
-			fullName: createTaskName([lastSuite.fullName, definition.name]),
-			fullTestName: createTaskName([lastSuite.fullTestName, definition.name]),
-			end: definition.end,
-			start: definition.start,
-			annotations: [],
-			artifacts: [],
-			meta: { typecheck: true }
-		};
-		definition.task = task;
-		latestSuite.tasks.push(task);
-	});
-	calculateSuiteHash(file);
-	const hasOnly = someTasksAreOnly(file);
-	interpretTaskModes(file, ctx.config.testNamePattern, void 0, void 0, void 0, hasOnly, false, ctx.config.allowOnly);
-	return {
-		file,
-		parsed: request.code,
-		filepath,
-		map: request.map,
-		definitions
-	};
-}
-
 const newLineRegExp = /\r?\n/;
 const errCodeRegExp = /error TS(?<errCode>\d+)/;
 async function makeTscErrorInfo(errInfo) {
@@ -4364,7 +4238,7 @@ class Typechecker {
 		this._onWatcherRerun = fn;
 	}
 	async collectFileTests(filepath) {
-		return collectTests(this.project, filepath);
+		return astCollectFileInformation(this.project, filepath, { pool: "typescript" });
 	}
 	getFiles() {
 		return this.files;
@@ -4504,18 +4378,16 @@ Possible solutions:
 	}
 	async spawn() {
 		const { root, watch, typecheck } = this.project.config;
-		const args = [
-			"--noEmit",
-			"--pretty",
-			"false",
-			"--incremental",
-			"--tsBuildInfoFile",
-			join(process.versions.pnp ? join(nodeos__default.tmpdir(), this.project.hash) : distDir, "tsconfig.tmp.tsbuildinfo")
-		];
+		const args = ["--pretty", "false"];
+		if (typecheck.build) args.unshift("--build");
+		else args.push("--noEmit", "--incremental", "--tsBuildInfoFile", join(process.versions.pnp ? join(nodeos__default.tmpdir(), this.project.hash) : distDir, "tsconfig.tmp.tsbuildinfo"));
 		// use builtin watcher because it's faster
 		if (watch) args.push("--watch");
 		if (typecheck.allowJs) args.push("--allowJs", "--checkJs");
-		if (typecheck.tsconfig) args.push("-p", resolve$1(root, typecheck.tsconfig));
+		if (typecheck.tsconfig) {
+			if (!typecheck.build) args.push("-p");
+			args.push(resolve$1(root, typecheck.tsconfig));
+		}
 		this._output = "";
 		this._startTime = performance$1.now();
 		const child = x(typecheck.checker, args, {
@@ -4755,9 +4627,9 @@ function printErrorInner(error, project, options) {
 	const testName = e.VITEST_TEST_NAME;
 	// testName has testPath inside
 	if (testPath) logger.error(c.red(`This error originated in "${c.bold(relative(project.config.root, testPath))}" test file. It doesn't mean the error was thrown inside the file itself, but while it was running.`));
-	if (testName) logger.error(c.red(`The latest test that might've caused the error is "${c.bold(testName)}". It might mean one of the following:
-- The error was thrown, while Vitest was running this test.
-- If the error occurred after the test had been completed, this was the last documented test before it was thrown.`));
+	if (testName) logger.error(c.red(`The last test to run before this error was "${c.bold(testName)}". This means either:
+- the error was thrown while Vitest was running this test, or
+- the error was thrown after the test completed, and this was the most recent test at that point.`));
 	if (typeof e.cause === "object" && e.cause && "name" in e.cause) {
 		e.cause.name = `Caused by: ${e.cause.name}`;
 		printErrorInner(e.cause, project, {
@@ -5011,10 +4883,10 @@ class Logger {
 	}
 	printNoTestFound(filters) {
 		const config = this.ctx.config;
-		if (config.watch && (config.changed || config.related?.length)) this.log(`No affected ${config.mode} files found\n`);
-		else if (config.watch) this.log(c.red(`No ${config.mode} files found. You can change the file name pattern by pressing "p"\n`));
-		else if (config.passWithNoTests) this.log(`No ${config.mode} files found, exiting with code 0\n`);
-		else this.error(c.red(`No ${config.mode} files found, exiting with code 1\n`));
+		if (config.watch && (config.changed || config.related?.length)) this.log(`No affected test files found\n`);
+		else if (config.watch) this.log(c.red(`No test files found. You can change the file name pattern by pressing "p"\n`));
+		else if (config.passWithNoTests) this.log(`No test files found, exiting with code 0\n`);
+		else this.error(c.red(`No test files found, exiting with code 1\n`));
 		const comma = c.dim(", ");
 		if (filters?.length) this.console.error(c.dim("filter: ") + c.yellow(filters.join(comma)));
 		const projectsFilter = toArray(config.project);
@@ -5775,6 +5647,15 @@ function createMethodsRPC(project, methodsOptions = {}) {
 		onAfterSuiteRun(meta) {
 			vitest.coverageProvider?.onAfterSuiteRun(meta);
 		},
+		async onTestBenchmark(testId, benchmark) {
+			return vitest._testRun.recordBenchmark(testId, benchmark);
+		},
+		async readBenchmarkResult(relativePath) {
+			return project.benchmark.readResult(relativePath);
+		},
+		async writeBenchmarkResult(relativePath, data) {
+			return project.benchmark.writeResult(relativePath, data);
+		},
 		async onTaskArtifactRecord(testId, artifact) {
 			return vitest._testRun.recordArtifact(testId, artifact);
 		},
@@ -6067,7 +5948,7 @@ class PoolRunner {
 		}
 	};
 	emitUnexpectedExit = () => {
-		const error = /* @__PURE__ */ new Error("Worker exited unexpectedly");
+		const error = /* @__PURE__ */ new Error(`Worker exited unexpectedly during ${this._state} state`);
 		this._eventEmitter.emit("error", error);
 	};
 	waitForStart() {
@@ -6638,7 +6519,7 @@ function deepEqual$1(obj1, obj2) {
 	const keys1 = Object.keys(obj1);
 	const keys2 = Object.keys(obj2);
 	if (keys1.length !== keys2.length) return false;
-	for (const key of keys1) if (!keys2.includes(key) || !deepEqual$1(obj1[key], obj2[key])) return false;
+	for (const key of keys1) if (!Object.prototype.hasOwnProperty.call(obj2, key) || !deepEqual$1(obj1[key], obj2[key])) return false;
 	return true;
 }
 
@@ -11902,11 +11783,12 @@ function getTestFileEnvironment(project, testFile, browser = false) {
 	}
 }
 
-async function getModuleGraph(ctx, projectName, testFilePath, browser = false) {
+async function getModuleGraph(ctx, projectName, testFilePath) {
 	const graph = {};
 	const externalized = /* @__PURE__ */ new Set();
 	const inlined = /* @__PURE__ */ new Set();
 	const project = ctx.getProjectByName(projectName);
+	const browser = project.config.browser.enabled;
 	const environment = project.config.experimental.viteModuleRunner === false ? project.vite.environments.__vitest__ : getTestFileEnvironment(project, testFilePath, browser);
 	if (!environment) throw new Error(`Cannot find environment for ${testFilePath}`);
 	const seen = /* @__PURE__ */ new Map();
@@ -12048,10 +11930,11 @@ function setup(ctx, _server) {
 				} catch {}
 				return result;
 			},
-			async getTransformResult(projectName, moduleId, testFileTaskId, browser = false) {
+			async getTransformResult(projectName, moduleId, testFileTaskId) {
 				const project = ctx.getProjectByName(projectName);
 				const testModule = ctx.state.getReportedEntityById(testFileTaskId);
 				if (!testModule || !isFileServingAllowed(project.vite.config, moduleId)) return;
+				const browser = !!project.config.browser.enabled;
 				const environment = getTestFileEnvironment(project, testModule.moduleId, browser);
 				const moduleNode = environment?.moduleGraph.getModuleById(moduleId);
 				if (!environment || !moduleNode?.transformResult) return;
@@ -12069,8 +11952,8 @@ function setup(ctx, _server) {
 				} catch {}
 				return result;
 			},
-			async getModuleGraph(project, id, browser) {
-				return getModuleGraph(ctx, project, id, browser);
+			async getModuleGraph(project, id) {
+				return getModuleGraph(ctx, project, id);
 			},
 			async updateSnapshot(file) {
 				// silently ignore exec/write attempts if not allowed
@@ -12242,13 +12125,39 @@ function handleDefineValue(value) {
 	return JSON.stringify(value);
 }
 
+class BenchmarkManager {
+	constructor(project) {
+		this.project = project;
+	}
+	// Resolve a user-supplied path against the project root. Reject paths that
+	// escape the project root: `bench.from()` accepts arbitrary input, and we
+	// never want a benchmark file to be able to read or clobber files outside
+	// the workspace.
+	resolve(relativePath) {
+		const root = this.project.config.root;
+		const absolute = isAbsolute(relativePath) ? resolve$1(relativePath) : resolve$1(root, relativePath);
+		const rootWithSep = root.endsWith("/") ? root : `${root}/`;
+		if (absolute !== root && !absolute.startsWith(rootWithSep)) throw new Error(`Benchmark artifact path "${relativePath}" resolves outside the project root (${root}). Paths passed to \`writeResult\` and \`bench.from()\` must point inside the project.`);
+		return absolute;
+	}
+	async readResult(relativePath) {
+		const path = this.resolve(relativePath);
+		if (!existsSync(path)) return null;
+		return JSON.parse(await readFile(path, "utf-8"));
+	}
+	async writeResult(relativePath, data) {
+		const absolute = this.resolve(relativePath);
+		await mkdir(dirname(absolute), { recursive: true });
+		await writeFile(absolute, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+	}
+}
+
 function serializeConfig(project) {
 	const { config, globalConfig } = project;
 	const viteConfig = project._vite?.config;
 	const optimizer = config.deps?.optimizer || {};
 	return {
 		environmentOptions: config.environmentOptions,
-		mode: config.mode,
 		isolate: config.isolate,
 		maxWorkers: config.maxWorkers,
 		base: config.base,
@@ -12343,7 +12252,8 @@ function serializeConfig(project) {
 				screenshotFailures: browser.screenshotFailures,
 				locators: {
 					testIdAttribute: browser.locators.testIdAttribute,
-					exact: browser.locators.exact
+					exact: browser.locators.exact,
+					errorFormat: browser.locators.errorFormat
 				},
 				providerOptions: provider?.name === "playwright" ? { actionTimeout: provider?.options?.actionTimeout } : {},
 				trackUnhandledErrors: browser.trackUnhandledErrors ?? true,
@@ -12353,7 +12263,12 @@ function serializeConfig(project) {
 		})(config.browser),
 		standalone: config.standalone,
 		printConsoleTrace: config.printConsoleTrace ?? globalConfig.printConsoleTrace,
-		benchmark: config.benchmark && { includeSamples: config.benchmark.includeSamples },
+		benchmark: {
+			enabled: config.benchmark.enabled,
+			retainSamples: config.benchmark.retainSamples,
+			suppressExportGetterWarnings: config.benchmark.suppressExportGetterWarnings,
+			projectName: config.benchmark.projectName
+		},
 		serializedDefines: config.browser.enabled ? "" : project._serializedDefines || "",
 		experimental: {
 			fsModuleCache: config.experimental.fsModuleCache ?? false,
@@ -12367,7 +12282,7 @@ function serializeConfig(project) {
 		strictTags: config.strictTags ?? true,
 		mergeReportsLabel: config.mergeReportsLabel,
 		slowTestThreshold: config.slowTestThreshold ?? globalConfig.slowTestThreshold ?? configDefaults.slowTestThreshold,
-		isAgent
+		disableColors: isAgent && !isForceColor()
 	};
 }
 
@@ -13364,7 +13279,8 @@ function WorkspaceVitestPlugin(project, options) {
 			name: "vitest:project:name",
 			enforce: "post",
 			config(viteConfig) {
-				const testConfig = viteConfig.test || {};
+				viteConfig.test ??= {};
+				const testConfig = viteConfig.test;
 				let { label: name, color } = typeof testConfig.name === "string" ? { label: testConfig.name } : {
 					label: "",
 					...testConfig.name
@@ -13376,6 +13292,10 @@ function WorkspaceVitestPlugin(project, options) {
 					if (existsSync(pkgJsonPath)) name = JSON.parse(readFileSync(pkgJsonPath, "utf-8")).name;
 					if (typeof name !== "string" || !name) name = basename(dir);
 				} else name = options.workspacePath.toString();
+				if (project.vitest._cliOptions.benchmarkOnly) {
+					viteConfig.test.benchmark ??= {};
+					viteConfig.test.benchmark.enabled = true;
+				}
 				const isBrowserEnabled = viteConfig.test?.browser?.enabled ?? (viteConfig.test?.browser && project.vitest._cliOptions.browser?.enabled);
 				// keep project names to potentially filter it out
 				const workspaceNames = [name];
@@ -13388,6 +13308,7 @@ function WorkspaceVitestPlugin(project, options) {
 					instance.name ??= name ? `${name} (${instance.browser})` : instance.browser;
 					if (isBrowserEnabled) workspaceNames.push(instance.name);
 				});
+				if (viteConfig.test?.benchmark?.enabled) workspaceNames.push(name ? `${name} (bench)` : "bench");
 				// if there is `--project=...` filter, check if any of the potential projects match
 				// if projects don't match, we ignore the test project altogether
 				// if some of them match, they will later be filtered again by `resolveWorkspace`
@@ -13660,9 +13581,9 @@ class TestSpecification {
 	* This class represents a test suite for a test module within a single project.
 	* @internal
 	*/
-	constructor(project, moduleId, pool, testLinesOrOptions, metaOverride) {
+	constructor(project, moduleId, pool, testLinesOrOptions, taskIdOverride) {
 		const projectName = project.config.name;
-		this.taskId = generateFileHash(relative(project.config.root, moduleId), projectName, metaOverride ?? {
+		this.taskId = taskIdOverride ?? generateFileHash(relative(project.config.root, moduleId), projectName, {
 			typecheck: pool === "typescript",
 			__vitest_label__: project.config.mergeReportsLabel
 		});
@@ -13720,6 +13641,7 @@ class TestProject {
 	* Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
 	*/
 	tmpDir;
+	benchmark = new BenchmarkManager(this);
 	/** @internal */ typechecker;
 	/** @internal */ _config;
 	/** @internal */ _vite;
@@ -13779,8 +13701,8 @@ class TestProject {
 	* Creates a new test specification. Specifications describe how to run tests.
 	* @param moduleId The file path
 	*/
-	createSpecification(moduleId, locationsOrOptions, pool, metaOverride) {
-		return new TestSpecification(this, moduleId, pool || getFilePoolName(this), locationsOrOptions, metaOverride);
+	createSpecification(moduleId, locationsOrOptions, pool, taskIdOverride) {
+		return new TestSpecification(this, moduleId, pool || getFilePoolName(this), locationsOrOptions, taskIdOverride);
 	}
 	toJSON() {
 		return {
@@ -14029,7 +13951,8 @@ class TestProject {
 	async _configureServer(options, server) {
 		this._config = resolveConfig$1(this.vitest, {
 			...options,
-			coverage: this.vitest.config.coverage
+			coverage: this.vitest.config.coverage,
+			attachmentsDir: this.vitest.config.attachmentsDir
 		}, server.config);
 		this._config.api.token = this.vitest.config.api.token;
 		this._config.mergeReportsLabel = this.vitest.config.mergeReportsLabel;
@@ -14069,9 +13992,8 @@ class TestProject {
 		const url = new URL("/__vitest_test__/", origin);
 		url.searchParams.set("sessionId", sessionId);
 		const otelCarrier = this.vitest._traces.getContextCarrier();
-		if (otelCarrier) url.searchParams.set("otelCarrier", JSON.stringify(otelCarrier));
 		this.vitest._browserSessions.sessionIds.add(sessionId);
-		const sessionPromise = this.vitest._browserSessions.createSession(sessionId, this, pool);
+		const sessionPromise = this.vitest._browserSessions.createSession(sessionId, this, pool, { otelCarrier });
 		const pagePromise = this.browser.provider.openPage(sessionId, url.toString(), { parallel: pool.parallel ?? false });
 		await Promise.all([sessionPromise, pagePromise]);
 	}
@@ -14125,7 +14047,7 @@ class TestProject {
 		return project;
 	}
 	/** @internal */
-	static _cloneBrowserProject(parent, config) {
+	static _cloneTestProject(parent, config) {
 		const clone = new TestProject(parent.vitest, void 0, parent.tmpDir);
 		clone.runner = parent.runner;
 		clone._vite = parent._vite;
@@ -14287,7 +14209,58 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 		}
 		names.add(name);
 	}
-	return resolveBrowserProjects(vitest, names, resolvedProjects);
+	return resolveDefaultProjects(vitest, names, resolvedProjects);
+}
+async function resolveDefaultProjects(vitest, names, resolvedProjects) {
+	const newProjects = await resolveBrowserProjects(vitest, names, resolvedProjects);
+	let lastGroupOrder = Math.max(0, ...newProjects.map((p) => p.config.sequence.groupOrder));
+	newProjects.forEach((project) => {
+		const benchmark = project.config.benchmark;
+		if (!benchmark.enabled) return;
+		if (vitest.isExcludedByProjectFilter(project.config.name)) {
+			benchmark.enabled = false;
+			return;
+		}
+		const name = project.config.name ? `${project.config.name} (bench)` : "bench";
+		if (!vitest.matchesProjectFilter(name)) {
+			benchmark.enabled = false;
+			return;
+		}
+		if (names.has(name)) throw new Error(`Cannot create a benchmark project because the name "${name}" is already in use.`);
+		names.add(name);
+		const benchmarkProject = TestProject._cloneTestProject(project, {
+			...project.config,
+			name,
+			include: benchmark.include,
+			exclude: benchmark.exclude,
+			includeSource: benchmark.includeSource,
+			coverage: {
+				...project.config.coverage,
+				enabled: false
+			},
+			maxWorkers: 1,
+			maxConcurrency: 1,
+			testTimeout: project.config.testTimeout < 6e4 ? 6e4 : project.config.testTimeout,
+			hookTimeout: project.config.hookTimeout < 12e4 ? 12e4 : project.config.hookTimeout,
+			benchmark: {
+				...benchmark,
+				projectName: project.config.name ?? ""
+			},
+			sequence: {
+				...project.config.sequence,
+				concurrent: false,
+				groupOrder: ++lastGroupOrder
+			},
+			typecheck: {
+				...project.config.typecheck,
+				enabled: false
+			}
+		});
+		// disable benchmark in the original project
+		benchmark.enabled = false;
+		newProjects.push(benchmarkProject);
+	});
+	return newProjects;
 }
 async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 	const removeProjects = /* @__PURE__ */ new Set();
@@ -14328,7 +14301,7 @@ async function resolveBrowserProjects(vitest, names, resolvedProjects) {
 			names.add(name);
 			const clonedConfig = cloneConfig(project, config);
 			clonedConfig.name = name;
-			const clone = TestProject._cloneBrowserProject(project, clonedConfig);
+			const clone = TestProject._cloneTestProject(project, clonedConfig);
 			resolvedProjects.push(clone);
 		});
 		removeProjects.add(project);
@@ -14345,7 +14318,8 @@ function cloneConfig(project, { browser, ...config }) {
 			...project.config.browser,
 			locators: locators ? {
 				testIdAttribute: locators.testIdAttribute ?? currentConfig.locators.testIdAttribute,
-				exact: locators.exact ?? currentConfig.locators.exact
+				exact: locators.exact ?? currentConfig.locators.exact,
+				errorFormat: locators.errorFormat ?? currentConfig.locators.errorFormat
 			} : project.config.browser.locators,
 			viewport: viewport ?? currentConfig.viewport,
 			testerHtmlPath: testerHtmlPath ?? currentConfig.testerHtmlPath,
@@ -14452,8 +14426,10 @@ function getDefaultTestProject(vitest) {
 }
 function getPotentialProjectNames(project) {
 	const names = [project.name];
+	// TODO: include benchmarks in browsers
 	if (project.config.browser.instances) names.push(...project.config.browser.instances.map((i) => i.name));
 	else if (project.config.browser.name) names.push(project.config.browser.name);
+	if (project.config.benchmark.enabled) names.push(project.name ? `${project.name} (bench)` : "bench");
 	return names;
 }
 
@@ -14512,8 +14488,8 @@ class BlobReporter {
 			outputFile = [
 				"blob",
 				this.ctx.config.mergeReportsLabel,
-				shard ? `-${shard.index}-${shard.count}` : ""
-			].join("");
+				shard ? `${shard.index}-${shard.count}` : ""
+			].filter(Boolean).join("-");
 			outputFile = `${sanitizeFilePath(outputFile)}.json`;
 			await report.writeFile(outputFile, content, "utf-8");
 			outputFile = resolve$1(report.root, outputFile);
@@ -14587,9 +14563,11 @@ function serializeEnvironmentModuleGraph(environment) {
 	};
 	const modules = [];
 	for (const [id, mod] of environment.moduleGraph.idToModuleMap.entries()) {
-		if (!mod.file) continue;
+		// Vite can generate module with `file = ""` for module id "#..."
+		// when the actual module doesn't exist (e.g. resolve failure or mocked module)
+		if (mod.file == null) continue;
 		const importedIds = [];
-		for (const importedNode of mod.importedModules) if (importedNode.id) importedIds.push(getIdIndex(importedNode.id));
+		for (const importedNode of mod.importedModules) if (importedNode.id !== null) importedIds.push(getIdIndex(importedNode.id));
 		modules.push([
 			getIdIndex(id),
 			getIdIndex(mod.file),
@@ -14608,6 +14586,10 @@ function deserializeEnvironmentModuleGraph(environment, serialized) {
 		const moduleId = serialized.idTable[id];
 		const filePath = serialized.idTable[file];
 		const urlPath = serialized.idTable[url];
+		// `createFileOnlyEntry('')` normalizes the file to ".". This keeps
+		// the graph usable, but doesn't perfectly round-trip Vite's `file = ""`
+		// nodes for ids like "#...".
+		// We may just do moduleNode.file = filePath in the future.
 		const moduleNode = environment.moduleGraph.createFileOnlyEntry(filePath);
 		moduleNode.url = urlPath;
 		moduleNode.id = moduleId;
@@ -14679,6 +14661,66 @@ function createReport(ctx, scope) {
 	};
 }
 
+const BENCH_TABLE_HEAD = [
+	"hz",
+	"min",
+	"max",
+	"mean",
+	"p75",
+	"p99",
+	"p995",
+	"p999",
+	"rme",
+	"samples"
+];
+function formatBenchNumber(number) {
+	const res = String(number.toFixed(number < 100 ? 4 : 2)).split(".");
+	return res[0].replace(/(?=(?:\d{3})+$)\B/g, ",") + (res[1] ? `.${res[1]}` : "");
+}
+// Plain-text rendering of the benchmark table (no ANSI colors, no indent).
+// Used by the junit reporter to embed benchmark data in <system-out>.
+function renderBenchmarkTableText(benchmarks, columnName = "name") {
+	const lines = [];
+	for (const benchmark of benchmarks) {
+		const { tasks } = benchmark;
+		if (tasks.length === 0) continue;
+		if (lines.length > 0) lines.push("");
+		const rows = tasks.map(renderBenchmarkRow);
+		const head = [columnName, ...BENCH_TABLE_HEAD];
+		const widths = computeBenchColumnWidths(head, rows);
+		lines.push(padBenchRow(head, widths).join("  "));
+		for (const task of tasks) {
+			let row = padBenchRow(renderBenchmarkRow(task), widths).join("  ");
+			if (task.rank === 1 && tasks.length > 1) row += "   fastest";
+			if (task.rank === tasks.length && tasks.length > 2) row += "   slowest";
+			lines.push(row);
+		}
+	}
+	return lines.join("\n");
+}
+function renderBenchmarkRow(task) {
+	return [
+		task.name,
+		formatBenchNumber(task.throughput.mean || 0),
+		formatBenchNumber(task.latency.min || 0),
+		formatBenchNumber(task.latency.max || 0),
+		formatBenchNumber(task.latency.mean || 0),
+		formatBenchNumber(task.latency.p75 || 0),
+		formatBenchNumber(task.latency.p99 || 0),
+		formatBenchNumber(task.latency.p995 || 0),
+		formatBenchNumber(task.latency.p999 || 0),
+		`\u00B1${(task.latency.rme || 0).toFixed(2)}%`,
+		String(task.latency.samplesCount || 0)
+	];
+}
+function computeBenchColumnWidths(header, rows) {
+	const allRows = [header, ...rows];
+	return Array.from(header, (_, i) => Math.max(...allRows.map((row) => stripVTControlCharacters(row[i]).length)));
+}
+function padBenchRow(row, widths) {
+	return row.map((v, i) => i === 0 ? v.padEnd(widths[i]) : v.padStart(widths[i]));
+}
+
 const BADGE_PADDING = "       ";
 class BaseReporter {
 	start = 0;
@@ -14692,6 +14734,7 @@ class BaseReporter {
 	silent;
 	_filesInWatchMode = /* @__PURE__ */ new Map();
 	_timeStart = formatTimeString(/* @__PURE__ */ new Date());
+	_perProjectBenchmarks = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.isTTY = options.isTTY ?? isTTY;
 		this.silent = options.silent;
@@ -14713,17 +14756,34 @@ class BaseReporter {
 	onTestRunStart(_specifications) {
 		this.start = performance$1.now();
 		this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
+		this._perProjectBenchmarks.clear();
 	}
 	onTestRunEnd(testModules, unhandledErrors, _reason) {
 		const files = testModules.map((testModule) => testModule.task);
 		const errors = [...unhandledErrors];
 		this.end = performance$1.now();
 		if (!files.length && !errors.length) this.ctx.logger.printNoTestFound(this.ctx.filenamePattern);
-		else this.reportSummary(files, errors);
+		else {
+			this.printPerProjectBenchmarks();
+			this.reportSummary(files, errors);
+		}
 	}
 	onTestCaseResult(testCase) {
 		if (testCase.result().state === "failed") this.logFailedTask(testCase.task);
 	}
+	onTestCaseBenchmark(testCase, benchmark) {
+		const projectName = testCase.project.name || "";
+		for (const task of benchmark.tasks) {
+			if (!task.perProject) continue;
+			const benchKey = `${testCase.module.relativeModuleId} > ${testCase.fullName} > ${task.name}`;
+			let projectMap = this._perProjectBenchmarks.get(benchKey);
+			if (!projectMap) {
+				projectMap = /* @__PURE__ */ new Map();
+				this._perProjectBenchmarks.set(benchKey, projectMap);
+			}
+			projectMap.set(projectName, task);
+		}
+	}
 	onTestSuiteResult(testSuite) {
 		if (testSuite.state() === "failed") this.logFailedTask(testSuite.task);
 	}
@@ -14782,9 +14842,13 @@ class BaseReporter {
 		const { duration = 0 } = test.diagnostic() || {};
 		const padding = this.getTestIndentation(test.task);
 		const suffix = this.getTestCaseSuffix(test);
+		// perProject tasks still appear in the inline table — they're additionally
+		// aggregated in the cross-project section at the end of the run
+		const inlineBenchmarks = test.benchmarks().filter((b) => b.tasks.length > 0);
 		if (testResult.state === "failed") this.log(c.red(` ${padding}${taskFail} ${this.getTestName(test.task, separator)}`) + suffix);
-		else if (duration > this.ctx.config.slowTestThreshold) this.log(` ${padding}${c.yellow(c.dim(F_CHECK))} ${this.getTestName(test.task, separator)} ${suffix}`);
-		else if (this.ctx.config.hideSkippedTests && testResult.state === "skipped" && test.options.mode !== "todo") ; else if (this.renderSucceed || moduleState === "failed") this.log(` ${padding}${this.getStateSymbol(test)} ${this.getTestName(test.task, separator)}${suffix}`);
+		else if (duration > this.ctx.config.slowTestThreshold) this.log(` ${padding}${c.yellow(c.dim(F_CHECK))} ${this.getTestName(test.task, separator)}${suffix}`);
+		else if (this.ctx.config.hideSkippedTests && testResult.state === "skipped" && test.options.mode !== "todo") ; else if (this.renderSucceed || moduleState === "failed" || inlineBenchmarks.length) this.log(` ${padding}${this.getStateSymbol(test)} ${this.getTestName(test.task, separator)}${suffix}`);
+		if (inlineBenchmarks.length > 0) this.printBenchmarkTable(inlineBenchmarks, padding);
 	}
 	getModuleLog(testModule, counts) {
 		let state = c.dim(`${counts.tests} test${counts.tests > 1 ? "s" : ""}`);
@@ -14938,8 +15002,7 @@ class BaseReporter {
 	reportSummary(files, errors) {
 		this.printErrorsSummary(files, errors);
 		const leakCount = this.printLeaksSummary();
-		if (this.ctx.config.mode === "benchmark") this.reportBenchmarkSummary(files);
-		else this.reportTestSummary(files, errors, leakCount);
+		this.reportTestSummary(files, errors, leakCount);
 	}
 	reportTestSummary(files, errors, leakCount) {
 		this.log();
@@ -15004,19 +15067,23 @@ class BaseReporter {
 			}
 		}
 		if (allImports.length === 0) return;
-		const dangerImports = allImports.filter((imp) => imp.totalTime >= thresholds.danger);
-		const warnImports = allImports.filter((imp) => imp.totalTime >= thresholds.warn);
-		const hasDangerImports = dangerImports.length > 0;
-		const hasWarnImports = warnImports.length > 0;
+		let dangerImportsCount = 0;
+		let hasWarnImports = false;
+		let totalSelfTime = 0;
+		let totalTotalTime = 0;
+		for (const imp of allImports) {
+			if (imp.totalTime >= thresholds.danger) dangerImportsCount++;
+			if (imp.totalTime >= thresholds.warn) hasWarnImports = true;
+			totalSelfTime += imp.selfTime;
+			totalTotalTime += imp.totalTime;
+		}
 		// Determine if we should print
-		const shouldFail = failOnDanger && hasDangerImports;
+		const shouldFail = failOnDanger && dangerImportsCount > 0;
 		if (!(print === true || print === "on-warn" && hasWarnImports || shouldFail)) return;
 		const sortedImports = allImports.sort((a, b) => b.totalTime - a.totalTime);
 		const maxTotalTime = sortedImports[0].totalTime;
 		const limit = this.ctx.config.experimental.importDurations.limit;
 		const topImports = sortedImports.slice(0, limit);
-		const totalSelfTime = allImports.reduce((sum, imp) => sum + imp.selfTime, 0);
-		const totalTotalTime = allImports.reduce((sum, imp) => sum + imp.totalTime, 0);
 		const slowestImport = sortedImports[0];
 		this.log();
 		this.log(c.bold("Import Duration Breakdown") + c.dim(` (Top ${limit})`));
@@ -15056,7 +15123,7 @@ class BaseReporter {
 		// Fail if danger threshold exceeded
 		if (shouldFail) {
 			this.log();
-			this.ctx.logger.error(`ERROR: ${dangerImports.length} import(s) exceeded the danger threshold of ${thresholds.danger}ms`);
+			this.ctx.logger.error(`ERROR: ${dangerImportsCount} import(s) exceeded the danger threshold of ${thresholds.danger}ms`);
 			process.exitCode = 1;
 		}
 	}
@@ -15123,21 +15190,63 @@ class BaseReporter {
 		}
 		return leakWithStacks.size;
 	}
-	reportBenchmarkSummary(files) {
-		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;
-			if (!group) continue;
-			const groupName = this.getFullName(group, separator);
-			const project = this.ctx.projects.find((p) => p.name === bench.file.projectName);
-			this.log(`  ${formatProjectName(project)}${bench.name}${c.dim(` - ${groupName}`)}`);
-			const siblings = group.tasks.filter((i) => i.meta.benchmark && i.result?.benchmark && i !== bench).sort((a, b) => a.result.benchmark.rank - b.result.benchmark.rank);
-			for (const sibling of siblings) {
-				const number = (sibling.result.benchmark.mean / bench.result.benchmark.mean).toFixed(2);
-				this.log(c.green(`    ${number}x `) + c.gray("faster than ") + sibling.name);
-			}
+	printPerProjectBenchmarks() {
+		if (this._perProjectBenchmarks.size === 0) return;
+		let hasComparable = false;
+		for (const projectMap of this._perProjectBenchmarks.values()) if (projectMap.size > 1) {
+			hasComparable = true;
+			break;
+		}
+		if (!hasComparable) return;
+		this.log("");
+		this.log(divider(c.bold(c.bgBlue(` Cross-Project Benchmark Comparison `)), null, null, c.blue));
+		for (const [benchName, projectMap] of this._perProjectBenchmarks) {
+			const tasks = [...projectMap.entries()].sort((a, b) => a[1].latency.mean - b[1].latency.mean).map(([projectName, task], index) => ({
+				...task,
+				name: projectName,
+				rank: index + 1
+			}));
+			if (tasks.length <= 1) continue;
 			this.log("");
+			this.log(`  ${c.dim(benchName)}`);
+			this.printBenchmarkTable([{
+				name: benchName,
+				tasks
+			}], "", "project");
+		}
+		this.log("");
+	}
+	printBenchmarkTable(benchmarks, basePadding, columnName = "name") {
+		let printedCount = 0;
+		for (const benchmark of benchmarks) {
+			const { tasks } = benchmark;
+			if (tasks.length === 0) continue;
+			if (printedCount > 0) this.log("");
+			const rows = tasks.map((t) => renderBenchmarkRow(t));
+			const tableHead = [columnName, ...BENCH_TABLE_HEAD];
+			const widths = computeBenchColumnWidths(tableHead, rows);
+			const indent = ` ${basePadding}  `;
+			this.log(`${indent}${padBenchRow(tableHead, widths).map(c.bold).join("  ")}`);
+			printedCount++;
+			for (const task of tasks) {
+				const padded = padBenchRow(renderBenchmarkRow(task), widths);
+				let row = [
+					padded[0],
+					c.blue(padded[1]),
+					c.cyan(padded[2]),
+					c.cyan(padded[3]),
+					c.cyan(padded[4]),
+					c.cyan(padded[5]),
+					c.cyan(padded[6]),
+					c.cyan(padded[7]),
+					c.cyan(padded[8]),
+					c.dim(padded[9]),
+					c.dim(padded[10])
+				].join("  ");
+				if (task.rank === 1 && tasks.length > 1) row += c.bold(c.green("   fastest"));
+				if (task.rank === tasks.length && tasks.length > 2) row += c.bold(c.gray("   slowest"));
+				this.log(`${indent}${row}`);
+			}
 		}
 	}
 	printTaskErrors(tasks, errorDivider) {
@@ -15195,7 +15304,7 @@ function deepEqual(a, b) {
 	const keysA = Object.keys(a);
 	const keysB = Object.keys(b);
 	if (keysA.length !== keysB.length) return false;
-	for (const key of keysA) if (!keysB.includes(key) || !deepEqual(a[key], b[key])) return false;
+	for (const key of keysA) if (!Object.prototype.hasOwnProperty.call(b, key) || !deepEqual(a[key], b[key])) return false;
 	return true;
 }
 function sum(items, cb) {
@@ -15208,6 +15317,9 @@ function getIndentation(suite, level = 1) {
 	return level;
 }
 
+/** Minimum time between two renders, no matter how many scheduled renderes were called */
+const DEFAULT_RENDER_THRESHOLD_MS = 100;
+/** Interval between automatic renders. If no test state changes happened, this will increase just duration field */
 const DEFAULT_RENDER_INTERVAL_MS = 1e3;
 const ESC$1 = "\x1B[";
 const CLEAR_LINE = `${ESC$1}K`;
@@ -15230,14 +15342,19 @@ class WindowRenderer {
 	cleanups = [];
 	constructor(options) {
 		this.options = {
-			interval: DEFAULT_RENDER_INTERVAL_MS,
-			...options
+			...options,
+			threshold: options.threshold ?? DEFAULT_RENDER_THRESHOLD_MS,
+			interval: options.interval ?? DEFAULT_RENDER_INTERVAL_MS
 		};
+		// Capture the original write methods early, before intercepting these
 		this.streams = {
 			output: options.logger.outputStream.write.bind(options.logger.outputStream),
 			error: options.logger.errorStream.write.bind(options.logger.errorStream)
 		};
 		this.cleanups.push(this.interceptStream(process.stdout, "output"), this.interceptStream(process.stderr, "error"));
+		// Intercept calls to custom VitestOptions.stdout and stderr streams
+		if (options.logger.outputStream !== process.stdout) this.cleanups.push(this.interceptStream(options.logger.outputStream, "output"));
+		if (options.logger.errorStream !== process.stderr) this.cleanups.push(this.interceptStream(options.logger.errorStream, "error"));
 		// Write buffered content on unexpected exits, e.g. direct `process.exit()` calls
 		this.options.logger.onTerminalCleanup(() => {
 			this.flushBuffer();
@@ -15269,9 +15386,10 @@ class WindowRenderer {
 		if (!this.renderScheduled) {
 			this.renderScheduled = true;
 			this.flushBuffer();
-			setTimeout(() => {
+			if (this.options.threshold) setTimeout(() => {
 				this.renderScheduled = false;
-			}, 100).unref();
+			}, this.options.threshold).unref();
+			else this.renderScheduled = false;
 		}
 	}
 	flushBuffer() {
@@ -15293,15 +15411,16 @@ class WindowRenderer {
 		if (current) this.render(current?.message, current?.type);
 	}
 	render(message, type = "output") {
+		this.write(SYNC_START);
 		if (this.finished) {
 			this.clearWindow();
-			return this.write(message || "", type);
+			this.write(message || "", type);
+			return this.write(SYNC_END);
 		}
 		const windowContent = this.options.getWindow();
 		const rowCount = getRenderedRowCount(windowContent, this.options.logger.getColumns());
 		let padding = this.windowHeight - rowCount;
 		if (padding > 0 && message) padding -= getRenderedRowCount([message], this.options.logger.getColumns());
-		this.write(SYNC_START);
 		this.clearWindow();
 		if (message) this.write(message, type);
 		if (padding > 0) this.write("\n".repeat(padding));
@@ -15373,7 +15492,9 @@ class SummaryReporter {
 		};
 		this.renderer = new WindowRenderer({
 			logger: ctx.logger,
-			getWindow: () => this.createSummary()
+			getWindow: () => this.createSummary(),
+			interval: this.options.interval,
+			threshold: this.options.threshold
 		});
 		this.ctx.onClose(() => {
 			clearInterval(this.durationInterval);
@@ -15416,27 +15537,30 @@ class SummaryReporter {
 		this.maxParallelTests = Math.max(this.maxParallelTests, this.runningModules.size);
 		this.renderer.schedule();
 	}
-	onHookStart(options) {
-		const stats = this.getHookStats(options);
-		if (!stats) return;
-		const hook = {
-			name: options.name,
+	startStep(stats, name) {
+		const step = {
+			name,
 			visible: false,
 			startTime: performance.now(),
 			onFinish: () => {}
 		};
-		stats.hook?.onFinish?.();
-		stats.hook = hook;
+		stats.step?.onFinish?.();
+		stats.step = step;
+		if (!Number.isFinite(this.ctx.config.slowTestThreshold)) return;
 		const timeout = setTimeout(() => {
-			hook.visible = true;
+			step.visible = true;
 		}, this.ctx.config.slowTestThreshold).unref();
-		hook.onFinish = () => clearTimeout(timeout);
+		step.onFinish = () => clearTimeout(timeout);
+	}
+	onHookStart(options) {
+		const stats = this.getStepStats(options.entity);
+		if (stats) this.startStep(stats, options.name);
 	}
 	onHookEnd(options) {
-		const stats = this.getHookStats(options);
-		if (stats?.hook?.name !== options.name) return;
-		stats.hook.onFinish();
-		stats.hook.visible = false;
+		const stats = this.getStepStats(options.entity);
+		if (stats?.step?.name !== options.name) return;
+		stats.step.onFinish();
+		stats.step.visible = false;
 	}
 	onTestCaseReady(test) {
 		// Track slow running tests only on verbose mode
@@ -15449,11 +15573,11 @@ class SummaryReporter {
 			startTime: performance.now(),
 			onFinish: () => {}
 		};
-		const timeout = setTimeout(() => {
+		const timeout = Number.isFinite(this.ctx.config.slowTestThreshold) ? setTimeout(() => {
 			slowTest.visible = true;
-		}, this.ctx.config.slowTestThreshold).unref();
+		}, this.ctx.config.slowTestThreshold).unref() : void 0;
 		slowTest.onFinish = () => {
-			slowTest.hook?.onFinish();
+			slowTest.step?.onFinish();
 			clearTimeout(timeout);
 		};
 		stats.tests.set(test.id, slowTest);
@@ -15493,7 +15617,7 @@ class SummaryReporter {
 		this.removeTestModule(module.id);
 		this.renderer.schedule();
 	}
-	getHookStats({ entity }) {
+	getStepStats(entity) {
 		// Track slow running hooks only on verbose mode
 		if (!this.options.verbose) return;
 		const module = entity.type === "module" ? entity : entity.module;
@@ -15510,12 +15634,12 @@ class SummaryReporter {
 				name: testFile.projectName,
 				color: testFile.projectColor
 			}) + typecheck + label + testFile.filename + c.dim(!testFile.completed && !testFile.total ? " [queued]" : ` ${testFile.completed}/${testFile.total}`));
-			const slowTasks = [testFile.hook, ...testFile.tests.values()].filter((t) => t != null && t.visible);
+			const slowTasks = [testFile.step, ...testFile.tests.values()].filter((t) => t != null && t.visible);
 			for (const [index, task] of slowTasks.entries()) {
 				const elapsed = this.currentTime - task.startTime;
 				const icon = index === slowTasks.length - 1 ? F_TREE_NODE_END : F_TREE_NODE_MIDDLE;
 				summary.push(c.bold(c.yellow(`   ${icon} `)) + task.name + c.bold(c.yellow(` ${formatTime(Math.max(0, elapsed))}`)));
-				if (task.hook?.visible) summary.push(c.bold(c.yellow(`      ${F_TREE_NODE_END} `)) + task.hook.name);
+				if (task.step?.visible) summary.push(c.bold(c.yellow(`      ${F_TREE_NODE_END} `)) + task.step.name);
 			}
 		}
 		if (this.runningModules.size > 0) summary.push("");
@@ -15537,7 +15661,7 @@ class SummaryReporter {
 	removeTestModule(id) {
 		if (!id) return;
 		const testFile = this.runningModules.get(id);
-		testFile?.hook?.onFinish();
+		testFile?.step?.onFinish();
 		testFile?.tests?.forEach((test) => test.onFinish());
 		this.runningModules.delete(id);
 		clearTimeout(this.finishedModules.get(id));
@@ -15630,7 +15754,10 @@ class DefaultReporter extends BaseReporter {
 	}
 	onInit(ctx) {
 		super.onInit(ctx);
-		this.summary?.onInit(ctx, { verbose: this.verbose });
+		this.summary?.onInit(ctx, {
+			verbose: this.verbose,
+			...this.options.summaryOptions
+		});
 	}
 }
 
@@ -16075,7 +16202,8 @@ class JsonReporter {
 						}
 						return filtered;
 					})() : t.meta,
-					tags: t.tags || []
+					tags: t.tags || [],
+					benchmarks: t.benchmarks
 				};
 			});
 			if (tests.some((t) => t.result?.state === "run" || t.result?.state === "queued")) this.ctx.logger.warn("WARNING: Some tests are still running when generating the JSON report.This is likely an internal bug in Vitest.Please report it to https://github.com/vitest-dev/vitest/issues");
@@ -16235,6 +16363,18 @@ class JUnitReporter {
 			for (const log of logs) await this.baseLog(escapeXML(log.content));
 		});
 	}
+	async writeSystemOut(task) {
+		const logs = this.options.includeConsoleOutput && task.logs ? task.logs.filter((log) => log.type === "stdout") : [];
+		const benchmarks = task.type === "test" ? task.benchmarks : [];
+		if (logs.length === 0 && benchmarks.length === 0) return;
+		await this.writeElement("system-out", {}, async () => {
+			for (const log of logs) await this.baseLog(escapeXML(log.content));
+			if (benchmarks.length > 0) {
+				if (logs.length > 0) await this.baseLog("");
+				await this.baseLog(escapeXML(renderBenchmarkTableText(benchmarks)));
+			}
+		});
+	}
 	applyTemplate(template, vars) {
 		if (typeof template === "function") return template(vars);
 		return template.replace(/\{filename\}/g, () => vars.filename).replace(/\{filepath\}/g, () => vars.filepath).replace(/\{basename\}/g, () => vars.basename).replace(/\{classname\}/g, () => vars.classname).replace(/\{title\}/g, () => vars.title).replace(/\{suitename\}/g, () => vars.suitename).replace(/\{displayName\}/g, () => vars.displayName);
@@ -16260,10 +16400,8 @@ class JUnitReporter {
 				name: testcaseName,
 				time: getDuration(task)
 			}, async () => {
-				if (this.options.includeConsoleOutput) {
-					await this.writeLogs(task, "out");
-					await this.writeLogs(task, "err");
-				}
+				await this.writeSystemOut(task);
+				if (this.options.includeConsoleOutput) await this.writeLogs(task, "err");
 				if (task.mode === "skip" || task.mode === "todo") await this.logger.log("<skipped/>");
 				if (task.type === "test" && task.annotations.length) {
 					await this.logger.log("<properties>");
@@ -16277,14 +16415,7 @@ class JUnitReporter {
 				}
 				if (task.result?.state === "fail") {
 					const errors = task.result.errors || [];
-					for (const error of errors) await this.writeElement("failure", {
-						message: error?.message,
-						type: error?.name
-					}, async () => {
-						if (!error || !this.options.stackTrace) return;
-						const result = this.ctx.logger.formatError(error, { project: this.ctx.getProjectByName(task.file?.projectName ?? "") });
-						await this.baseLog(escapeXML(stripVTControlCharacters(result.output.trim())));
-					});
+					for (const error of errors) await this.writeErrorElement("failure", error, { project: this.ctx.getProjectByName(task.file?.projectName ?? "") });
 				}
 			});
 		}
@@ -16303,7 +16434,52 @@ class JUnitReporter {
 		if (typeof this.options.suiteNameTemplate === "function") return this.options.suiteNameTemplate(vars);
 		return this.options.suiteNameTemplate.replace(/\{filepath\}/g, () => vars.filepath).replace(/\{filename\}/g, () => vars.filename).replace(/\{basename\}/g, () => vars.basename).replace(/\{displayName\}/g, () => vars.displayName).replace(/\{title\}/g, () => vars.title);
 	}
-	async onTestRunEnd(testModules) {
+	async writeErrorElement(elementName, error, errorOptions) {
+		await this.writeElement(elementName, {
+			message: error?.message,
+			type: error?.name
+		}, async () => {
+			if (!error || !this.options.stackTrace) return;
+			const result = this.ctx.logger.formatError(error, errorOptions);
+			await this.baseLog(escapeXML(stripVTControlCharacters(result.output.trim())));
+		});
+	}
+	async writeUnhandledErrorsTestsuite(unhandledErrors, testModules) {
+		await this.writeElement("testsuite", {
+			name: "vitest unhandled errors",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			hostname: this.options.hostname || hostname(),
+			tests: unhandledErrors.length,
+			failures: 0,
+			errors: unhandledErrors.length,
+			skipped: 0,
+			time: "0"
+		}, async () => {
+			// Stable order across runs — workers/projects report errors concurrently.
+			const sortedErrors = [...unhandledErrors].sort((a, b) => {
+				const ka = `${a.VITEST_TEST_PATH ?? ""}\0${a.type ?? ""}\0${a.name ?? ""}\0${a.message ?? ""}`;
+				const kb = `${b.VITEST_TEST_PATH ?? ""}\0${b.type ?? ""}\0${b.name ?? ""}\0${b.message ?? ""}`;
+				return ka < kb ? -1 : ka > kb ? 1 : 0;
+			});
+			for (const error of sortedErrors) {
+				const errorTitle = error.type || error.name || "Unhandled Error";
+				// Only attribute when the path resolves to exactly one module — when
+				// multiple projects share a file, errors lack a project identifier and
+				// we can't disambiguate without one (tracked for follow-up).
+				const matches = error.VITEST_TEST_PATH ? testModules.filter((m) => m.task.filepath === error.VITEST_TEST_PATH) : [];
+				const owningModule = matches.length === 1 ? matches[0] : void 0;
+				await this.writeElement("testcase", {
+					classname: "vitest unhandled errors",
+					file: this.options.addFileAttribute && error.VITEST_TEST_PATH ? relative(this.ctx.config.root, error.VITEST_TEST_PATH) : void 0,
+					name: error.message ? `${errorTitle}: ${error.message}` : errorTitle,
+					time: "0"
+				}, async () => {
+					await this.writeErrorElement("error", error, { project: owningModule?.project });
+				});
+			}
+		});
+	}
+	async onTestRunEnd(testModules, unhandledErrors = []) {
 		const files = testModules.map((testModule) => testModule.task);
 		const separator = this.options.ancestorSeparator ?? " > ";
 		await this.logger.log("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
@@ -16343,7 +16519,8 @@ class JUnitReporter {
 					suite: null,
 					file: null,
 					annotations: [],
-					artifacts: []
+					artifacts: [],
+					benchmarks: []
 				});
 			}
 			return {
@@ -16361,32 +16538,36 @@ class JUnitReporter {
 			name: this.options.suiteName || "vitest tests",
 			tests: 0,
 			failures: 0,
-			errors: 0,
+			errors: unhandledErrors.length,
 			time: 0
 		});
+		stats.tests += unhandledErrors.length;
+		// Plain byte compare (not localeCompare) so output is identical across machines and ICU versions.
+		const orderedSuites = transformed.map((file, i) => {
+			const filename = relative(this.ctx.config.root, file.filepath);
+			return {
+				file,
+				filename,
+				suiteName: this.resolveSuiteNameTemplate(files[i], filename)
+			};
+		}).sort((a, b) => a.suiteName < b.suiteName ? -1 : a.suiteName > b.suiteName ? 1 : 0);
 		await this.writeElement("testsuites", {
 			...stats,
 			time: executionTime(stats.time)
 		}, async () => {
-			for (let i = 0; i < transformed.length; i++) {
-				const file = transformed[i];
-				const filename = relative(this.ctx.config.root, file.filepath);
-				// resolveSuiteNameTemplate needs the original file (before task flattening) to
-				// search for top-level describe blocks, so pass files[i] directly.
-				const suiteName = this.resolveSuiteNameTemplate(files[i], filename);
-				await this.writeElement("testsuite", {
-					name: suiteName,
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-					hostname: this.options.hostname || hostname(),
-					tests: file.tasks.length,
-					failures: file.stats.failures,
-					errors: 0,
-					skipped: file.stats.skipped,
-					time: getDuration(file)
-				}, async () => {
-					await this.writeTasks(file.tasks, filename, file.filepath);
-				});
-			}
+			for (const { file, filename, suiteName } of orderedSuites) await this.writeElement("testsuite", {
+				name: suiteName,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				hostname: this.options.hostname || hostname(),
+				tests: file.tasks.length,
+				failures: file.stats.failures,
+				errors: 0,
+				skipped: file.stats.skipped,
+				time: getDuration(file)
+			}, async () => {
+				await this.writeTasks(file.tasks, filename, file.filepath);
+			});
+			if (unhandledErrors.length) await this.writeUnhandledErrorsTestsuite(unhandledErrors, testModules);
 		});
 		if (this.reportFile) this.ctx.logger.log(`JUNIT report written to ${this.reportFile}`);
 		await this.fileFd?.close();
@@ -16541,231 +16722,11 @@ class VerboseReporter extends DefaultReporter {
 			this.printAnnotations(test, "log", 3);
 			this.log();
 		}
+		const inlineBenchmarks = test.benchmarks().filter((b) => b.tasks.length > 0);
+		if (inlineBenchmarks.length > 0) this.printBenchmarkTable(inlineBenchmarks, "");
 	}
 }
 
-function createBenchmarkJsonReport(files) {
-	const report = { files: [] };
-	for (const file of files) {
-		const groups = [];
-		for (const task of getTasks(file)) if (task?.type === "suite") {
-			const benchmarks = [];
-			for (const t of task.tasks) {
-				const benchmark = t.meta.benchmark && t.result?.benchmark;
-				if (benchmark) benchmarks.push({
-					id: t.id,
-					...benchmark,
-					samples: []
-				});
-			}
-			if (benchmarks.length) groups.push({
-				fullName: getFullName(task, " > "),
-				benchmarks
-			});
-		}
-		report.files.push({
-			filepath: file.filepath,
-			groups
-		});
-	}
-	return report;
-}
-function flattenFormattedBenchmarkReport(report) {
-	const flat = {};
-	for (const file of report.files) for (const group of file.groups) for (const t of group.benchmarks) flat[t.id] = t;
-	return flat;
-}
-
-const outputMap = /* @__PURE__ */ new WeakMap();
-function formatNumber(number) {
-	const res = String(number.toFixed(number < 100 ? 4 : 2)).split(".");
-	return res[0].replace(/(?=(?:\d{3})+$)\B/g, ",") + (res[1] ? `.${res[1]}` : "");
-}
-const tableHead = [
-	"name",
-	"hz",
-	"min",
-	"max",
-	"mean",
-	"p75",
-	"p99",
-	"p995",
-	"p999",
-	"rme",
-	"samples"
-];
-function renderBenchmarkItems(result) {
-	return [
-		result.name,
-		formatNumber(result.hz || 0),
-		formatNumber(result.min || 0),
-		formatNumber(result.max || 0),
-		formatNumber(result.mean || 0),
-		formatNumber(result.p75 || 0),
-		formatNumber(result.p99 || 0),
-		formatNumber(result.p995 || 0),
-		formatNumber(result.p999 || 0),
-		`±${(result.rme || 0).toFixed(2)}%`,
-		(result.sampleCount || 0).toString()
-	];
-}
-function computeColumnWidths(results) {
-	const rows = [tableHead, ...results.map((v) => renderBenchmarkItems(v))];
-	return Array.from(tableHead, (_, i) => Math.max(...rows.map((row) => stripVTControlCharacters(row[i]).length)));
-}
-function padRow(row, widths) {
-	return row.map((v, i) => i ? v.padStart(widths[i], " ") : v.padEnd(widths[i], " "));
-}
-function renderTableHead(widths) {
-	return " ".repeat(3) + padRow(tableHead, widths).map(c.bold).join("  ");
-}
-function renderBenchmark(result, widths) {
-	const padded = padRow(renderBenchmarkItems(result), widths);
-	return [
-		padded[0],
-		c.blue(padded[1]),
-		c.cyan(padded[2]),
-		c.cyan(padded[3]),
-		c.cyan(padded[4]),
-		c.cyan(padded[5]),
-		c.cyan(padded[6]),
-		c.cyan(padded[7]),
-		c.cyan(padded[8]),
-		c.dim(padded[9]),
-		c.dim(padded[10])
-	].join("  ");
-}
-function renderTable(options) {
-	const output = [];
-	const benchMap = {};
-	for (const task of options.tasks) if (task.meta.benchmark && task.result?.benchmark) benchMap[task.id] = {
-		current: task.result.benchmark,
-		baseline: options.compare?.[task.id]
-	};
-	const benchCount = Object.entries(benchMap).length;
-	const columnWidths = computeColumnWidths(Object.values(benchMap).flatMap((v) => [v.current, v.baseline]).filter(notNullish));
-	let idx = 0;
-	const padding = "  ".repeat(1 );
-	for (const task of options.tasks) {
-		const duration = task.result?.duration;
-		const bench = benchMap[task.id];
-		let prefix = "";
-		if (idx === 0 && task.meta?.benchmark) prefix += `${renderTableHead(columnWidths)}\n${padding}`;
-		prefix += ` ${getStateSymbol(task)} `;
-		let suffix = "";
-		if (task.type === "suite") suffix += c.dim(` (${getTests(task).length})`);
-		if (task.mode === "skip" || task.mode === "todo") suffix += c.dim(c.gray(" [skipped]"));
-		if (duration != null) {
-			const color = duration > options.slowTestThreshold ? c.yellow : c.green;
-			suffix += color(` ${Math.round(duration)}${c.dim("ms")}`);
-		}
-		if (options.showHeap && task.result?.heap != null) suffix += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
-		if (bench) {
-			let body = renderBenchmark(bench.current, columnWidths);
-			if (options.compare && bench.baseline) {
-				if (bench.current.hz) {
-					const diff = bench.current.hz / bench.baseline.hz;
-					const diffFixed = diff.toFixed(2);
-					if (diffFixed === "1.0.0") body += c.gray(`  [${diffFixed}x]`);
-					if (diff > 1) body += c.blue(`  [${diffFixed}x] ⇑`);
-					else body += c.red(`  [${diffFixed}x] ⇓`);
-				}
-				output.push(padding + prefix + body + suffix);
-				const bodyBaseline = renderBenchmark(bench.baseline, columnWidths);
-				output.push(`${padding}   ${bodyBaseline}  ${c.dim("(baseline)")}`);
-			} else {
-				if (bench.current.rank === 1 && benchCount > 1) body += c.bold(c.green("   fastest"));
-				if (bench.current.rank === benchCount && benchCount > 2) body += c.bold(c.gray("   slowest"));
-				output.push(padding + prefix + body + suffix);
-			}
-		} else output.push(padding + prefix + task.name + suffix);
-		if (task.result?.state !== "pass" && outputMap.get(task) != null) {
-			let data = outputMap.get(task);
-			if (typeof data === "string") {
-				data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop());
-				if (data === "") data = void 0;
-			}
-			if (data != null) {
-				const out = `   ${"  ".repeat(options.level)}${F_RIGHT} ${data}`;
-				output.push(c.gray(truncateString(out, options.columns)));
-			}
-		}
-		idx++;
-	}
-	return output.filter(Boolean).join("\n");
-}
-
-class BenchmarkReporter extends DefaultReporter {
-	compare;
-	async onInit(ctx) {
-		super.onInit(ctx);
-		if (this.ctx.config.benchmark?.compare) {
-			const compareFile = pathe.resolve(this.ctx.config.root, this.ctx.config.benchmark?.compare);
-			try {
-				this.compare = flattenFormattedBenchmarkReport(JSON.parse(await fs__default.promises.readFile(compareFile, "utf-8")));
-			} catch (e) {
-				this.error(`Failed to read '${compareFile}'`, e);
-			}
-		}
-	}
-	onTaskUpdate(packs) {
-		for (const pack of packs) {
-			const task = this.ctx.state.idMap.get(pack[0]);
-			if (task?.type === "suite" && task.result?.state !== "run") task.tasks.filter((task) => task.result?.benchmark).sort((benchA, benchB) => benchA.result.benchmark.mean - benchB.result.benchmark.mean).forEach((bench, idx) => {
-				bench.result.benchmark.rank = Number(idx) + 1;
-			});
-		}
-	}
-	onTestSuiteResult(testSuite) {
-		super.onTestSuiteResult(testSuite);
-		this.printSuiteTable(testSuite);
-	}
-	printTestModule(testModule) {
-		this.printSuiteTable(testModule);
-	}
-	printSuiteTable(testTask) {
-		const state = testTask.state();
-		if (state === "pending" || state === "queued") return;
-		const benches = testTask.task.tasks.filter((t) => t.meta.benchmark);
-		const duration = testTask.task.result?.duration || 0;
-		if (benches.length > 0 && benches.every((t) => t.result?.state !== "run" && t.result?.state !== "queued")) {
-			let title = `\n ${getStateSymbol(testTask.task)} ${formatProjectName(testTask.project)}${getFullName(testTask.task, separator)}`;
-			if (duration != null && duration > this.ctx.config.slowTestThreshold) title += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
-			this.log(title);
-			this.log(renderTable({
-				tasks: benches,
-				level: 1,
-				columns: this.ctx.logger.getColumns(),
-				compare: this.compare,
-				showHeap: this.ctx.config.logHeapUsage,
-				slowTestThreshold: this.ctx.config.slowTestThreshold
-			}));
-		}
-	}
-	async onTestRunEnd(testModules, unhandledErrors, reason) {
-		super.onTestRunEnd(testModules, unhandledErrors, reason);
-		// write output for future comparison
-		let outputFile = this.ctx.config.benchmark?.outputJson;
-		if (outputFile) {
-			outputFile = pathe.resolve(this.ctx.config.root, outputFile);
-			const outputDirectory = pathe.dirname(outputFile);
-			if (!fs__default.existsSync(outputDirectory)) await fs__default.promises.mkdir(outputDirectory, { recursive: true });
-			const output = createBenchmarkJsonReport(testModules.map((t) => t.task.file));
-			await fs__default.promises.writeFile(outputFile, JSON.stringify(output, null, 2));
-			this.log(`Benchmark report written to ${outputFile}`);
-		}
-	}
-}
-
-class VerboseBenchmarkReporter extends BenchmarkReporter {
-	verbose = true;
-}
-
-const BenchmarkReportsMap = {
-	default: BenchmarkReporter,
-	verbose: VerboseBenchmarkReporter
-};
-
 const ReportersMap = {
 	"default": DefaultReporter,
 	"agent": MinimalReporter,
@@ -16809,16 +16770,6 @@ function createReporters(reporterReferences, ctx) {
 	});
 	return Promise.all(promisedReporters);
 }
-function createBenchmarkReporters(reporterReferences, runner) {
-	const promisedReporters = reporterReferences.map(async (referenceOrInstance) => {
-		if (typeof referenceOrInstance === "string") if (referenceOrInstance in BenchmarkReportsMap) {
-			const BuiltinReporter = BenchmarkReportsMap[referenceOrInstance];
-			return new BuiltinReporter();
-		} else return new (await (loadCustomReporterModule(referenceOrInstance, runner)))();
-		return referenceOrInstance;
-	});
-	return Promise.all(promisedReporters);
-}
 
 function parseFilter(filter) {
 	const colonIndex = filter.lastIndexOf(":");
@@ -16994,6 +16945,12 @@ class ReportedTaskImplementation {
 		return this.task.meta;
 	}
 	/**
+	* Console logs recorded during the test execution.
+	*/
+	logs() {
+		return [...this.task.logs || []];
+	}
+	/**
 	* Creates a new reported task instance and stores it in the project's state for future use.
 	* @internal
 	*/
@@ -17094,6 +17051,14 @@ class TestCase extends ReportedTaskImplementation {
 		return [...this.task.artifacts];
 	}
 	/**
+	* @experimental
+	*
+	* A list of benchmarks performed during the test.
+	*/
+	benchmarks() {
+		return [...this.task.benchmarks];
+	}
+	/**
 	* Useful information about the test like duration, memory usage, etc.
 	* Diagnostic is only available after the test has finished.
 	*/
@@ -17998,21 +17963,23 @@ class TestRun {
 		this.vitest.state.updateUserLog(log);
 		await this.vitest.report("onUserConsoleLog", log);
 	}
+	async recordBenchmark(testId, benchmark) {
+		const testCase = this.getTestCaseById(testId, "Benchmark");
+		testCase.task.benchmarks.push(benchmark);
+		await this.vitest.report("onTestCaseBenchmark", testCase, benchmark);
+	}
 	async recordArtifact(testId, artifact) {
-		const task = this.vitest.state.idMap.get(testId);
-		const entity = task && this.vitest.state.getReportedEntity(task);
-		assert$1(task && entity, `Entity must be found for task ${task?.name || testId}`);
-		assert$1(entity.type === "test", `Artifacts can only be recorded on a test, instead got ${entity.type}`);
+		const testCase = this.getTestCaseById(testId, "Artifact");
 		// annotations won't resolve as artifacts for backwards compatibility until next major
 		if (artifact.type === "internal:annotation") {
-			await this.resolveTestAttachment(entity, artifact.annotation.attachment, artifact.annotation.message);
-			entity.task.annotations.push(artifact.annotation);
-			await this.vitest.report("onTestCaseAnnotate", entity, artifact.annotation);
+			await this.resolveTestAttachment(testCase, artifact.annotation.attachment, artifact.annotation.message);
+			testCase.task.annotations.push(artifact.annotation);
+			await this.vitest.report("onTestCaseAnnotate", testCase, artifact.annotation);
 			return artifact;
 		}
-		if (Array.isArray(artifact.attachments)) await Promise.all(artifact.attachments.map((attachment) => this.resolveTestAttachment(entity, attachment)));
-		entity.task.artifacts.push(artifact);
-		await this.vitest.report("onTestCaseArtifactRecord", entity, artifact);
+		if (Array.isArray(artifact.attachments)) await Promise.all(artifact.attachments.map((attachment) => this.resolveTestAttachment(testCase, attachment)));
+		testCase.task.artifacts.push(artifact);
+		await this.vitest.report("onTestCaseArtifactRecord", testCase, artifact);
 		return artifact;
 	}
 	async updated(update, events) {
@@ -18026,6 +17993,13 @@ class TestRun {
 		// TODO: error handling - what happens if custom reporter throws an error?
 		await this.vitest.report("onTaskUpdate", update, events);
 	}
+	getTestCaseById(testId, recordType) {
+		const task = this.vitest.state.idMap.get(testId);
+		const entity = task && this.vitest.state.getReportedEntity(task);
+		assert$1(task && entity, `Entity must be found for task ${task?.name || testId}`);
+		assert$1(entity.type === "test", `${recordType} can only be recorded on a test, instead got ${entity.type}`);
+		return entity;
+	}
 	async end(specifications, errors, coverage) {
 		if (coverage) await this.vitest.report("onCoverage", coverage);
 		// specification won't have the File task if they were filtered by the --shard command
@@ -18390,7 +18364,7 @@ class Vitest {
 	* The logger instance used to log messages. It's recommended to use this logger instead of `console`.
 	* It's possible to override stdout and stderr streams when initiating Vitest.
 	* @example
-	* new Vitest('test', {
+	* new Vitest({
 	*   stdout: new Writable(),
 	* })
 	*/
@@ -18452,8 +18426,20 @@ class Vitest {
 	_cache;
 	_snapshot;
 	_coverageProvider;
-	constructor(mode, cliOptions, options = {}) {
-		this.mode = mode;
+	/**
+	* @deprecated Do not rely on this property, it's always `test`. Scheduled to be removed in the next major.
+	*/
+	mode = "test";
+	constructor(modeOrCliOptions, cliOptionsOrOptions, maybeOptions) {
+		let cliOptions;
+		let options;
+		if (typeof modeOrCliOptions === "string") {
+			cliOptions = cliOptionsOrOptions;
+			options = maybeOptions ?? {};
+		} else {
+			cliOptions = modeOrCliOptions;
+			options = cliOptionsOrOptions ?? {};
+		}
 		this._cliOptions = cliOptions;
 		this.logger = new Logger(this, options.stdout, options.stderr);
 		this.packageInstaller = options.packageInstaller || new VitestPackageInstaller();
@@ -18571,9 +18557,9 @@ class Vitest {
 		try {
 			await this.cache.results.readFromCache();
 		} catch {}
-		const projects = await this.resolveProjects(this._cliOptions);
-		this.projects = projects;
-		await Promise.all(projects.flatMap((project) => {
+		this.projects = await this.resolveProjects(this._cliOptions);
+		if (this._cliOptions.benchmarkOnly) this.projects = this.projects.filter((c) => c.config.benchmark.enabled);
+		await Promise.all(this.projects.flatMap((project) => {
 			return project.vite.config.getSortedPluginHooks("configureVitest").map((hook) => hook({
 				project,
 				vitest: this,
@@ -18598,7 +18584,7 @@ class Vitest {
 		// populate will merge all configs into every project,
 		// we don't want that when just listing tags
 		if (!this.config.listTags) populateProjectsTags(this.coreWorkspaceProject, this.projects);
-		this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this);
+		this.reporters = await createReporters(resolved.reporters, this);
 		await this._fsCache.ensureCacheIntegrity();
 		await Promise.all([...this._onSetServer.map((fn) => fn()), this._traces.waitInit()]);
 	}
@@ -18725,7 +18711,7 @@ class Vitest {
 		// returns the project only if it matches the filter
 		const project = getDefaultTestProject(this);
 		if (!project) return [];
-		return resolveBrowserProjects(this, new Set([project.name]), [project]);
+		return resolveDefaultProjects(this, new Set([project.name]), [project]);
 	}
 	/**
 	* Glob test files in every project and create a TestSpecification for each file and pool.
@@ -18767,7 +18753,7 @@ class Vitest {
 			await this.report("onInit", this);
 			const specifications = [];
 			for (const file of files) {
-				const specification = this.getProjectByName(file.projectName || "").createSpecification(file.filepath, void 0, file.pool, file.meta);
+				const specification = this.getProjectByName(file.projectName || "").createSpecification(file.filepath, void 0, file.pool, file.id);
 				specifications.push(specification);
 			}
 			await this._testRun.start(specifications);
@@ -18891,7 +18877,7 @@ class Vitest {
 					// Report coverage for uncovered files
 					await this.reportCoverage(coverage, true);
 				});
-				if (!this.config.watch || !(this.config.changed || this.config.related?.length)) throw new FilesNotFoundError(this.mode);
+				if (!this.config.watch || !(this.config.changed || this.config.related?.length)) throw new FilesNotFoundError();
 			}
 			let testModules = {
 				testModules: [],
@@ -19075,7 +19061,6 @@ class Vitest {
 		}));
 	}
 	async experimental_parseSpecifications(specifications, options) {
-		if (this.mode !== "test") throw new Error(`The \`experimental_parseSpecifications\` does not support "${this.mode}" mode.`);
 		const limit = limitConcurrency(options?.concurrency ?? (typeof nodeos__default.availableParallelism === "function" ? nodeos__default.availableParallelism() : nodeos__default.cpus().length));
 		// Phase 1: parse all files in parallel (without mode interpretation)
 		const results = await Promise.all(specifications.map((specification) => limit(async () => {
@@ -19097,7 +19082,6 @@ class Vitest {
 		return results.map(({ file }) => this.state.getReportedEntity(file));
 	}
 	async experimental_parseSpecification(specification) {
-		if (this.mode !== "test") throw new Error(`The \`experimental_parseSpecification\` does not support "${this.mode}" mode.`);
 		const file = await astCollectTests(specification.project, specification.moduleId).catch((error) => {
 			return createFailedFileTask(specification.project, specification.moduleId, error);
 		});
@@ -19493,7 +19477,7 @@ function assert(condition, property, name = property) {
 	if (!condition) throw new Error(`The ${name} was not set. It means that \`vitest.${property}\` was called before the Vite server was established. Await the Vitest promise before accessing \`vitest.${property}\`.`);
 }
 
-async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(options))) {
+async function VitestPlugin(options = {}, vitest = new Vitest(deepClone(options))) {
 	const userConfig = deepMerge({}, options);
 	async function UIPlugin() {
 		await vitest.packageInstaller.ensureInstalled("@vitest/ui", resolve$1(options.root || process.cwd()), vitest.version);
@@ -19566,6 +19550,10 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 						legalComments: "inline"
 					}
 				};
+				if (vitest._cliOptions.benchmarkOnly) {
+					config.test.benchmark ??= {};
+					config.test.benchmark.enabled = true;
+				}
 				// inherit so it's available in VitestOptimizer
 				// I cannot wait to rewrite all of this in Vitest 4
 				if (options.cache != null) config.test.cache = options.cache;
@@ -19635,8 +19623,20 @@ async function VitestPlugin(options = {}, vitest = new Vitest("test", deepClone(
 	].filter(notNullish);
 }
 
-async function createVitest(mode, options, viteOverrides = {}, vitestOptions = {}) {
-	const ctx = new Vitest(mode, deepClone(options), vitestOptions);
+async function createVitest(modeOrOptions, optionsOrViteOverrides = {}, viteOverridesOrVitestOptions = {}, maybeVitestOptions = {}) {
+	let options;
+	let viteOverrides;
+	let vitestOptions;
+	if (typeof modeOrOptions === "string") {
+		options = optionsOrViteOverrides;
+		viteOverrides = viteOverridesOrVitestOptions;
+		vitestOptions = maybeVitestOptions;
+	} else {
+		options = modeOrOptions;
+		viteOverrides = optionsOrViteOverrides;
+		vitestOptions = viteOverridesOrVitestOptions;
+	}
+	const ctx = new Vitest(deepClone(options), vitestOptions);
 	const root = slash(resolve$2(options.root || process.cwd()));
 	const configPath = options.config === false ? false : options.config ? resolveModule(options.config, { paths: [root] }) ?? resolve$2(root, options.config) : any(configFiles, { cwd: root });
 	options.config = configPath;
@@ -19644,7 +19644,7 @@ async function createVitest(mode, options, viteOverrides = {}, vitestOptions = {
 	const config = {
 		configFile: configPath,
 		configLoader: options.configLoader,
-		mode: options.mode || mode,
+		mode: options.mode || "test",
 		plugins: await VitestPlugin(restOptions, ctx)
 	};
 	try {
@@ -19951,15 +19951,25 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 	};
 }
 
-/**
-* Start Vitest programmatically
-*
-* Returns a Vitest instance if initialized successfully.
-*/
-async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, vitestOptions) {
+async function startVitest(modeOrCliFilters, cliFiltersOrOptions, optionsOrViteOverrides, viteOverridesOrVitestOptions, maybeVitestOptions) {
+	let cliFilters;
+	let options;
+	let viteOverrides;
+	let vitestOptions;
+	if (typeof modeOrCliFilters === "string") {
+		cliFilters = cliFiltersOrOptions ?? [];
+		options = optionsOrViteOverrides ?? {};
+		viteOverrides = viteOverridesOrVitestOptions;
+		vitestOptions = maybeVitestOptions;
+	} else {
+		cliFilters = modeOrCliFilters ?? [];
+		options = cliFiltersOrOptions ?? {};
+		viteOverrides = optionsOrViteOverrides;
+		vitestOptions = viteOverridesOrVitestOptions;
+	}
 	const root = resolve$1(options.root || process.cwd());
-	const ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions, cliFilters);
-	if (mode === "test" && ctx._coverageOptions.enabled) {
+	const ctx = await prepareVitest(options, viteOverrides, vitestOptions, cliFilters);
+	if (ctx._coverageOptions.enabled) {
 		const requiredPackages = CoverageProviderMap[ctx._coverageOptions.provider || "v8"];
 		if (requiredPackages) {
 			if (!await ctx.packageInstaller.ensureInstalled(requiredPackages, root, ctx.version)) {
@@ -20007,7 +20017,22 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
 		}
 	}
 }
-async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions, cliFilters) {
+async function prepareVitest(modeOrOptions, optionsOrViteOverrides, viteOverridesOrVitestOptions, vitestOptionsOrCliFilters, maybeCliFilters) {
+	let options;
+	let viteOverrides;
+	let vitestOptions;
+	let cliFilters;
+	if (typeof modeOrOptions === "string") {
+		options = optionsOrViteOverrides ?? {};
+		viteOverrides = viteOverridesOrVitestOptions;
+		vitestOptions = vitestOptionsOrCliFilters;
+		cliFilters = maybeCliFilters;
+	} else {
+		options = modeOrOptions ?? {};
+		viteOverrides = optionsOrViteOverrides;
+		vitestOptions = viteOverridesOrVitestOptions;
+		cliFilters = vitestOptionsOrCliFilters;
+	}
 	process.env.TEST = "true";
 	process.env.VITEST = "true";
 	process.env.NODE_ENV ??= "test";
@@ -20015,7 +20040,7 @@ async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions, c
 	if (options.standalone && (cliFilters?.length || 0) > 0) options.standalone = false;
 	// this shouldn't affect _application root_ that can be changed inside config
 	const root = resolve$1(options.root || process.cwd());
-	const ctx = await createVitest(mode, options, viteOverrides, vitestOptions);
+	const ctx = await createVitest(options, viteOverrides, vitestOptions);
 	const environmentPackage = getEnvPackageName(ctx.config.environment);
 	if (environmentPackage && !await ctx.packageInstaller.ensureInstalled(environmentPackage, root)) {
 		process.exitCode = 1;
@@ -20124,4 +20149,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { registerConsoleShortcuts as A, BaseCoverageProvider as B, resolveApiServerConfig as C, DefaultReporter as D, resolveFsAllow as E, ForksPoolWorker as F, GitNotFoundError as G, HangingProcessReporter as H, startVitest as I, JUnitReporter as J, cliApi as K, MinimalReporter as M, ReportersMap as R, TapFlatReporter as T, Vitest as V, VitestPlugin as a, BaseSequencer as b, BenchmarkReporter as c, BenchmarkReportsMap as d, DotReporter as e, GithubActionsReporter as f, JsonReporter as g, TapReporter as h, FilesNotFoundError as i, ThreadsPoolWorker as j, TypecheckPoolWorker as k, VerboseBenchmarkReporter as l, VerboseReporter as m, VitestPackageInstaller as n, VmForksPoolWorker as o, VmThreadsPoolWorker as p, createDebugger as q, resolveConfig$1 as r, createMethodsRPC as s, createViteLogger as t, createVitest as u, escapeTestName as v, experimental_getRunnerTask as w, getFilePoolName as x, isFileServingAllowed as y, isValidApiRequest as z };
+export { startVitest as A, BaseCoverageProvider as B, cliApi as C, DefaultReporter as D, ForksPoolWorker as F, GitNotFoundError as G, HangingProcessReporter as H, JUnitReporter as J, MinimalReporter as M, ReportersMap as R, TapFlatReporter as T, Vitest as V, VitestPlugin as a, BaseSequencer as b, DotReporter as c, GithubActionsReporter as d, JsonReporter as e, TapReporter as f, FilesNotFoundError as g, ThreadsPoolWorker as h, TypecheckPoolWorker as i, VerboseReporter as j, VitestPackageInstaller as k, VmForksPoolWorker as l, VmThreadsPoolWorker as m, createDebugger as n, createMethodsRPC as o, createViteLogger as p, createVitest as q, resolveConfig$1 as r, escapeTestName as s, experimental_getRunnerTask as t, getFilePoolName as u, isFileServingAllowed as v, isValidApiRequest as w, registerConsoleShortcuts as x, resolveApiServerConfig as y, resolveFsAllow as z };