vitest 4.0.6 → 4.0.8

package/dist/chunks/{index.BL8Hg4Uk.js → index.kotH7DY7.js}

@@ -4,7 +4,7 @@ import { resolve as resolve$1, dirname, isAbsolute, relative, basename, join, no
 import { performance as performance$1 } from 'node:perf_hooks';
 import { getTests, getTestName, hasFailed, getSuites, generateHash, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, getTasks, getFullName } from '@vitest/runner/utils';
 import { slash, toArray, isPrimitive } from '@vitest/utils/helpers';
-import { parseStacktrace, parseErrorStacktrace, defaultStackIgnorePatterns } from '@vitest/utils/source-map';
+import { parseStacktrace, defaultStackIgnorePatterns, parseErrorStacktrace } from '@vitest/utils/source-map';
 import c from 'tinyrainbow';
 import { i as isTTY } from './env.D4Lgay0q.js';
 import { stripVTControlCharacters } from 'node:util';
@@ -126,10 +126,14 @@ const stringify = (value, replacer, space) => {
 };
 
 function getOutputFile(config, reporter) {
-	if (config?.outputFile) return typeof config.outputFile === "string" ? config.outputFile : config.outputFile[reporter];
+	if (!config?.outputFile) return;
+	if (typeof config.outputFile === "string") return config.outputFile;
+	return config.outputFile[reporter];
 }
 function createDefinesScript(define) {
-	return !define || serializeDefine(define) === "{}" ? "" : `
+	if (!define) return "";
+	if (serializeDefine(define) === "{}") return "";
+	return `
 const defines = ${serializeDefine(define)}
 Object.keys(defines).forEach((key) => {
   const segments = key.split('.')
@@ -161,13 +165,17 @@ function serializeDefine(define) {
 	let res = `{`;
 	const keys = Object.keys(userDefine).sort();
 	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i], val = userDefine[key];
-		if (res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`, i !== keys.length - 1) res += `, `;
+		const key = keys[i];
+		const val = userDefine[key];
+		res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`;
+		if (i !== keys.length - 1) res += `, `;
 	}
 	return `${res}}`;
 }
 function handleDefineValue(value) {
-	return typeof value === "undefined" ? "undefined" : typeof value === "string" ? value : JSON.stringify(value);
+	if (typeof value === "undefined") return "undefined";
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
 }
 
 class BlobReporter {
@@ -180,13 +188,18 @@ class BlobReporter {
 	}
 	onInit(ctx) {
 		if (ctx.config.watch) throw new Error("Blob reporter is not supported in watch mode");
-		this.ctx = ctx, this.start = performance.now(), this.coverage = void 0;
+		this.ctx = ctx;
+		this.start = performance.now();
+		this.coverage = void 0;
 	}
 	onCoverage(coverage) {
 		this.coverage = coverage;
 	}
 	async onTestRunEnd(testModules, unhandledErrors) {
-		const executionTime = performance.now() - this.start, files = testModules.map((testModule) => testModule.task), errors = [...unhandledErrors], coverage = this.coverage;
+		const executionTime = performance.now() - this.start;
+		const files = testModules.map((testModule) => testModule.task);
+		const errors = [...unhandledErrors];
+		const coverage = this.coverage;
 		let outputFile = this.options.outputFile ?? getOutputFile(this.ctx.config, "blob");
 		if (!outputFile) {
 			const shard = this.ctx.config.shard;
@@ -194,34 +207,40 @@ class BlobReporter {
 		}
 		const modules = this.ctx.projects.map((project) => {
 			return [project.name, [...project.vite.moduleGraph.idToModuleMap.entries()].map((mod) => {
-				return mod[1].file ? [
+				if (!mod[1].file) return null;
+				return [
 					mod[0],
 					mod[1].file,
 					mod[1].url
-				] : null;
+				];
 			}).filter((x) => x != null)];
-		}), report = [
+		});
+		const report = [
 			this.ctx.version,
 			files,
 			errors,
 			modules,
 			coverage,
 			executionTime
-		], reportFile = resolve$1(this.ctx.config.root, outputFile);
-		await writeBlob(report, reportFile), this.ctx.logger.log("blob report written to", reportFile);
+		];
+		const reportFile = resolve$1(this.ctx.config.root, outputFile);
+		await writeBlob(report, reportFile);
+		this.ctx.logger.log("blob report written to", reportFile);
 	}
 }
 async function writeBlob(content, filename) {
-	const report = stringify(content), dir = dirname(filename);
+	const report = stringify(content);
+	const dir = dirname(filename);
 	if (!existsSync(dir)) await mkdir(dir, { recursive: true });
 	await writeFile(filename, report, "utf-8");
 }
 async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
 	// using process.cwd() because --merge-reports can only be used in CLI
-	const resolvedDir = resolve$1(process.cwd(), blobsDirectory), promises = (await readdir(resolvedDir)).map(async (filename) => {
+	const resolvedDir = resolve$1(process.cwd(), blobsDirectory);
+	const promises = (await readdir(resolvedDir)).map(async (filename) => {
 		const fullPath = resolve$1(resolvedDir, filename);
 		if (!(await stat(fullPath)).isFile()) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
-		const content = await readFile(fullPath, "utf-8"), [version, files, errors, moduleKeys, coverage, executionTime] = parse$1(content);
+		const [version, files, errors, moduleKeys, coverage, executionTime] = parse$1(await readFile(fullPath, "utf-8"));
 		if (!version) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a valid blob file`);
 		return {
 			version,
@@ -232,7 +251,8 @@ async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
 			file: filename,
 			executionTime
 		};
-	}), blobs = await Promise.all(promises);
+	});
+	const blobs = await Promise.all(promises);
 	if (!blobs.length) throw new Error(`vitest.mergeReports() requires at least one blob file in "${blobsDirectory}" directory, but none were found`);
 	const versions = new Set(blobs.map((blob) => blob.version));
 	if (versions.size > 1) throw new Error(`vitest.mergeReports() requires all blob files to be generated by the same Vitest version, received\n\n${blobs.map((b) => `- "${b.file}" uses v${b.version}`).join("\n")}`);
@@ -242,24 +262,26 @@ async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
 	blobs.forEach((blob) => {
 		blob.moduleKeys.forEach(([projectName, moduleIds]) => {
 			const project = projects[projectName];
-			project && moduleIds.forEach(([moduleId, file, url]) => {
+			if (!project) return;
+			moduleIds.forEach(([moduleId, file, url]) => {
 				const moduleNode = project.vite.moduleGraph.createFileOnlyEntry(file);
-				moduleNode.url = url, moduleNode.id = moduleId, moduleNode.transformResult = {
+				moduleNode.url = url;
+				moduleNode.id = moduleId;
+				moduleNode.transformResult = {
 					code: " ",
 					map: null
-				}, project.vite.moduleGraph.idToModuleMap.set(moduleId, moduleNode);
+				};
+				project.vite.moduleGraph.idToModuleMap.set(moduleId, moduleNode);
 			});
 		});
 	});
-	const files = blobs.flatMap((blob) => blob.files).sort((f1, f2) => {
-		const time1 = f1.result?.startTime || 0, time2 = f2.result?.startTime || 0;
-		return time1 - time2;
-	}), errors = blobs.flatMap((blob) => blob.errors), coverages = blobs.map((blob) => blob.coverage), executionTimes = blobs.map((blob) => blob.executionTime);
 	return {
-		files,
-		errors,
-		coverages,
-		executionTimes
+		files: blobs.flatMap((blob) => blob.files).sort((f1, f2) => {
+			return (f1.result?.startTime || 0) - (f2.result?.startTime || 0);
+		}),
+		errors: blobs.flatMap((blob) => blob.errors),
+		coverages: blobs.map((blob) => blob.coverage),
+		executionTimes: blobs.map((blob) => blob.executionTime)
 	};
 }
 
@@ -269,44 +291,58 @@ function hasFailedSnapshot(suite) {
 	});
 }
 function convertTasksToEvents(file, onTask) {
-	const packs = [], events = [];
+	const packs = [];
+	const events = [];
 	function visit(suite) {
-		onTask?.(suite), packs.push([
+		onTask?.(suite);
+		packs.push([
 			suite.id,
 			suite.result,
 			suite.meta
-		]), events.push([
+		]);
+		events.push([
 			suite.id,
 			"suite-prepare",
 			void 0
-		]), suite.tasks.forEach((task) => {
+		]);
+		suite.tasks.forEach((task) => {
 			if (task.type === "suite") visit(task);
-			else if (onTask?.(task), suite.mode !== "skip" && suite.mode !== "todo") packs.push([
-				task.id,
-				task.result,
-				task.meta
-			]), events.push([
-				task.id,
-				"test-prepare",
-				void 0
-			]), task.annotations.forEach((annotation) => {
-				events.push([
-					task.id,
-					"test-annotation",
-					{ annotation }
-				]);
-			}), events.push([
-				task.id,
-				"test-finished",
-				void 0
-			]);
-		}), events.push([
+			else {
+				onTask?.(task);
+				if (suite.mode !== "skip" && suite.mode !== "todo") {
+					packs.push([
+						task.id,
+						task.result,
+						task.meta
+					]);
+					events.push([
+						task.id,
+						"test-prepare",
+						void 0
+					]);
+					task.annotations.forEach((annotation) => {
+						events.push([
+							task.id,
+							"test-annotation",
+							{ annotation }
+						]);
+					});
+					events.push([
+						task.id,
+						"test-finished",
+						void 0
+					]);
+				}
+			}
+		});
+		events.push([
 			suite.id,
 			"suite-finished",
 			void 0
 		]);
 	}
-	return visit(file), {
+	visit(file);
+	return {
 		packs,
 		events
 	};
@@ -346,18 +382,26 @@ function errorBanner(message) {
 	return divider(c.bold(c.bgRed(` ${message} `)), null, null, c.red);
 }
 function divider(text, left, right, color) {
-	const cols = getCols(), c = color || ((text) => text);
+	const cols = getCols();
+	const c = color || ((text) => text);
 	if (text) {
 		const textLength = stripVTControlCharacters(text).length;
 		if (left == null && right != null) left = cols - textLength - right;
-		else left = left ?? Math.floor((cols - textLength) / 2), right = cols - textLength - left;
-		return left = Math.max(0, left), right = Math.max(0, right), `${c(F_LONG_DASH.repeat(left))}${text}${c(F_LONG_DASH.repeat(right))}`;
+		else {
+			left = left ?? Math.floor((cols - textLength) / 2);
+			right = cols - textLength - left;
+		}
+		left = Math.max(0, left);
+		right = Math.max(0, right);
+		return `${c(F_LONG_DASH.repeat(left))}${text}${c(F_LONG_DASH.repeat(right))}`;
 	}
 	return F_LONG_DASH.repeat(cols);
 }
 function formatTestPath(root, path) {
 	if (isAbsolute(path)) path = relative(root, path);
-	const dir = dirname(path), ext = path.match(/(\.(spec|test)\.[cm]?[tj]sx?)$/)?.[0] || "", base = basename(path, ext);
+	const dir = dirname(path);
+	const ext = path.match(/(\.(spec|test)\.[cm]?[tj]sx?)$/)?.[0] || "";
+	const base = basename(path, ext);
 	return slash(c.dim(`${dir}/`) + c.bold(base)) + c.dim(ext);
 }
 function renderSnapshotSummary(rootDir, snapshots) {
@@ -369,7 +413,8 @@ function renderSnapshotSummary(rootDir, snapshots) {
 	else summary.push(c.bold(c.yellow(`${snapshots.filesRemoved} files obsolete `)));
 	if (snapshots.filesRemovedList && snapshots.filesRemovedList.length) {
 		const [head, ...tail] = snapshots.filesRemovedList;
-		summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, head)}`), tail.forEach((key) => {
+		summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, head)}`);
+		tail.forEach((key) => {
 			summary.push(`  ${c.gray(F_DOT)} ${formatTestPath(rootDir, key)}`);
 		});
 	}
@@ -377,7 +422,8 @@ function renderSnapshotSummary(rootDir, snapshots) {
 		if (snapshots.didUpdate) summary.push(c.bold(c.green(`${snapshots.unchecked} removed`)));
 		else summary.push(c.bold(c.yellow(`${snapshots.unchecked} obsolete`)));
 		snapshots.uncheckedKeysByFile.forEach((uncheckedFile) => {
-			summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, uncheckedFile.filePath)}`), uncheckedFile.keys.forEach((key) => summary.push(`  ${c.gray(F_DOT)} ${key}`));
+			summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, uncheckedFile.filePath)}`);
+			uncheckedFile.keys.forEach((key) => summary.push(`  ${c.gray(F_DOT)} ${key}`));
 		});
 	}
 	return summary;
@@ -387,12 +433,15 @@ function countTestErrors(tasks) {
 }
 function getStateString$1(tasks, name = "tests", showTotal = true) {
 	if (tasks.length === 0) return c.dim(`no ${name}`);
-	const passed = tasks.filter((i) => i.result?.state === "pass"), failed = tasks.filter((i) => i.result?.state === "fail"), skipped = tasks.filter((i) => i.mode === "skip"), todo = tasks.filter((i) => i.mode === "todo");
+	const passed = tasks.reduce((acc, i) => i.result?.state === "pass" ? acc + 1 : acc, 0);
+	const failed = tasks.reduce((acc, i) => i.result?.state === "fail" ? acc + 1 : acc, 0);
+	const skipped = tasks.reduce((acc, i) => i.mode === "skip" ? acc + 1 : acc, 0);
+	const todo = tasks.reduce((acc, i) => i.mode === "todo" ? acc + 1 : acc, 0);
 	return [
-		failed.length ? c.bold(c.red(`${failed.length} failed`)) : null,
-		passed.length ? c.bold(c.green(`${passed.length} passed`)) : null,
-		skipped.length ? c.yellow(`${skipped.length} skipped`) : null,
-		todo.length ? c.gray(`${todo.length} todo`) : null
+		failed ? c.bold(c.red(`${failed} failed`)) : null,
+		passed ? c.bold(c.green(`${passed} passed`)) : null,
+		skipped ? c.yellow(`${skipped} skipped`) : null,
+		todo ? c.gray(`${todo} todo`) : null
 	].filter(Boolean).join(c.dim(" | ")) + (showTotal ? c.gray(` (${tasks.length})`) : "");
 }
 function getStateSymbol(task) {
@@ -401,22 +450,22 @@ function getStateSymbol(task) {
 	if (task.result.state === "run" || task.result.state === "queued") {
 		if (task.type === "suite") return pointer;
 	}
-	return task.result.state === "pass" ? task.meta?.benchmark ? benchmarkPass : testPass : task.result.state === "fail" ? task.type === "suite" ? suiteFail : taskFail : " ";
+	if (task.result.state === "pass") return task.meta?.benchmark ? benchmarkPass : testPass;
+	if (task.result.state === "fail") return task.type === "suite" ? suiteFail : taskFail;
+	return " ";
 }
 function formatTimeString(date) {
 	return date.toTimeString().split(" ")[0];
 }
 function formatTime(time) {
-	return time > 1e3 ? `${(time / 1e3).toFixed(2)}s` : `${Math.round(time)}ms`;
+	if (time > 1e3) return `${(time / 1e3).toFixed(2)}s`;
+	return `${Math.round(time)}ms`;
 }
 function formatProjectName(project, suffix = " ") {
 	if (!project?.name) return "";
 	if (!c.isColorSupported) return `|${project.name}|${suffix}`;
 	let background = project.color && c[`bg${capitalize(project.color)}`];
-	if (!background) {
-		const index = project.name.split("").reduce((acc, v, idx) => acc + v.charCodeAt(0) + idx, 0);
-		background = labelDefaultColors[index % labelDefaultColors.length];
-	}
+	if (!background) background = labelDefaultColors[project.name.split("").reduce((acc, v, idx) => acc + v.charCodeAt(0) + idx, 0) % labelDefaultColors.length];
 	return c.black(background(` ${project.name} `)) + suffix;
 }
 function withLabel(color, label, message) {
@@ -428,7 +477,8 @@ function padSummaryTitle(str) {
 }
 function truncateString(text, maxLength) {
 	const plainText = stripVTControlCharacters(text);
-	return plainText.length <= maxLength ? text : `${plainText.slice(0, maxLength - 1)}…`;
+	if (plainText.length <= maxLength) return text;
+	return `${plainText.slice(0, maxLength - 1)}…`;
 }
 function capitalize(text) {
 	return `${text[0].toUpperCase()}${text.slice(1)}`;
@@ -475,7 +525,9 @@ class BaseReporter {
 		this.isTTY = options.isTTY ?? isTTY;
 	}
 	onInit(ctx) {
-		this.ctx = ctx, this.ctx.logger.printBanner(), this.start = performance$1.now();
+		this.ctx = ctx;
+		this.ctx.logger.printBanner();
+		this.start = performance$1.now();
 	}
 	log(...messages) {
 		this.ctx.logger.log(...messages);
@@ -487,8 +539,10 @@ class BaseReporter {
 		return relative(this.ctx.config.root, path);
 	}
 	onTestRunEnd(testModules, unhandledErrors, _reason) {
-		const files = testModules.map((testModule) => testModule.task), errors = [...unhandledErrors];
-		if (this.end = performance$1.now(), !files.length && !errors.length) this.ctx.logger.printNoTestFound(this.ctx.filenamePattern);
+		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);
 	}
 	onTestCaseResult(testCase) {
@@ -507,10 +561,13 @@ class BaseReporter {
 	printTestModule(testModule) {
 		const moduleState = testModule.state();
 		if (moduleState === "queued" || moduleState === "pending") return;
-		let testsCount = 0, failedCount = 0, skippedCount = 0;
+		let testsCount = 0;
+		let failedCount = 0;
+		let skippedCount = 0;
 		// delaying logs to calculate the test stats first
 		// which minimizes the amount of for loops
-		const logs = [], originalLog = this.log.bind(this);
+		const logs = [];
+		const originalLog = this.log.bind(this);
 		this.log = (msg) => logs.push(msg);
 		const visit = (suiteState, children) => {
 			for (const child of children) if (child.type === "suite") {
@@ -520,7 +577,8 @@ class BaseReporter {
 				visit(suiteState, child.children);
 			} else {
 				const testResult = child.result();
-				if (testsCount++, testResult.state === "failed") failedCount++;
+				testsCount++;
+				if (testResult.state === "failed") failedCount++;
 				else if (testResult.state === "skipped") skippedCount++;
 				if (this.ctx.config.hideSkippedTests && suiteState === "skipped")
  // Skipped suites are hidden when --hideSkippedTests
@@ -537,10 +595,14 @@ class BaseReporter {
 			tests: testsCount,
 			failed: failedCount,
 			skipped: skippedCount
-		})), logs.forEach((log) => this.log(log));
+		}));
+		logs.forEach((log) => this.log(log));
 	}
 	printTestCase(moduleState, test) {
-		const testResult = test.result(), { duration = 0 } = test.diagnostic() || {}, padding = this.getTestIndentation(test.task), suffix = this.getTestCaseSuffix(test);
+		const testResult = test.result();
+		const { duration = 0 } = test.diagnostic() || {};
+		const padding = this.getTestIndentation(test.task);
+		const suffix = this.getTestCaseSuffix(test);
 		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") ; else if (this.renderSucceed || moduleState === "failed") this.log(` ${padding}${this.getStateSymbol(test)} ${this.getTestName(test.task, separator)}${suffix}`);
@@ -556,7 +618,9 @@ class BaseReporter {
 	}
 	printTestSuite(testSuite) {
 		if (!this.renderSucceed) return;
-		const indentation = "  ".repeat(getIndentation(testSuite.task)), tests = Array.from(testSuite.children.allTests()), state = this.getStateSymbol(testSuite);
+		const indentation = "  ".repeat(getIndentation(testSuite.task));
+		const tests = Array.from(testSuite.children.allTests());
+		const state = this.getStateSymbol(testSuite);
 		this.log(` ${indentation}${state} ${testSuite.name} ${c.dim(`(${tests.length})`)}`);
 	}
 	getTestName(test, _separator) {
@@ -566,7 +630,9 @@ class BaseReporter {
 		if (test === test.file) return test.name;
 		let name = test.file.name;
 		if (test.location) name += c.dim(`:${test.location.line}:${test.location.column}`);
-		return name += separator, name += getTestName(test, separator), name;
+		name += separator;
+		name += getTestName(test, separator);
+		return name;
 	}
 	getTestIndentation(test) {
 		return "  ".repeat(getIndentation(test));
@@ -574,18 +640,24 @@ class BaseReporter {
 	printAnnotations(test, console, padding = 0) {
 		const annotations = test.annotations();
 		if (!annotations.length) return;
-		const PADDING = " ".repeat(padding), groupedAnnotations = {};
-		for (const group in annotations.forEach((annotation) => {
+		const PADDING = " ".repeat(padding);
+		const groupedAnnotations = {};
+		annotations.forEach((annotation) => {
 			const { location, type } = annotation;
 			let group;
 			if (location) {
 				const file = relative(test.project.config.root, location.file);
 				group = `${c.gray(`${file}:${location.line}:${location.column}`)} ${c.bold(type)}`;
 			} else group = c.bold(type);
-			groupedAnnotations[group] ??= [], groupedAnnotations[group].push(annotation);
-		}), groupedAnnotations) this[console](`${PADDING}${c.blue(F_POINTER)} ${group}`), groupedAnnotations[group].forEach(({ message }) => {
-			this[console](`${PADDING}  ${c.blue(F_DOWN_RIGHT)} ${message}`);
+			groupedAnnotations[group] ??= [];
+			groupedAnnotations[group].push(annotation);
 		});
+		for (const group in groupedAnnotations) {
+			this[console](`${PADDING}${c.blue(F_POINTER)} ${group}`);
+			groupedAnnotations[group].forEach(({ message }) => {
+				this[console](`${PADDING}  ${c.blue(F_DOWN_RIGHT)} ${message}`);
+			});
+		}
 	}
 	getEntityPrefix(entity) {
 		let title = this.getStateSymbol(entity);
@@ -594,7 +666,8 @@ class BaseReporter {
 		return title;
 	}
 	getTestCaseSuffix(testCase) {
-		const { heap, retryCount, repeatCount } = testCase.diagnostic() || {}, testResult = testCase.result();
+		const { heap, retryCount, repeatCount } = testCase.diagnostic() || {};
+		const testResult = testCase.result();
 		let suffix = this.getDurationPrefix(testCase.task);
 		if (retryCount != null && retryCount > 0) suffix += c.yellow(` (retry x${retryCount})`);
 		if (repeatCount != null && repeatCount > 0) suffix += c.yellow(` (repeat x${repeatCount})`);
@@ -607,7 +680,8 @@ class BaseReporter {
 	}
 	getDurationPrefix(task) {
 		const duration = task.result?.duration && Math.round(task.result?.duration);
-		return duration == null ? "" : (duration > this.ctx.config.slowTestThreshold ? c.yellow : c.green)(` ${duration}${c.dim("ms")}`);
+		if (duration == null) return "";
+		return (duration > this.ctx.config.slowTestThreshold ? c.yellow : c.green)(` ${duration}${c.dim("ms")}`);
 	}
 	onWatcherStart(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
 		if (errors.length > 0 || hasFailed(files)) this.log(withLabel("red", "FAIL", "Tests failed. Watching for file changes..."));
@@ -619,8 +693,10 @@ class BaseReporter {
 		this.log(BADGE_PADDING + hints.join(c.dim(", ")));
 	}
 	onWatcherRerun(files, trigger) {
+		this.watchFilters = files;
+		this.failedUnwatchedFiles = this.ctx.state.getTestModules().filter((testModule) => !files.includes(testModule.task.filepath) && testModule.state() === "failed");
 		// Update re-run count for each file
-		this.watchFilters = files, this.failedUnwatchedFiles = this.ctx.state.getTestModules().filter((testModule) => !files.includes(testModule.task.filepath) && testModule.state() === "failed"), files.forEach((filepath) => {
+		files.forEach((filepath) => {
 			let reruns = this._filesInWatchMode.get(filepath) ?? 0;
 			this._filesInWatchMode.set(filepath, ++reruns);
 		});
@@ -629,26 +705,35 @@ class BaseReporter {
 			const rerun = this._filesInWatchMode.get(files[0]) ?? 1;
 			banner += c.blue(`x${rerun} `);
 		}
-		if (this.ctx.logger.clearFullScreen(), this.log(withLabel("blue", "RERUN", banner)), this.ctx.configOverride.project) this.log(BADGE_PADDING + c.dim(" Project name: ") + c.blue(toArray(this.ctx.configOverride.project).join(", ")));
+		this.ctx.logger.clearFullScreen();
+		this.log(withLabel("blue", "RERUN", banner));
+		if (this.ctx.configOverride.project) this.log(BADGE_PADDING + c.dim(" Project name: ") + c.blue(toArray(this.ctx.configOverride.project).join(", ")));
 		if (this.ctx.filenamePattern) this.log(BADGE_PADDING + c.dim(" Filename pattern: ") + c.blue(this.ctx.filenamePattern.join(", ")));
 		if (this.ctx.configOverride.testNamePattern) this.log(BADGE_PADDING + c.dim(" Test name pattern: ") + c.blue(String(this.ctx.configOverride.testNamePattern)));
 		this.log("");
 		for (const testModule of this.failedUnwatchedFiles) this.printTestModule(testModule);
-		this._timeStart = formatTimeString(/* @__PURE__ */ new Date()), this.start = performance$1.now();
+		this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
+		this.start = performance$1.now();
 	}
 	onUserConsoleLog(log, taskState) {
 		if (!this.shouldLog(log, taskState)) return;
-		const output = log.type === "stdout" ? this.ctx.logger.outputStream : this.ctx.logger.errorStream, write = (msg) => output.write(msg);
+		const output = log.type === "stdout" ? this.ctx.logger.outputStream : this.ctx.logger.errorStream;
+		const write = (msg) => output.write(msg);
 		let headerText = "unknown test";
 		const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0;
 		if (task) headerText = this.getFullName(task, separator);
 		else if (log.taskId && log.taskId !== "__vitest__unknown_test__") headerText = log.taskId;
-		if (write(c.gray(log.type + c.dim(` | ${headerText}\n`)) + log.content), log.origin) {
+		write(c.gray(log.type + c.dim(` | ${headerText}\n`)) + log.content);
+		if (log.origin) {
 			// browser logs don't have an extra end of line at the end like Node.js does
 			if (log.browser) write("\n");
-			const project = task ? this.ctx.getProjectByName(task.file.projectName || "") : this.ctx.getRootProject(), stack = log.browser ? project.browser?.parseStacktrace(log.origin) || [] : parseStacktrace(log.origin), highlight = task && stack.find((i) => i.file === task.file.filepath);
+			const project = task ? this.ctx.getProjectByName(task.file.projectName || "") : this.ctx.getRootProject();
+			const stack = log.browser ? project.browser?.parseStacktrace(log.origin) || [] : parseStacktrace(log.origin);
+			const highlight = task && stack.find((i) => i.file === task.file.filepath);
 			for (const frame of stack) {
-				const color = frame === highlight ? c.cyan : c.gray, path = relative(project.config.root, frame.file), positions = [frame.method, `${path}:${c.dim(`${frame.line}:${frame.column}`)}`].filter(Boolean).join(" ");
+				const color = frame === highlight ? c.cyan : c.gray;
+				const path = relative(project.config.root, frame.file);
+				const positions = [frame.method, `${path}:${c.dim(`${frame.line}:${frame.column}`)}`].filter(Boolean).join(" ");
 				write(color(` ${c.dim(F_POINTER)} ${positions}\n`));
 			}
 		}
@@ -658,9 +743,11 @@ class BaseReporter {
 		this.log(c.yellow("Test removed...") + (trigger ? c.dim(` [ ${this.relative(trigger)} ]\n`) : ""));
 	}
 	shouldLog(log, taskState) {
-		if (this.ctx.config.silent === true || this.ctx.config.silent === "passed-only" && taskState !== "failed") return false;
+		if (this.ctx.config.silent === true) return false;
+		if (this.ctx.config.silent === "passed-only" && taskState !== "failed") return false;
 		if (this.ctx.config.onConsoleLog) {
-			const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0, entity = task && this.ctx.state.getReportedEntity(task);
+			const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0;
+			const entity = task && this.ctx.state.getReportedEntity(task);
 			if (this.ctx.config.onConsoleLog(log.content, log.type, entity) === false) return false;
 		}
 		return true;
@@ -669,27 +756,41 @@ class BaseReporter {
 		this.log(c.bold(c.magenta(reason === "config" ? "\nRestarting due to config changes..." : "\nRestarting Vitest...")));
 	}
 	reportSummary(files, errors) {
-		if (this.printErrorsSummary(files, errors), this.ctx.config.mode === "benchmark") this.reportBenchmarkSummary(files);
+		this.printErrorsSummary(files, errors);
+		if (this.ctx.config.mode === "benchmark") this.reportBenchmarkSummary(files);
 		else this.reportTestSummary(files, errors);
 	}
 	reportTestSummary(files, errors) {
 		this.log();
-		const affectedFiles = [...this.failedUnwatchedFiles.map((m) => m.task), ...files], tests = getTests(affectedFiles), snapshotOutput = renderSnapshotSummary(this.ctx.config.root, this.ctx.snapshot.summary);
+		const affectedFiles = [...this.failedUnwatchedFiles.map((m) => m.task), ...files];
+		const tests = getTests(affectedFiles);
+		const snapshotOutput = renderSnapshotSummary(this.ctx.config.root, this.ctx.snapshot.summary);
 		for (const [index, snapshot] of snapshotOutput.entries()) {
 			const title = index === 0 ? "Snapshots" : "";
 			this.log(`${padSummaryTitle(title)} ${snapshot}`);
 		}
 		if (snapshotOutput.length > 1) this.log();
-		if (this.log(padSummaryTitle("Test Files"), getStateString$1(affectedFiles)), this.log(padSummaryTitle("Tests"), getStateString$1(tests)), this.ctx.projects.some((c) => c.config.typecheck.enabled)) {
+		this.log(padSummaryTitle("Test Files"), getStateString$1(affectedFiles));
+		this.log(padSummaryTitle("Tests"), getStateString$1(tests));
+		if (this.ctx.projects.some((c) => c.config.typecheck.enabled)) {
 			const failed = tests.filter((t) => t.meta?.typecheck && t.result?.errors?.length);
 			this.log(padSummaryTitle("Type Errors"), failed.length ? c.bold(c.red(`${failed.length} failed`)) : c.dim("no errors"));
 		}
 		if (errors.length) this.log(padSummaryTitle("Errors"), c.bold(c.red(`${errors.length} error${errors.length > 1 ? "s" : ""}`)));
 		this.log(padSummaryTitle("Start at"), this._timeStart);
-		const collectTime = sum(files, (file) => file.collectDuration), testsTime = sum(files, (file) => file.result?.duration), setupTime = sum(files, (file) => file.setupDuration);
+		const collectTime = sum(files, (file) => file.collectDuration);
+		const testsTime = sum(files, (file) => file.result?.duration);
+		const setupTime = sum(files, (file) => file.setupDuration);
 		if (this.watchFilters) this.log(padSummaryTitle("Duration"), formatTime(collectTime + testsTime + setupTime));
 		else {
-			const blobs = this.ctx.state.blobs, executionTime = blobs?.executionTimes ? sum(blobs.executionTimes, (time) => time) : this.end - this.start, environmentTime = sum(files, (file) => file.environmentLoad), prepareTime = sum(files, (file) => file.prepareDuration), transformTime = this.ctx.state.transformTime, typecheck = sum(this.ctx.projects, (project) => project.typechecker?.getResult().time), timers = [
+			const blobs = this.ctx.state.blobs;
+			// Execution time is either sum of all runs of `--merge-reports` or the current run's time
+			const executionTime = blobs?.executionTimes ? sum(blobs.executionTimes, (time) => time) : this.end - this.start;
+			const environmentTime = sum(files, (file) => file.environmentLoad);
+			const prepareTime = sum(files, (file) => file.prepareDuration);
+			const transformTime = this.ctx.state.transformTime;
+			const typecheck = sum(this.ctx.projects, (project) => project.typechecker?.getResult().time);
+			const timers = [
 				`transform ${formatTime(transformTime)}`,
 				`setup ${formatTime(setupTime)}`,
 				`collect ${formatTime(collectTime)}`,
@@ -698,18 +799,32 @@ class BaseReporter {
 				`prepare ${formatTime(prepareTime)}`,
 				typecheck && `typecheck ${formatTime(typecheck)}`
 			].filter(Boolean).join(", ");
-			if (this.log(padSummaryTitle("Duration"), formatTime(executionTime) + c.dim(` (${timers})`)), blobs?.executionTimes) this.log(padSummaryTitle("Per blob") + blobs.executionTimes.map((time) => ` ${formatTime(time)}`).join(""));
+			this.log(padSummaryTitle("Duration"), formatTime(executionTime) + c.dim(` (${timers})`));
+			if (blobs?.executionTimes) this.log(padSummaryTitle("Per blob") + blobs.executionTimes.map((time) => ` ${formatTime(time)}`).join(""));
 		}
 		this.log();
 	}
 	printErrorsSummary(files, errors) {
-		const suites = getSuites(files), tests = getTests(files), failedSuites = suites.filter((i) => i.result?.errors), failedTests = tests.filter((i) => i.result?.state === "fail"), failedTotal = countTestErrors(failedSuites) + countTestErrors(failedTests);
+		const suites = getSuites(files);
+		const tests = getTests(files);
+		const failedSuites = suites.filter((i) => i.result?.errors);
+		const failedTests = tests.filter((i) => i.result?.state === "fail");
+		const failedTotal = countTestErrors(failedSuites) + countTestErrors(failedTests);
 		// TODO: error divider should take into account merged errors for counting
 		let current = 1;
 		const errorDivider = () => this.error(`${c.red(c.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}\n`);
-		if (failedSuites.length) this.error(`\n${errorBanner(`Failed Suites ${failedSuites.length}`)}\n`), this.printTaskErrors(failedSuites, errorDivider);
-		if (failedTests.length) this.error(`\n${errorBanner(`Failed Tests ${failedTests.length}`)}\n`), this.printTaskErrors(failedTests, errorDivider);
-		if (errors.length) this.ctx.logger.printUnhandledErrors(errors), this.error();
+		if (failedSuites.length) {
+			this.error(`\n${errorBanner(`Failed Suites ${failedSuites.length}`)}\n`);
+			this.printTaskErrors(failedSuites, errorDivider);
+		}
+		if (failedTests.length) {
+			this.error(`\n${errorBanner(`Failed Tests ${failedTests.length}`)}\n`);
+			this.printTaskErrors(failedTests, errorDivider);
+		}
+		if (errors.length) {
+			this.ctx.logger.printUnhandledErrors(errors);
+			this.error();
+		}
 	}
 	reportBenchmarkSummary(files) {
 		const topBenches = getTests(files).filter((i) => i.result?.benchmark?.rank === 1);
@@ -717,7 +832,8 @@ class BaseReporter {
 		for (const bench of topBenches) {
 			const group = bench.suite || bench.file;
 			if (!group) continue;
-			const groupName = this.getFullName(group, separator), project = this.ctx.projects.find((p) => p.name === bench.file.projectName);
+			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) {
@@ -735,7 +851,10 @@ class BaseReporter {
 			let previous;
 			if (error?.stack) previous = errorsQueue.find((i) => {
 				if (i[0]?.stack !== error.stack || i[0]?.diff !== error.diff) return false;
-				const currentProjectName = task?.projectName || task.file?.projectName || "", projectName = i[1][0]?.projectName || i[1][0].file?.projectName || "", currentAnnotations = task.type === "test" && task.annotations, itemAnnotations = i[1][0].type === "test" && i[1][0].annotations;
+				const currentProjectName = task?.projectName || task.file?.projectName || "";
+				const projectName = i[1][0]?.projectName || i[1][0].file?.projectName || "";
+				const currentAnnotations = task.type === "test" && task.annotations;
+				const itemAnnotations = i[1][0].type === "test" && i[1][0].annotations;
 				return projectName === currentProjectName && deepEqual(currentAnnotations, itemAnnotations);
 			});
 			if (previous) previous[1].push(task);
@@ -743,20 +862,24 @@ class BaseReporter {
 		});
 		for (const [error, tasks] of errorsQueue) {
 			for (const task of tasks) {
-				const filepath = task?.filepath || "", projectName = task?.projectName || task.file?.projectName || "", project = this.ctx.projects.find((p) => p.name === projectName);
+				const filepath = task?.filepath || "";
+				const projectName = task?.projectName || task.file?.projectName || "";
+				const project = this.ctx.projects.find((p) => p.name === projectName);
 				let name = this.getFullName(task, separator);
 				if (filepath) name += c.dim(` [ ${this.relative(filepath)} ]`);
 				this.ctx.logger.error(`${c.bgRed(c.bold(" FAIL "))} ${formatProjectName(project)}${name}`);
 			}
 			const screenshotPaths = tasks.map((t) => t.meta?.failScreenshotPath).filter((screenshot) => screenshot != null);
-			if (this.ctx.logger.printError(error, {
+			this.ctx.logger.printError(error, {
 				project: this.ctx.getProjectByName(tasks[0].file.projectName || ""),
 				verbose: this.verbose,
 				screenshotPaths,
 				task: tasks[0]
-			}), tasks[0].type === "test" && tasks[0].annotations.length) {
+			});
+			if (tasks[0].type === "test" && tasks[0].annotations.length) {
 				const test = this.ctx.state.getReportedEntity(tasks[0]);
-				this.printAnnotations(test, "error", 1), this.error();
+				this.printAnnotations(test, "error", 1);
+				this.error();
 			}
 			errorDivider();
 		}
@@ -765,7 +888,8 @@ class BaseReporter {
 function deepEqual(a, b) {
 	if (a === b) return true;
 	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
-	const keysA = Object.keys(a), keysB = Object.keys(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;
 	return true;
@@ -776,10 +900,16 @@ function sum(items, cb) {
 	}, 0);
 }
 function getIndentation(suite, level = 1) {
-	return suite.suite && !("filepath" in suite.suite) ? getIndentation(suite.suite, level + 1) : level;
+	if (suite.suite && !("filepath" in suite.suite)) return getIndentation(suite.suite, level + 1);
+	return level;
 }
 
-const DEFAULT_RENDER_INTERVAL_MS = 1e3, ESC = "\x1B[", CLEAR_LINE = `${ESC}K`, MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`, SYNC_START = `${ESC}?2026h`, SYNC_END = `${ESC}?2026l`;
+const DEFAULT_RENDER_INTERVAL_MS = 1e3;
+const ESC = "\x1B[";
+const CLEAR_LINE = `${ESC}K`;
+const MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`;
+const SYNC_START = `${ESC}?2026h`;
+const SYNC_END = `${ESC}?2026l`;
 /**
 * Renders content of `getWindow` at the bottom of the terminal and
 * forwards all other intercepted `stdout` and `stderr` logs above it.
@@ -795,37 +925,50 @@ class WindowRenderer {
 	finished = false;
 	cleanups = [];
 	constructor(options) {
-		// Write buffered content on unexpected exits, e.g. direct `process.exit()` calls
 		this.options = {
 			interval: DEFAULT_RENDER_INTERVAL_MS,
 			...options
-		}, this.streams = {
+		};
+		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")), this.options.logger.onTerminalCleanup(() => {
-			this.flushBuffer(), this.stop();
+		};
+		this.cleanups.push(this.interceptStream(process.stdout, "output"), this.interceptStream(process.stderr, "error"));
+		// Write buffered content on unexpected exits, e.g. direct `process.exit()` calls
+		this.options.logger.onTerminalCleanup(() => {
+			this.flushBuffer();
+			this.stop();
 		});
 	}
 	start() {
-		this.started = true, this.finished = false, this.renderInterval = setInterval(() => this.schedule(), this.options.interval).unref();
+		this.started = true;
+		this.finished = false;
+		this.renderInterval = setInterval(() => this.schedule(), this.options.interval).unref();
 	}
 	stop() {
-		this.cleanups.splice(0).map((fn) => fn()), clearInterval(this.renderInterval);
+		this.cleanups.splice(0).map((fn) => fn());
+		clearInterval(this.renderInterval);
 	}
 	/**
 	* Write all buffered output and stop buffering.
 	* All intercepted writes are forwarded to actual write after this.
 	*/
 	finish() {
-		this.finished = true, this.flushBuffer(), clearInterval(this.renderInterval);
+		this.finished = true;
+		this.flushBuffer();
+		clearInterval(this.renderInterval);
 	}
 	/**
 	* Queue new render update
 	*/
 	schedule() {
-		if (!this.renderScheduled) this.renderScheduled = true, this.flushBuffer(), setTimeout(() => {
-			this.renderScheduled = false;
-		}, 100).unref();
+		if (!this.renderScheduled) {
+			this.renderScheduled = true;
+			this.flushBuffer();
+			setTimeout(() => {
+				this.renderScheduled = false;
+			}, 100).unref();
+		}
 	}
 	flushBuffer() {
 		if (this.buffer.length === 0) return this.render();
@@ -837,7 +980,8 @@ class WindowRenderer {
 				continue;
 			}
 			if (current.type !== next.type) {
-				this.render(current.message, current.type), current = next;
+				this.render(current.message, current.type);
+				current = next;
 				continue;
 			}
 			current.message += next.message;
@@ -845,31 +989,40 @@ class WindowRenderer {
 		if (current) this.render(current?.message, current?.type);
 	}
 	render(message, type = "output") {
-		if (this.finished) return this.clearWindow(), this.write(message || "", type);
-		const windowContent = this.options.getWindow(), rowCount = getRenderedRowCount(windowContent, this.options.logger.getColumns());
+		if (this.finished) {
+			this.clearWindow();
+			return this.write(message || "", type);
+		}
+		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());
-		if (this.write(SYNC_START), this.clearWindow(), message) this.write(message, type);
+		this.write(SYNC_START);
+		this.clearWindow();
+		if (message) this.write(message, type);
 		if (padding > 0) this.write("\n".repeat(padding));
-		this.write(windowContent.join("\n")), this.write(SYNC_END), this.windowHeight = rowCount + Math.max(0, padding);
+		this.write(windowContent.join("\n"));
+		this.write(SYNC_END);
+		this.windowHeight = rowCount + Math.max(0, padding);
 	}
 	clearWindow() {
-		if (this.windowHeight !== 0) {
-			this.write(CLEAR_LINE);
-			for (let i = 1; i < this.windowHeight; i++) this.write(`${MOVE_CURSOR_ONE_ROW_UP}${CLEAR_LINE}`);
-			this.windowHeight = 0;
-		}
+		if (this.windowHeight === 0) return;
+		this.write(CLEAR_LINE);
+		for (let i = 1; i < this.windowHeight; i++) this.write(`${MOVE_CURSOR_ONE_ROW_UP}${CLEAR_LINE}`);
+		this.windowHeight = 0;
 	}
 	interceptStream(stream, type) {
 		const original = stream.write;
-		return stream.write = (chunk, _, callback) => {
+		// @ts-expect-error -- not sure how 2 overloads should be typed
+		stream.write = (chunk, _, callback) => {
 			if (chunk) if (this.finished || !this.started) this.write(chunk.toString(), type);
 			else this.buffer.push({
 				type,
 				message: chunk.toString()
 			});
 			callback?.();
-		}, function restore() {
+		};
+		return function restore() {
 			stream.write = original;
 		};
 	}
@@ -887,7 +1040,8 @@ function getRenderedRowCount(rows, columns) {
 	return count;
 }
 
-const DURATION_UPDATE_INTERVAL_MS = 100, FINISHED_TEST_CLEANUP_TIME_MS = 1e3;
+const DURATION_UPDATE_INTERVAL_MS = 100;
+const FINISHED_TEST_CLEANUP_TIME_MS = 1e3;
 /**
 * Reporter extension that renders summary and forwards all other logs above itself.
 * Intended to be used by other reporters, not as a standalone reporter.
@@ -908,21 +1062,34 @@ class SummaryReporter {
 	duration = 0;
 	durationInterval = void 0;
 	onInit(ctx, options = {}) {
-		this.ctx = ctx, this.options = {
+		this.ctx = ctx;
+		this.options = {
 			verbose: false,
 			...options
-		}, this.renderer = new WindowRenderer({
+		};
+		this.renderer = new WindowRenderer({
 			logger: ctx.logger,
 			getWindow: () => this.createSummary()
-		}), this.ctx.onClose(() => {
-			clearInterval(this.durationInterval), this.renderer.stop();
+		});
+		this.ctx.onClose(() => {
+			clearInterval(this.durationInterval);
+			this.renderer.stop();
 		});
 	}
 	onTestRunStart(specifications) {
-		this.runningModules.clear(), this.finishedModules.clear(), this.modules = emptyCounters(), this.tests = emptyCounters(), this.startTimers(), this.renderer.start(), this.modules.total = specifications.length;
+		this.runningModules.clear();
+		this.finishedModules.clear();
+		this.modules = emptyCounters();
+		this.tests = emptyCounters();
+		this.startTimers();
+		this.renderer.start();
+		this.modules.total = specifications.length;
 	}
 	onTestRunEnd() {
-		this.runningModules.clear(), this.finishedModules.clear(), this.renderer.finish(), clearInterval(this.durationInterval);
+		this.runningModules.clear();
+		this.finishedModules.clear();
+		this.renderer.finish();
+		clearInterval(this.durationInterval);
 	}
 	onTestModuleQueued(module) {
 		// When new test module starts, take the place of previously finished test module, if any
@@ -930,13 +1097,20 @@ class SummaryReporter {
 			const finished = this.finishedModules.keys().next().value;
 			this.removeTestModule(finished);
 		}
-		this.runningModules.set(module.id, initializeStats(module)), this.renderer.schedule();
+		this.runningModules.set(module.id, initializeStats(module));
+		this.renderer.schedule();
 	}
 	onTestModuleCollected(module) {
 		let stats = this.runningModules.get(module.id);
-		if (!stats) stats = initializeStats(module), this.runningModules.set(module.id, stats);
+		if (!stats) {
+			stats = initializeStats(module);
+			this.runningModules.set(module.id, stats);
+		}
 		const total = Array.from(module.children.allTests()).length;
-		this.tests.total += total, stats.total = total, this.maxParallelTests = Math.max(this.maxParallelTests, this.runningModules.size), this.renderer.schedule();
+		this.tests.total += total;
+		stats.total = total;
+		this.maxParallelTests = Math.max(this.maxParallelTests, this.runningModules.size);
+		this.renderer.schedule();
 	}
 	onHookStart(options) {
 		const stats = this.getHookStats(options);
@@ -947,7 +1121,8 @@ class SummaryReporter {
 			startTime: performance.now(),
 			onFinish: () => {}
 		};
-		stats.hook?.onFinish?.(), stats.hook = hook;
+		stats.hook?.onFinish?.();
+		stats.hook = hook;
 		const timeout = setTimeout(() => {
 			hook.visible = true;
 		}, this.ctx.config.slowTestThreshold).unref();
@@ -955,7 +1130,9 @@ class SummaryReporter {
 	}
 	onHookEnd(options) {
 		const stats = this.getHookStats(options);
-		stats?.hook?.name === options.name && (stats.hook.onFinish(), stats.hook.visible = false);
+		if (stats?.hook?.name !== options.name) return;
+		stats.hook.onFinish();
+		stats.hook.visible = false;
 	}
 	onTestCaseReady(test) {
 		// Track slow running tests only on verbose mode
@@ -967,17 +1144,22 @@ class SummaryReporter {
 			visible: false,
 			startTime: performance.now(),
 			onFinish: () => {}
-		}, timeout = setTimeout(() => {
+		};
+		const timeout = setTimeout(() => {
 			slowTest.visible = true;
 		}, this.ctx.config.slowTestThreshold).unref();
 		slowTest.onFinish = () => {
-			slowTest.hook?.onFinish(), clearTimeout(timeout);
-		}, stats.tests.set(test.id, slowTest);
+			slowTest.hook?.onFinish();
+			clearTimeout(timeout);
+		};
+		stats.tests.set(test.id, slowTest);
 	}
 	onTestCaseResult(test) {
 		const stats = this.runningModules.get(test.module.id);
 		if (!stats) return;
-		stats.tests.get(test.id)?.onFinish(), stats.tests.delete(test.id), stats.completed++;
+		stats.tests.get(test.id)?.onFinish();
+		stats.tests.delete(test.id);
+		stats.completed++;
 		const result = test.result();
 		if (result?.state === "passed") this.tests.passed++;
 		else if (result?.state === "failed") this.tests.failed++;
@@ -986,7 +1168,8 @@ class SummaryReporter {
 	}
 	onTestModuleEnd(module) {
 		const state = module.state();
-		if (this.modules.completed++, state === "passed") this.modules.passed++;
+		this.modules.completed++;
+		if (state === "passed") this.modules.passed++;
 		else if (state === "failed") this.modules.failed++;
 		else if (module.task.mode === "todo" && state === "skipped") this.modules.todo++;
 		else if (state === "skipped") this.modules.skipped++;
@@ -1005,8 +1188,10 @@ class SummaryReporter {
 	getHookStats({ entity }) {
 		// Track slow running hooks only on verbose mode
 		if (!this.options.verbose) return;
-		const module = entity.type === "module" ? entity : entity.module, stats = this.runningModules.get(module.id);
-		if (stats) return entity.type === "test" ? stats.tests.get(entity.id) : stats;
+		const module = entity.type === "module" ? entity : entity.module;
+		const stats = this.runningModules.get(module.id);
+		if (!stats) return;
+		return entity.type === "test" ? stats.tests.get(entity.id) : stats;
 	}
 	createSummary() {
 		const summary = [""];
@@ -1016,25 +1201,38 @@ class SummaryReporter {
 				name: testFile.projectName,
 				color: testFile.projectColor
 			}) + typecheck + testFile.filename + c.dim(!testFile.completed && !testFile.total ? " [queued]" : ` ${testFile.completed}/${testFile.total}`));
-			const slowTasks = [testFile.hook, ...Array.from(testFile.tests.values())].filter((t) => t != null && t.visible);
+			const slowTasks = [testFile.hook, ...testFile.tests.values()].filter((t) => t != null && t.visible);
 			for (const [index, task] of slowTasks.entries()) {
-				const elapsed = this.currentTime - task.startTime, icon = index === slowTasks.length - 1 ? F_TREE_NODE_END : F_TREE_NODE_MIDDLE;
-				if (summary.push(c.bold(c.yellow(`   ${icon} `)) + task.name + c.bold(c.yellow(` ${formatTime(Math.max(0, elapsed))}`))), task.hook?.visible) summary.push(c.bold(c.yellow(`      ${F_TREE_NODE_END} `)) + task.hook.name);
+				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 (this.runningModules.size > 0) summary.push("");
-		return summary.push(padSummaryTitle("Test Files") + getStateString(this.modules)), summary.push(padSummaryTitle("Tests") + getStateString(this.tests)), summary.push(padSummaryTitle("Start at") + this.startTime), summary.push(padSummaryTitle("Duration") + formatTime(this.duration)), summary.push(""), summary;
+		summary.push(padSummaryTitle("Test Files") + getStateString(this.modules));
+		summary.push(padSummaryTitle("Tests") + getStateString(this.tests));
+		summary.push(padSummaryTitle("Start at") + this.startTime);
+		summary.push(padSummaryTitle("Duration") + formatTime(this.duration));
+		summary.push("");
+		return summary;
 	}
 	startTimers() {
 		const start = performance.now();
-		this.startTime = formatTimeString(/* @__PURE__ */ new Date()), this.durationInterval = setInterval(() => {
-			this.currentTime = performance.now(), this.duration = this.currentTime - start;
+		this.startTime = formatTimeString(/* @__PURE__ */ new Date());
+		this.durationInterval = setInterval(() => {
+			this.currentTime = performance.now();
+			this.duration = this.currentTime - start;
 		}, DURATION_UPDATE_INTERVAL_MS).unref();
 	}
 	removeTestModule(id) {
 		if (!id) return;
 		const testFile = this.runningModules.get(id);
-		testFile?.hook?.onFinish(), testFile?.tests?.forEach((test) => test.onFinish()), this.runningModules.delete(id), clearTimeout(this.finishedModules.get(id)), this.finishedModules.delete(id);
+		testFile?.hook?.onFinish();
+		testFile?.tests?.forEach((test) => test.onFinish());
+		this.runningModules.delete(id);
+		clearTimeout(this.finishedModules.get(id));
+		this.finishedModules.delete(id);
 	}
 }
 function emptyCounters() {
@@ -1056,7 +1254,9 @@ function getStateString(entry) {
 	].filter(Boolean).join(c.dim(" | ")) + c.gray(` (${entry.total})`);
 }
 function sortRunningModules(a, b) {
-	return (a.projectName || "") > (b.projectName || "") ? 1 : (a.projectName || "") < (b.projectName || "") ? -1 : a.filename.localeCompare(b.filename);
+	if ((a.projectName || "") > (b.projectName || "")) return 1;
+	if ((a.projectName || "") < (b.projectName || "")) return -1;
+	return a.filename.localeCompare(b.filename);
 }
 function initializeStats(module) {
 	return {
@@ -1074,10 +1274,12 @@ class DefaultReporter extends BaseReporter {
 	options;
 	summary;
 	constructor(options = {}) {
-		if (super(options), this.options = {
+		super(options);
+		this.options = {
 			summary: true,
 			...options
-		}, !this.isTTY) this.options.summary = false;
+		};
+		if (!this.isTTY) this.options.summary = false;
 		if (this.options.summary) this.summary = new SummaryReporter();
 	}
 	onTestRunStart(specifications) {
@@ -1088,7 +1290,8 @@ class DefaultReporter extends BaseReporter {
 		this.summary?.onTestRunStart(specifications);
 	}
 	onTestRunEnd(testModules, unhandledErrors, reason) {
-		super.onTestRunEnd(testModules, unhandledErrors, reason), this.summary?.onTestRunEnd();
+		super.onTestRunEnd(testModules, unhandledErrors, reason);
+		this.summary?.onTestRunEnd();
 	}
 	onTestModuleQueued(file) {
 		this.summary?.onTestModuleQueued(file);
@@ -1097,13 +1300,15 @@ class DefaultReporter extends BaseReporter {
 		this.summary?.onTestModuleCollected(module);
 	}
 	onTestModuleEnd(module) {
-		super.onTestModuleEnd(module), this.summary?.onTestModuleEnd(module);
+		super.onTestModuleEnd(module);
+		this.summary?.onTestModuleEnd(module);
 	}
 	onTestCaseReady(test) {
 		this.summary?.onTestCaseReady(test);
 	}
 	onTestCaseResult(test) {
-		super.onTestCaseResult(test), this.summary?.onTestCaseResult(test);
+		super.onTestCaseResult(test);
+		this.summary?.onTestCaseResult(test);
 	}
 	onHookStart(hook) {
 		this.summary?.onHookStart(hook);
@@ -1112,7 +1317,8 @@ class DefaultReporter extends BaseReporter {
 		this.summary?.onHookEnd(hook);
 	}
 	onInit(ctx) {
-		super.onInit(ctx), this.summary?.onInit(ctx, { verbose: this.verbose });
+		super.onInit(ctx);
+		this.summary?.onInit(ctx, { verbose: this.verbose });
 	}
 }
 
@@ -1121,22 +1327,30 @@ class DotReporter extends BaseReporter {
 	tests = /* @__PURE__ */ new Map();
 	finishedTests = /* @__PURE__ */ new Set();
 	onInit(ctx) {
-		if (super.onInit(ctx), this.isTTY) this.renderer = new WindowRenderer({
-			logger: ctx.logger,
-			getWindow: () => this.createSummary()
-		}), this.ctx.onClose(() => this.renderer?.stop());
+		super.onInit(ctx);
+		if (this.isTTY) {
+			this.renderer = new WindowRenderer({
+				logger: ctx.logger,
+				getWindow: () => this.createSummary()
+			});
+			this.ctx.onClose(() => this.renderer?.stop());
+		}
 	}
 	// Ignore default logging of base reporter
 	printTestModule() {}
 	onWatcherRerun(files, trigger) {
-		this.tests.clear(), this.renderer?.start(), super.onWatcherRerun(files, trigger);
+		this.tests.clear();
+		this.renderer?.start();
+		super.onWatcherRerun(files, trigger);
 	}
 	onTestRunEnd(testModules, unhandledErrors, reason) {
 		if (this.isTTY) {
 			const finalLog = formatTests(Array.from(this.tests.values()));
 			this.ctx.logger.log(finalLog);
 		} else this.ctx.logger.log();
-		this.tests.clear(), this.renderer?.finish(), super.onTestRunEnd(testModules, unhandledErrors, reason);
+		this.tests.clear();
+		this.renderer?.finish();
+		super.onTestRunEnd(testModules, unhandledErrors, reason);
 	}
 	onTestModuleCollected(module) {
 		for (const test of module.children.allTests())
@@ -1144,16 +1358,22 @@ class DotReporter extends BaseReporter {
 		this.onTestCaseReady(test);
 	}
 	onTestCaseReady(test) {
-		this.finishedTests.has(test.id) || (this.tests.set(test.id, test.result().state || "run"), this.renderer?.schedule());
+		if (this.finishedTests.has(test.id)) return;
+		this.tests.set(test.id, test.result().state || "run");
+		this.renderer?.schedule();
 	}
 	onTestCaseResult(test) {
 		const result = test.result().state;
 		// On non-TTY the finished tests are printed immediately
 		if (!this.isTTY && result !== "pending") this.ctx.logger.outputStream.write(formatTests([result]));
-		super.onTestCaseResult(test), this.finishedTests.add(test.id), this.tests.set(test.id, result || "skipped"), this.renderer?.schedule();
+		super.onTestCaseResult(test);
+		this.finishedTests.add(test.id);
+		this.tests.set(test.id, result || "skipped");
+		this.renderer?.schedule();
 	}
 	onTestModuleEnd(testModule) {
-		if (super.onTestModuleEnd(testModule), !this.isTTY) return;
+		super.onTestModuleEnd(testModule);
+		if (!this.isTTY) return;
 		const columns = this.ctx.logger.getColumns();
 		if (this.tests.size < columns) return;
 		const finishedTests = Array.from(this.tests).filter((entry) => entry[1] !== "pending");
@@ -1163,9 +1383,11 @@ class DotReporter extends BaseReporter {
 		let count = 0;
 		for (const [id, state] of finishedTests) {
 			if (count++ >= columns) break;
-			this.tests.delete(id), states.push(state);
+			this.tests.delete(id);
+			states.push(state);
 		}
-		this.ctx.logger.log(formatTests(states)), this.renderer?.schedule();
+		this.ctx.logger.log(formatTests(states));
+		this.renderer?.schedule();
 	}
 	createSummary() {
 		return [formatTests(Array.from(this.tests.values())), ""];
@@ -1175,13 +1397,16 @@ class DotReporter extends BaseReporter {
 const pass = {
 	char: "·",
 	color: c.green
-}, fail = {
+};
+const fail = {
 	char: "x",
 	color: c.red
-}, pending = {
+};
+const pending = {
 	char: "*",
 	color: c.yellow
-}, skip = {
+};
+const skip = {
 	char: "-",
 	color: (char) => c.dim(c.gray(char))
 };
@@ -1198,16 +1423,22 @@ function getIcon(state) {
 * Sibling icons with same color are merged into a single c.color() call.
 */
 function formatTests(states) {
-	let currentIcon = pending, count = 0, output = "";
+	let currentIcon = pending;
+	let count = 0;
+	let output = "";
 	for (const state of states) {
 		const icon = getIcon(state);
 		if (currentIcon === icon) {
 			count++;
 			continue;
 		}
-		output += currentIcon.color(currentIcon.char.repeat(count)), count = 1, currentIcon = icon;
+		output += currentIcon.color(currentIcon.char.repeat(count));
+		// Start tracking new group
+		count = 1;
+		currentIcon = icon;
 	}
-	return output += currentIcon.color(currentIcon.char.repeat(count)), output;
+	output += currentIcon.color(currentIcon.char.repeat(count));
+	return output;
 }
 
 // src/vlq.ts
@@ -2102,10 +2333,13 @@ base.MethodDefinition = base.PropertyDefinition = base.Property = function (node
 async function collectTests(ctx, filepath) {
 	const request = await ctx.vite.environments.ssr.transformRequest(filepath);
 	if (!request) return null;
-	const ast = await parseAstAsync(request.code), testFilepath = relative(ctx.config.root, filepath), projectName = ctx.name, typecheckSubprojectName = projectName ? `${projectName}:__typecheck__` : "__typecheck__", file = {
+	const ast = await parseAstAsync(request.code);
+	const testFilepath = relative(ctx.config.root, filepath);
+	const projectName = ctx.name;
+	const file = {
 		filepath,
 		type: "suite",
-		id: generateHash(`${testFilepath}${typecheckSubprojectName}`),
+		id: generateHash(`${testFilepath}${projectName ? `${projectName}:__typecheck__` : "__typecheck__"}`),
 		name: testFilepath,
 		mode: "run",
 		tasks: [],
@@ -2116,19 +2350,24 @@ async function collectTests(ctx, filepath) {
 		file: null
 	};
 	file.file = file;
-	const definitions = [], getName = (callee) => {
+	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")
- // call as `__vite_ssr__.test.skip()`
-		return callee.object?.type === "Identifier" && [
-			"it",
-			"test",
-			"describe",
-			"suite"
-		].includes(callee.object.name) ? callee.object?.name : callee.object?.name?.startsWith("__vite_ssr_") ? getName(callee.property) : getName(callee.object?.property);
+		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;
@@ -2137,8 +2376,10 @@ async function collectTests(ctx, filepath) {
 		return null;
 	};
 	ancestor(ast, { CallExpression(node) {
-		const { callee } = node, name = getName(callee);
-		if (!name || ![
+		const { callee } = node;
+		const name = getName(callee);
+		if (!name) return;
+		if (![
 			"it",
 			"test",
 			"describe",
@@ -2159,7 +2400,8 @@ async function collectTests(ctx, filepath) {
 		if (callee.type === "CallExpression") start = callee.end;
 		else if (callee.type === "TaggedTemplateExpression") start = callee.end + 1;
 		else start = node.start;
-		const { arguments: [messageNode] } = node, message = messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral" ? request.code.slice(messageNode.start + 1, messageNode.end - 1) : request.code.slice(messageNode.start, messageNode.end);
+		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({
@@ -2195,7 +2437,9 @@ async function collectTests(ctx, filepath) {
 				start: definition.start,
 				meta: { typecheck: true }
 			};
-			definition.task = task, latestSuite.tasks.push(task), lastSuite = task;
+			definition.task = task;
+			latestSuite.tasks.push(task);
+			lastSuite = task;
 			return;
 		}
 		const task = {
@@ -2212,10 +2456,13 @@ async function collectTests(ctx, filepath) {
 			annotations: [],
 			meta: { typecheck: true }
 		};
-		definition.task = task, latestSuite.tasks.push(task);
-	}), calculateSuiteHash(file);
+		definition.task = task;
+		latestSuite.tasks.push(task);
+	});
+	calculateSuiteHash(file);
 	const hasOnly = someTasksAreOnly(file);
-	return interpretTaskModes(file, ctx.config.testNamePattern, void 0, hasOnly, false, ctx.config.allowOnly), {
+	interpretTaskModes(file, ctx.config.testNamePattern, void 0, hasOnly, false, ctx.config.allowOnly);
+	return {
 		file,
 		parsed: request.code,
 		filepath,
@@ -2224,11 +2471,14 @@ async function collectTests(ctx, filepath) {
 	};
 }
 
-const newLineRegExp = /\r?\n/, errCodeRegExp = /error TS(?<errCode>\d+)/;
+const newLineRegExp = /\r?\n/;
+const errCodeRegExp = /error TS(?<errCode>\d+)/;
 async function makeTscErrorInfo(errInfo) {
 	const [errFilePathPos = "", ...errMsgRawArr] = errInfo.split(":");
 	if (!errFilePathPos || errMsgRawArr.length === 0 || errMsgRawArr.join("").length === 0) return ["unknown filepath", null];
-	const errMsgRaw = errMsgRawArr.join("").trim(), [errFilePath, errPos] = errFilePathPos.slice(0, -1).split("(");
+	const errMsgRaw = errMsgRawArr.join("").trim();
+	// get filePath, line, col
+	const [errFilePath, errPos] = errFilePathPos.slice(0, -1).split("(");
 	if (!errFilePath || !errPos) return ["unknown filepath", null];
 	const [errLine, errCol] = errPos.split(",");
 	if (!errLine || !errCol) return [errFilePath, null];
@@ -2237,7 +2487,9 @@ async function makeTscErrorInfo(errInfo) {
 	if (!execArr) return [errFilePath, null];
 	const errCodeStr = execArr.groups?.errCode ?? "";
 	if (!errCodeStr) return [errFilePath, null];
-	const line = Number(errLine), col = Number(errCol), errCode = Number(errCodeStr);
+	const line = Number(errLine);
+	const col = Number(errCol);
+	const errCode = Number(errCodeStr);
 	return [errFilePath, {
 		filePath: errFilePath,
 		errCode,
@@ -2248,29 +2500,40 @@ async function makeTscErrorInfo(errInfo) {
 }
 async function getRawErrsMapFromTsCompile(tscErrorStdout) {
 	const rawErrsMap = /* @__PURE__ */ new Map();
-	return (await Promise.all(tscErrorStdout.split(newLineRegExp).reduce((prev, next) => {
+	(await Promise.all(tscErrorStdout.split(newLineRegExp).reduce((prev, next) => {
 		if (!next) return prev;
-		if (next[0] !== " ") prev.push(next);
+		else if (next[0] !== " ") prev.push(next);
 		else prev[prev.length - 1] += `\n${next}`;
 		return prev;
 	}, []).map((errInfoLine) => makeTscErrorInfo(errInfoLine)))).forEach(([errFilePath, errInfo]) => {
-		if (errInfo) if (!rawErrsMap.has(errFilePath)) rawErrsMap.set(errFilePath, [errInfo]);
+		if (!errInfo) return;
+		if (!rawErrsMap.has(errFilePath)) rawErrsMap.set(errFilePath, [errInfo]);
 		else rawErrsMap.get(errFilePath)?.push(errInfo);
-	}), rawErrsMap;
+	});
+	return rawErrsMap;
 }
 
 function createIndexMap(source) {
 	const map = /* @__PURE__ */ new Map();
-	let index = 0, line = 1, column = 1;
-	for (const char of source) if (map.set(`${line}:${column}`, index++), char === "\n" || char === "\r\n") line++, column = 0;
-	else column++;
+	let index = 0;
+	let line = 1;
+	let column = 1;
+	for (const char of source) {
+		map.set(`${line}:${column}`, index++);
+		if (char === "\n" || char === "\r\n") {
+			line++;
+			column = 0;
+		} else column++;
+	}
 	return map;
 }
 
 class TypeCheckError extends Error {
 	name = "TypeCheckError";
 	constructor(message, stacks) {
-		super(message), this.message = message, this.stacks = stacks;
+		super(message);
+		this.message = message;
+		this.stacks = stacks;
 	}
 }
 class Typechecker {
@@ -2310,9 +2573,12 @@ class Typechecker {
 	}
 	async collectTests() {
 		const tests = (await Promise.all(this.getFiles().map((filepath) => this.collectFileTests(filepath)))).reduce((acc, data) => {
-			return data && (acc[data.filepath] = data), acc;
+			if (!data) return acc;
+			acc[data.filepath] = data;
+			return acc;
 		}, {});
-		return this._tests = tests, tests;
+		this._tests = tests;
+		return tests;
 	}
 	markPassed(file) {
 		if (!file.result?.state) file.result = { state: "pass" };
@@ -2325,17 +2591,26 @@ class Typechecker {
 		markTasks(file.tasks);
 	}
 	async prepareResults(output) {
-		const typeErrors = await this.parseTscLikeOutput(output), testFiles = new Set(this.getFiles());
+		const typeErrors = await this.parseTscLikeOutput(output);
+		const testFiles = new Set(this.getFiles());
 		if (!this._tests) this._tests = await this.collectTests();
-		const sourceErrors = [], files = [];
-		return testFiles.forEach((path) => {
-			const { file, definitions, map, parsed } = this._tests[path], errors = typeErrors.get(path);
-			if (files.push(file), !errors) {
+		const sourceErrors = [];
+		const files = [];
+		testFiles.forEach((path) => {
+			const { file, definitions, map, parsed } = this._tests[path];
+			const errors = typeErrors.get(path);
+			files.push(file);
+			if (!errors) {
 				this.markPassed(file);
 				return;
 			}
-			const sortedDefinitions = [...definitions.sort((a, b) => b.start - a.start)], traceMap = map && new TraceMap(map), indexMap = createIndexMap(parsed), markState = (task, state) => {
-				if (task.result = { state: task.mode === "run" || task.mode === "only" ? state : task.mode }, task.suite) markState(task.suite, state);
+			const sortedDefinitions = [...definitions.sort((a, b) => b.start - a.start)];
+			// has no map for ".js" files that use // @ts-check
+			const traceMap = map && new TraceMap(map);
+			const indexMap = createIndexMap(parsed);
+			const markState = (task, state) => {
+				task.result = { state: task.mode === "run" || task.mode === "only" ? state : task.mode };
+				if (task.suite) markState(task.suite, state);
 				else if (task.file && task !== task.file) markState(task.file, state);
 			};
 			errors.forEach(({ error, originalError }) => {
@@ -2343,37 +2618,53 @@ class Typechecker {
 					line: originalError.line,
 					column: originalError.column,
 					source: basename(path)
-				}) : originalError, line = processedPos.line ?? originalError.line, column = processedPos.column ?? originalError.column, index = indexMap.get(`${line}:${column}`), definition = index != null && sortedDefinitions.find((def) => def.start <= index && def.end >= index), suite = definition ? definition.task : file, state = suite.mode === "run" || suite.mode === "only" ? "fail" : suite.mode, errors = suite.result?.errors || [];
-				if (suite.result = {
+				}) : originalError;
+				const line = processedPos.line ?? originalError.line;
+				const column = processedPos.column ?? originalError.column;
+				const index = indexMap.get(`${line}:${column}`);
+				const definition = index != null && sortedDefinitions.find((def) => def.start <= index && def.end >= index);
+				const suite = definition ? definition.task : file;
+				const state = suite.mode === "run" || suite.mode === "only" ? "fail" : suite.mode;
+				const errors = suite.result?.errors || [];
+				suite.result = {
 					state,
 					errors
-				}, errors.push(error), state === "fail") {
+				};
+				errors.push(error);
+				if (state === "fail") {
 					if (suite.suite) markState(suite.suite, "fail");
 					else if (suite.file && suite !== suite.file) markState(suite.file, "fail");
 				}
-			}), this.markPassed(file);
-		}), typeErrors.forEach((errors, path) => {
+			});
+			this.markPassed(file);
+		});
+		typeErrors.forEach((errors, path) => {
 			if (!testFiles.has(path)) sourceErrors.push(...errors.map(({ error }) => error));
-		}), {
+		});
+		return {
 			files,
 			sourceErrors,
 			time: performance$1.now() - this._startTime
 		};
 	}
 	async parseTscLikeOutput(output) {
-		const errorsMap = await getRawErrsMapFromTsCompile(output), typesErrors = /* @__PURE__ */ new Map();
-		return errorsMap.forEach((errors, path) => {
-			const filepath = resolve$1(this.project.config.root, path), suiteErrors = errors.map((info) => {
+		const errorsMap = await getRawErrsMapFromTsCompile(output);
+		const typesErrors = /* @__PURE__ */ new Map();
+		errorsMap.forEach((errors, path) => {
+			const filepath = resolve$1(this.project.config.root, path);
+			const suiteErrors = errors.map((info) => {
 				const limit = Error.stackTraceLimit;
 				Error.stackTraceLimit = 0;
 				// Some expect-type errors have the most useful information on the second line e.g. `This expression is not callable.\n  Type 'ExpectString<number>' has no call signatures.`
-				const errMsg = info.errMsg.replace(/\r?\n\s*(Type .* has no call signatures)/g, " $1"), error = new TypeCheckError(errMsg, [{
+				const errMsg = info.errMsg.replace(/\r?\n\s*(Type .* has no call signatures)/g, " $1");
+				const error = new TypeCheckError(errMsg, [{
 					file: filepath,
 					line: info.line,
 					column: info.column,
 					method: ""
 				}]);
-				return Error.stackTraceLimit = limit, {
+				Error.stackTraceLimit = limit;
+				return {
 					originalError: info,
 					error: {
 						name: error.name,
@@ -2384,10 +2675,12 @@ class Typechecker {
 				};
 			});
 			typesErrors.set(filepath, suiteErrors);
-		}), typesErrors;
+		});
+		return typesErrors;
 	}
 	async stop() {
-		this.process?.kill(), this.process = void 0;
+		this.process?.kill();
+		this.process = void 0;
 	}
 	async ensurePackageInstalled(ctx, checker) {
 		if (checker !== "tsc" && checker !== "vue-tsc") return;
@@ -2401,7 +2694,8 @@ class Typechecker {
 		return this._output;
 	}
 	async spawn() {
-		const { root, watch, typecheck } = this.project.config, args = [
+		const { root, watch, typecheck } = this.project.config;
+		const args = [
 			"--noEmit",
 			"--pretty",
 			"false",
@@ -2413,7 +2707,8 @@ class Typechecker {
 		if (watch) args.push("--watch");
 		if (typecheck.allowJs) args.push("--allowJs", "--checkJs");
 		if (typecheck.tsconfig) args.push("-p", resolve$1(root, typecheck.tsconfig));
-		this._output = "", this._startTime = performance$1.now();
+		this._output = "";
+		this._startTime = performance$1.now();
 		const child = x(typecheck.checker, args, {
 			nodeOptions: {
 				cwd: root,
@@ -2422,26 +2717,44 @@ class Typechecker {
 			throwOnError: false
 		});
 		this.process = child.process;
-		let rerunTriggered = false, dataReceived = false;
+		let rerunTriggered = false;
+		let dataReceived = false;
 		return new Promise((resolve, reject) => {
 			if (!child.process || !child.process.stdout) {
 				reject(/* @__PURE__ */ new Error(`Failed to initialize ${typecheck.checker}. This is a bug in Vitest - please, open an issue with reproduction.`));
 				return;
 			}
 			child.process.stdout.on("data", (chunk) => {
-				if (dataReceived = true, this._output += chunk, watch) {
-					if (this._output.includes("File change detected") && !rerunTriggered) this._onWatcherRerun?.(), this._startTime = performance$1.now(), this._result.sourceErrors = [], this._result.files = [], this._tests = null, rerunTriggered = true;
-					if (/Found \w+ errors*. Watching for/.test(this._output)) rerunTriggered = false, this.prepareResults(this._output).then((result) => {
-						this._result = result, this._onParseEnd?.(result);
-					}), this._output = "";
+				dataReceived = true;
+				this._output += chunk;
+				if (!watch) return;
+				if (this._output.includes("File change detected") && !rerunTriggered) {
+					this._onWatcherRerun?.();
+					this._startTime = performance$1.now();
+					this._result.sourceErrors = [];
+					this._result.files = [];
+					this._tests = null;
+					rerunTriggered = true;
+				}
+				if (/Found \w+ errors*. Watching for/.test(this._output)) {
+					rerunTriggered = false;
+					this.prepareResults(this._output).then((result) => {
+						this._result = result;
+						this._onParseEnd?.(result);
+					});
+					this._output = "";
 				}
 			});
 			const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`${typecheck.checker} spawn timed out`)), this.project.config.typecheck.spawnTimeout);
 			function onError(cause) {
-				clearTimeout(timeout), reject(new Error("Spawning typechecker failed - is typescript installed?", { cause }));
+				clearTimeout(timeout);
+				reject(new Error("Spawning typechecker failed - is typescript installed?", { cause }));
 			}
-			if (child.process.once("spawn", () => {
-				if (this._onParseStart?.(), child.process?.off("error", onError), clearTimeout(timeout), process.platform === "win32")
+			child.process.once("spawn", () => {
+				this._onParseStart?.();
+				child.process?.off("error", onError);
+				clearTimeout(timeout);
+				if (process.platform === "win32")
  // on Windows, the process might be spawned but fail to start
 				// we wait for a potential error here. if "close" event didn't trigger,
 				// we resolve the promise
@@ -2449,7 +2762,8 @@ class Typechecker {
 					resolve({ result: child });
 				}, 200);
 				else resolve({ result: child });
-			}), process.platform === "win32") child.process.once("close", (code) => {
+			});
+			if (process.platform === "win32") child.process.once("close", (code) => {
 				if (code != null && code !== 0 && !dataReceived) onError(/* @__PURE__ */ new Error(`The ${typecheck.checker} command exited with code ${code}.`));
 			});
 			child.process.once("error", onError);
@@ -2457,8 +2771,13 @@ class Typechecker {
 	}
 	async start() {
 		if (this.process) return;
-		const { watch } = this.project.config, { result: child } = await this.spawn();
-		if (!watch) await child, this._result = await this.prepareResults(this._output), await this._onParseEnd?.(this._result);
+		const { watch } = this.project.config;
+		const { result: child } = await this.spawn();
+		if (!watch) {
+			await child;
+			this._result = await this.prepareResults(this._output);
+			await this._onParseEnd?.(this._result);
+		}
 	}
 	getResult() {
 		return this._result;
@@ -2467,10 +2786,12 @@ class Typechecker {
 		return Object.values(this._tests || {}).map((i) => i.file);
 	}
 	getTestPacksAndEvents() {
-		const packs = [], events = [];
+		const packs = [];
+		const events = [];
 		for (const { file } of Object.values(this._tests || {})) {
 			const result = convertTasksToEvents(file);
-			packs.push(...result.packs), events.push(...result.events);
+			packs.push(...result.packs);
+			events.push(...result.events);
 		}
 		return {
 			packs,
@@ -2493,10 +2814,11 @@ function findGeneratedPosition(traceMap, { line, column, source }) {
 		if (m.source === source && m.originalLine !== null && m.originalColumn !== null && (line === m.originalLine ? column < m.originalColumn : line < m.originalLine)) mappings.push(m);
 	});
 	const next = mappings.sort((a, b) => a.originalLine === b.originalLine ? a.originalColumn - b.originalColumn : a.originalLine - b.originalLine).at(0);
-	return next ? {
+	if (next) return {
 		line: next.generatedLine,
 		column: next.generatedColumn
-	} : {
+	};
+	return {
 		line: null,
 		column: null
 	};
@@ -2505,14 +2827,15 @@ function findGeneratedPosition(traceMap, { line, column, source }) {
 // use Logger with custom Console to capture entire error printing
 function capturePrintError(error, ctx, options) {
 	let output = "";
-	const writable = new Writable({ write(chunk, _encoding, callback) {
-		output += String(chunk), callback();
-	} }), console = new Console(writable), logger = {
-		error: console.error.bind(console),
-		highlight: ctx.logger.highlight.bind(ctx.logger)
-	};
+	const console = new Console(new Writable({ write(chunk, _encoding, callback) {
+		output += String(chunk);
+		callback();
+	} }));
 	return {
-		nearest: printError(error, ctx, logger, {
+		nearest: printError(error, ctx, {
+			error: console.error.bind(console),
+			highlight: ctx.logger.highlight.bind(ctx.logger)
+		}, {
 			showCodeFrame: false,
 			...options
 		})?.nearest,
@@ -2528,13 +2851,18 @@ function printError(error, ctx, logger, options) {
 		screenshotPaths: options.screenshotPaths,
 		printProperties: options.verbose,
 		parseErrorStacktrace(error) {
-			// node.js stack trace already has correct source map locations
-			return error.stacks ? options.fullStack ? error.stacks : error.stacks.filter((stack) => {
+			if (error.stacks) if (options.fullStack) return error.stacks;
+			else return error.stacks.filter((stack) => {
 				return !defaultStackIgnorePatterns.some((p) => stack.file.match(p));
-			}) : options.task?.file.pool === "browser" && project.browser ? project.browser.parseErrorStacktrace(error, {
+			});
+			// browser stack trace needs to be processed differently,
+			// so there is a separate method for that
+			if (options.task?.file.pool === "browser" && project.browser) return project.browser.parseErrorStacktrace(error, {
 				frameFilter: project.config.onStackTrace,
 				ignoreStackEntries: options.fullStack ? [] : void 0
-			}) : parseErrorStacktrace(error, {
+			});
+			// node.js stack trace already has correct source map locations
+			return parseErrorStacktrace(error, {
 				frameFilter: project.config.onStackTrace,
 				ignoreStackEntries: options.fullStack ? [] : void 0
 			});
@@ -2542,7 +2870,8 @@ function printError(error, ctx, logger, options) {
 	});
 }
 function printErrorInner(error, project, options) {
-	const { showCodeFrame = true, type, printProperties = true } = options, logger = options.logger;
+	const { showCodeFrame = true, type, printProperties = true } = options;
+	const logger = options.logger;
 	let e = error;
 	if (isPrimitive(e)) e = {
 		message: String(error).split(/\n/g)[0],
@@ -2560,7 +2889,8 @@ function printErrorInner(error, project, options) {
 		printErrorMessage(e, logger);
 		return;
 	}
-	const stacks = options.parseErrorStacktrace(e), nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find((stack) => {
+	const stacks = options.parseErrorStacktrace(e);
+	const nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find((stack) => {
 		// we are checking that this module was processed by us at one point
 		try {
 			return [...Object.values(project._vite?.environments || {}), ...Object.values(project.browser?.vite.environments || {})].some((environment) => {
@@ -2571,9 +2901,13 @@ function printErrorInner(error, project, options) {
 		}
 	});
 	if (type) printErrorType(type, project.vitest);
-	if (printErrorMessage(e, logger), options.screenshotPaths?.length) {
-		const uniqueScreenshots = Array.from(new Set(options.screenshotPaths)), length = uniqueScreenshots.length;
-		if (logger.error(`\nFailure screenshot${length > 1 ? "s" : ""}:`), logger.error(uniqueScreenshots.map((p) => `  - ${c.dim(relative(process.cwd(), p))}`).join("\n")), !e.diff) logger.error();
+	printErrorMessage(e, logger);
+	if (options.screenshotPaths?.length) {
+		const uniqueScreenshots = Array.from(new Set(options.screenshotPaths));
+		const length = uniqueScreenshots.length;
+		logger.error(`\nFailure screenshot${length > 1 ? "s" : ""}:`);
+		logger.error(uniqueScreenshots.map((p) => `  - ${c.dim(relative(process.cwd(), p))}`).join("\n"));
+		if (!e.diff) logger.error();
 	}
 	if (e.codeFrame) logger.error(`${e.codeFrame}\n`);
 	if ("__vitest_rollup_error__" in e) {
@@ -2589,28 +2923,29 @@ function printErrorInner(error, project, options) {
 	if (e.diff) logger.error(`\n${e.diff}\n`);
 	// if the error provide the frame
 	if (e.frame) logger.error(c.yellow(e.frame));
-	else {
-		const errorProperties = printProperties ? getErrorProperties(e) : {};
-		printStack(logger, project, stacks, nearest, errorProperties, (s) => {
-			if (showCodeFrame && s === nearest && nearest) {
-				const sourceCode = readFileSync(nearest.file, "utf-8");
-				logger.error(generateCodeFrame(sourceCode.length > 1e5 ? sourceCode : logger.highlight(nearest.file, sourceCode), 4, s));
-			}
-		});
-	}
-	const testPath = e.VITEST_TEST_PATH, testName = e.VITEST_TEST_NAME, afterEnvTeardown = e.VITEST_AFTER_ENV_TEARDOWN;
+	else printStack(logger, project, stacks, nearest, printProperties ? getErrorProperties(e) : {}, (s) => {
+		if (showCodeFrame && s === nearest && nearest) {
+			const sourceCode = readFileSync(nearest.file, "utf-8");
+			logger.error(generateCodeFrame(sourceCode.length > 1e5 ? sourceCode : logger.highlight(nearest.file, sourceCode), 4, s));
+		}
+	});
+	const testPath = e.VITEST_TEST_PATH;
+	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 (afterEnvTeardown) logger.error(c.red("This error was caught after test environment was torn down. Make sure to cancel any running tasks before test finishes:\n- cancel timeouts using clearTimeout and clearInterval\n- wait for promises to resolve using the await keyword"));
-	if (typeof e.cause === "object" && e.cause && "name" in e.cause) e.cause.name = `Caused by: ${e.cause.name}`, printErrorInner(e.cause, project, {
-		showCodeFrame: false,
-		logger: options.logger,
-		parseErrorStacktrace: options.parseErrorStacktrace
-	});
-	return handleImportOutsideModuleError(e.stack || "", logger), { nearest };
+	if (typeof e.cause === "object" && e.cause && "name" in e.cause) {
+		e.cause.name = `Caused by: ${e.cause.name}`;
+		printErrorInner(e.cause, project, {
+			showCodeFrame: false,
+			logger: options.logger,
+			parseErrorStacktrace: options.parseErrorStacktrace
+		});
+	}
+	handleImportOutsideModuleError(e.stack || "", logger);
+	return { nearest };
 }
 function printErrorType(type, ctx) {
 	ctx.logger.error(`\n${errorBanner(type)}`);
@@ -2636,7 +2971,6 @@ const skipErrorProperties = new Set([
 	"columnNumber",
 	"VITEST_TEST_NAME",
 	"VITEST_TEST_PATH",
-	"VITEST_AFTER_ENV_TEARDOWN",
 	"__vitest_rollup_error__",
 	...Object.getOwnPropertyNames(Error.prototype),
 	...Object.getOwnPropertyNames(Object.prototype)
@@ -2693,8 +3027,10 @@ function printErrorMessage(error, logger) {
 }
 function printStack(logger, project, stack, highlight, errorProperties, onStack) {
 	for (const frame of stack) {
-		const color = frame === highlight ? c.cyan : c.gray, path = relative(project.config.root, frame.file);
-		logger.error(color(` ${c.dim(F_POINTER)} ${[frame.method, `${path}:${c.dim(`${frame.line}:${frame.column}`)}`].filter(Boolean).join(" ")}`)), onStack?.(frame);
+		const color = frame === highlight ? c.cyan : c.gray;
+		const path = relative(project.config.root, frame.file);
+		logger.error(color(` ${c.dim(F_POINTER)} ${[frame.method, `${path}:${c.dim(`${frame.line}:${frame.column}`)}`].filter(Boolean).join(" ")}`));
+		onStack?.(frame);
 	}
 	if (stack.length) logger.error();
 	if (hasProperties(errorProperties)) {
@@ -2709,19 +3045,28 @@ function hasProperties(obj) {
 	return false;
 }
 function generateCodeFrame(source, indent = 0, loc, range = 2) {
-	const start = typeof loc === "object" ? positionToOffset(source, loc.line, loc.column) : loc, end = start, lines = source.split(lineSplitRE), nl = /\r\n/.test(source) ? 2 : 1;
-	let count = 0, res = [];
+	const start = typeof loc === "object" ? positionToOffset(source, loc.line, loc.column) : loc;
+	const end = start;
+	const lines = source.split(lineSplitRE);
+	const nl = /\r\n/.test(source) ? 2 : 1;
+	let count = 0;
+	let res = [];
 	const columns = process.stdout?.columns || 80;
-	for (let i = 0; i < lines.length; i++) if (count += lines[i].length + nl, count >= start) {
-		for (let j = i - range; j <= i + range || end > count; j++) {
-			if (j < 0 || j >= lines.length) continue;
-			const lineLength = lines[j].length, strippedContent = stripVTControlCharacters(lines[j]);
-			if (!strippedContent.startsWith("//# sourceMappingURL")) {
+	for (let i = 0; i < lines.length; i++) {
+		count += lines[i].length + nl;
+		if (count >= start) {
+			for (let j = i - range; j <= i + range || end > count; j++) {
+				if (j < 0 || j >= lines.length) continue;
+				const lineLength = lines[j].length;
+				const strippedContent = stripVTControlCharacters(lines[j]);
+				if (strippedContent.startsWith("//# sourceMappingURL")) continue;
 				// too long, maybe it's a minified file, skip for codeframe
 				if (strippedContent.length > 200) return "";
-				if (res.push(lineNo(j + 1) + truncateString(lines[j].replace(/\t/g, " "), columns - 5 - indent)), j === i) {
+				res.push(lineNo(j + 1) + truncateString(lines[j].replace(/\t/g, " "), columns - 5 - indent));
+				if (j === i) {
 					// push underline
-					const pad = start - (count - lineLength) + (nl - 1), length = Math.max(1, end > count ? lineLength - pad : end - start);
+					const pad = start - (count - lineLength) + (nl - 1);
+					const length = Math.max(1, end > count ? lineLength - pad : end - start);
 					res.push(lineNo() + " ".repeat(pad) + c.red("^".repeat(length)));
 				} else if (j > i) {
 					if (end > count) {
@@ -2731,8 +3076,8 @@ function generateCodeFrame(source, indent = 0, loc, range = 2) {
 					count += lineLength + 1;
 				}
 			}
+			break;
 		}
-		break;
 	}
 	if (indent) res = res.map((line) => " ".repeat(indent) + line);
 	return res.join("\n");
@@ -2752,7 +3097,8 @@ class GithubActionsReporter {
 	}
 	onTestCaseAnnotate(testCase, annotation) {
 		if (!annotation.location || this.options.displayAnnotations === false) return;
-		const type = getTitle(annotation.type), formatted = formatMessage({
+		const type = getTitle(annotation.type);
+		const formatted = formatMessage({
 			command: getType(annotation.type),
 			properties: {
 				file: annotation.location.file,
@@ -2765,14 +3111,18 @@ class GithubActionsReporter {
 		this.ctx.logger.log(`\n${formatted}`);
 	}
 	onTestRunEnd(testModules, unhandledErrors) {
-		const files = testModules.map((testModule) => testModule.task), errors = [...unhandledErrors], projectErrors = new Array();
+		const files = testModules.map((testModule) => testModule.task);
+		const errors = [...unhandledErrors];
+		// collect all errors and associate them with projects
+		const projectErrors = new Array();
 		for (const error of errors) projectErrors.push({
 			project: this.ctx.getRootProject(),
 			title: "Unhandled error",
 			error
 		});
 		for (const file of files) {
-			const tasks = getTasks(file), project = this.ctx.getProjectByName(file.projectName || "");
+			const tasks = getTasks(file);
+			const project = this.ctx.getProjectByName(file.projectName || "");
 			for (const task of tasks) {
 				if (task.result?.state !== "fail") continue;
 				const title = getFullName(task, " > ");
@@ -2790,7 +3140,8 @@ class GithubActionsReporter {
 			const result = capturePrintError(error, this.ctx, {
 				project,
 				task: file
-			}), stack = result?.nearest;
+			});
+			const stack = result?.nearest;
 			if (!stack) continue;
 			const formatted = formatMessage({
 				command: "error",
@@ -2812,10 +3163,12 @@ const BUILT_IN_TYPES = [
 	"warning"
 ];
 function getTitle(type) {
-	if (!BUILT_IN_TYPES.includes(type)) return type;
+	if (BUILT_IN_TYPES.includes(type)) return;
+	return type;
 }
 function getType(type) {
-	return BUILT_IN_TYPES.includes(type) ? type : "notice";
+	if (BUILT_IN_TYPES.includes(type)) return type;
+	return "notice";
 }
 function defaultOnWritePath(path) {
 	return path;
@@ -2825,9 +3178,12 @@ function defaultOnWritePath(path) {
 // https://github.com/actions/toolkit/blob/f1d9b4b985e6f0f728b4b766db73498403fd5ca3/packages/core/src/command.ts#L80-L85
 function formatMessage({ command, properties, message }) {
 	let result = `::${command}`;
-	return Object.entries(properties).forEach(([k, v], i) => {
-		result += i === 0 ? " " : ",", result += `${k}=${escapeProperty(v)}`;
-	}), result += `::${escapeData(message)}`, result;
+	Object.entries(properties).forEach(([k, v], i) => {
+		result += i === 0 ? " " : ",";
+		result += `${k}=${escapeProperty(v)}`;
+	});
+	result += `::${escapeData(message)}`;
+	return result;
 }
 function escapeData(s) {
 	return s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
@@ -2864,22 +3220,42 @@ class JsonReporter {
 		this.options = options;
 	}
 	onInit(ctx) {
-		this.ctx = ctx, this.start = Date.now(), this.coverageMap = void 0;
+		this.ctx = ctx;
+		this.start = Date.now();
+		this.coverageMap = void 0;
 	}
 	onCoverage(coverageMap) {
 		this.coverageMap = coverageMap;
 	}
 	async onTestRunEnd(testModules) {
-		const files = testModules.map((testModule) => testModule.task), suites = getSuites(files), numTotalTestSuites = suites.length, tests = getTests(files), numTotalTests = tests.length, numFailedTestSuites = suites.filter((s) => s.result?.state === "fail").length, numPendingTestSuites = suites.filter((s) => s.result?.state === "run" || s.result?.state === "queued" || s.mode === "todo").length, numPassedTestSuites = numTotalTestSuites - numFailedTestSuites - numPendingTestSuites, numFailedTests = tests.filter((t) => t.result?.state === "fail").length, numPassedTests = tests.filter((t) => t.result?.state === "pass").length, numPendingTests = tests.filter((t) => t.result?.state === "run" || t.result?.state === "queued" || t.mode === "skip" || t.result?.state === "skip").length, numTodoTests = tests.filter((t) => t.mode === "todo").length, testResults = [], success = !!(files.length > 0 || this.ctx.config.passWithNoTests) && numFailedTestSuites === 0 && numFailedTests === 0;
+		const files = testModules.map((testModule) => testModule.task);
+		const suites = getSuites(files);
+		const numTotalTestSuites = suites.length;
+		const tests = getTests(files);
+		const numTotalTests = tests.length;
+		const numFailedTestSuites = suites.filter((s) => s.result?.state === "fail").length;
+		const numPendingTestSuites = suites.filter((s) => s.result?.state === "run" || s.result?.state === "queued" || s.mode === "todo").length;
+		const numPassedTestSuites = numTotalTestSuites - numFailedTestSuites - numPendingTestSuites;
+		const numFailedTests = tests.filter((t) => t.result?.state === "fail").length;
+		const numPassedTests = tests.filter((t) => t.result?.state === "pass").length;
+		const numPendingTests = tests.filter((t) => t.result?.state === "run" || t.result?.state === "queued" || t.mode === "skip" || t.result?.state === "skip").length;
+		const numTodoTests = tests.filter((t) => t.mode === "todo").length;
+		const testResults = [];
+		const success = !!(files.length > 0 || this.ctx.config.passWithNoTests) && numFailedTestSuites === 0 && numFailedTests === 0;
 		for (const file of files) {
 			const tests = getTests([file]);
 			let startTime = tests.reduce((prev, next) => Math.min(prev, next.result?.startTime ?? Number.POSITIVE_INFINITY), Number.POSITIVE_INFINITY);
 			if (startTime === Number.POSITIVE_INFINITY) startTime = this.start;
-			const endTime = tests.reduce((prev, next) => Math.max(prev, (next.result?.startTime ?? 0) + (next.result?.duration ?? 0)), startTime), assertionResults = tests.map((t) => {
+			const endTime = tests.reduce((prev, next) => Math.max(prev, (next.result?.startTime ?? 0) + (next.result?.duration ?? 0)), startTime);
+			const assertionResults = tests.map((t) => {
 				const ancestorTitles = [];
 				let iter = t.suite;
-				while (iter) ancestorTitles.push(iter.name), iter = iter.suite;
-				return ancestorTitles.reverse(), {
+				while (iter) {
+					ancestorTitles.push(iter.name);
+					iter = iter.suite;
+				}
+				ancestorTitles.reverse();
+				return {
 					ancestorTitles,
 					fullName: t.name ? [...ancestorTitles, t.name].join(" ") : ancestorTitles.join(" "),
 					status: StatusMap[t.result?.state || t.mode] || "skipped",
@@ -2927,9 +3303,11 @@ class JsonReporter {
 	async writeReport(report) {
 		const outputFile = this.options.outputFile ?? getOutputFile(this.ctx.config, "json");
 		if (outputFile) {
-			const reportFile = resolve$1(this.ctx.config.root, outputFile), outputDirectory = dirname(reportFile);
+			const reportFile = resolve$1(this.ctx.config.root, outputFile);
+			const outputDirectory = dirname(reportFile);
 			if (!existsSync(outputDirectory)) await promises.mkdir(outputDirectory, { recursive: true });
-			await promises.writeFile(reportFile, report, "utf-8"), this.ctx.logger.log(`JSON report written to ${reportFile}`);
+			await promises.writeFile(reportFile, report, "utf-8");
+			this.ctx.logger.log(`JSON report written to ${reportFile}`);
 		} else this.ctx.logger.log(report);
 	}
 }
@@ -2952,7 +3330,8 @@ class IndentedLogger {
 
 function flattenTasks$1(task, baseName = "") {
 	const base = baseName ? `${baseName} > ` : "";
-	return task.type === "suite" ? task.tasks.flatMap((child) => flattenTasks$1(child, `${base}${task.name}`)) : [{
+	if (task.type === "suite") return task.tasks.flatMap((child) => flattenTasks$1(child, `${base}${task.name}`));
+	else return [{
 		...task,
 		name: `${base}${task.name}`
 	}];
@@ -2960,16 +3339,21 @@ function flattenTasks$1(task, baseName = "") {
 // https://gist.github.com/john-doherty/b9195065884cdbfd2017a4756e6409cc
 function removeInvalidXMLCharacters(value, removeDiscouragedChars) {
 	let regex = /([\0-\x08\v\f\x0E-\x1F\uFFFD\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g;
-	if (value = String(value || "").replace(regex, ""), removeDiscouragedChars) regex = new RegExp(
-		/* eslint-disable regexp/prefer-character-class, regexp/no-obscure-range, regexp/no-useless-non-capturing-group */
-		"([\\x7F-\\x84]|[\\x86-\\x9F]|[\\uFDD0-\\uFDEF]|\\uD83F[\\uDFFE\\uDFFF]|(?:\\uD87F[\\uDFFE\\uDFFF])|\\uD8BF[\\uDFFE\\uDFFF]|\\uD8FF[\\uDFFE\\uDFFF]|(?:\\uD93F[\\uDFFE\\uDFFF])|\\uD97F[\\uDFFE\\uDFFF]|\\uD9BF[\\uDFFE\\uDFFF]|\\uD9FF[\\uDFFE\\uDFFF]|\\uDA3F[\\uDFFE\\uDFFF]|\\uDA7F[\\uDFFE\\uDFFF]|\\uDABF[\\uDFFE\\uDFFF]|(?:\\uDAFF[\\uDFFE\\uDFFF])|\\uDB3F[\\uDFFE\\uDFFF]|\\uDB7F[\\uDFFE\\uDFFF]|(?:\\uDBBF[\\uDFFE\\uDFFF])|\\uDBFF[\\uDFFE\\uDFFF](?:[\\0-\\t\\v\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]))",
-		"g"
-		/* eslint-enable */
-	), value = value.replace(regex, "");
+	value = String(value || "").replace(regex, "");
+	{
+		// remove everything discouraged by XML 1.0 specifications
+		regex = new RegExp(
+			/* eslint-disable regexp/prefer-character-class, regexp/no-obscure-range, regexp/no-useless-non-capturing-group */
+			"([\\x7F-\\x84]|[\\x86-\\x9F]|[\\uFDD0-\\uFDEF]|\\uD83F[\\uDFFE\\uDFFF]|(?:\\uD87F[\\uDFFE\\uDFFF])|\\uD8BF[\\uDFFE\\uDFFF]|\\uD8FF[\\uDFFE\\uDFFF]|(?:\\uD93F[\\uDFFE\\uDFFF])|\\uD97F[\\uDFFE\\uDFFF]|\\uD9BF[\\uDFFE\\uDFFF]|\\uD9FF[\\uDFFE\\uDFFF]|\\uDA3F[\\uDFFE\\uDFFF]|\\uDA7F[\\uDFFE\\uDFFF]|\\uDABF[\\uDFFE\\uDFFF]|(?:\\uDAFF[\\uDFFE\\uDFFF])|\\uDB3F[\\uDFFE\\uDFFF]|\\uDB7F[\\uDFFE\\uDFFF]|(?:\\uDBBF[\\uDFFE\\uDFFF])|\\uDBFF[\\uDFFE\\uDFFF](?:[\\0-\\t\\v\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]))",
+			"g"
+			/* eslint-enable */
+		);
+		value = value.replace(regex, "");
+	}
 	return value;
 }
 function escapeXML(value) {
-	return removeInvalidXMLCharacters(String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/</g, "&lt;").replace(/>/g, "&gt;"), true);
+	return removeInvalidXMLCharacters(String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/</g, "&lt;").replace(/>/g, "&gt;"));
 }
 function executionTime(durationMS) {
 	return (durationMS / 1e3).toLocaleString("en-US", {
@@ -2978,8 +3362,7 @@ function executionTime(durationMS) {
 	});
 }
 function getDuration(task) {
-	const duration = task.result?.duration ?? 0;
-	return executionTime(duration);
+	return executionTime(task.result?.duration ?? 0);
 }
 class JUnitReporter {
 	ctx;
@@ -2990,7 +3373,8 @@ class JUnitReporter {
 	fileFd;
 	options;
 	constructor(options) {
-		this.options = { ...options }, this.options.includeConsoleOutput ??= true;
+		this.options = { ...options };
+		this.options.includeConsoleOutput ??= true;
 	}
 	async onInit(ctx) {
 		this.ctx = ctx;
@@ -2999,12 +3383,14 @@ class JUnitReporter {
 			this.reportFile = resolve$1(this.ctx.config.root, outputFile);
 			const outputDirectory = dirname(this.reportFile);
 			if (!existsSync(outputDirectory)) await promises.mkdir(outputDirectory, { recursive: true });
-			this.fileFd = await promises.open(this.reportFile, "w+"), this.baseLog = async (text) => {
+			this.fileFd = await promises.open(this.reportFile, "w+");
+			this.baseLog = async (text) => {
 				if (!this.fileFd) this.fileFd = await promises.open(this.reportFile, "w+");
 				await promises.writeFile(this.fileFd, `${text}\n`);
 			};
 		} else this.baseLog = async (text) => this.ctx.logger.log(text);
-		this._timeStart = /* @__PURE__ */ new Date(), this.logger = new IndentedLogger(this.baseLog);
+		this._timeStart = /* @__PURE__ */ new Date();
+		this.logger = new IndentedLogger(this.baseLog);
 	}
 	async writeElement(name, attrs, children) {
 		const pairs = [];
@@ -3013,12 +3399,18 @@ class JUnitReporter {
 			if (attr === void 0) continue;
 			pairs.push(`${key}="${escapeXML(attr)}"`);
 		}
-		await this.logger.log(`<${name}${pairs.length ? ` ${pairs.join(" ")}` : ""}>`), this.logger.indent(), await children.call(this), this.logger.unindent(), await this.logger.log(`</${name}>`);
+		await this.logger.log(`<${name}${pairs.length ? ` ${pairs.join(" ")}` : ""}>`);
+		this.logger.indent();
+		await children.call(this);
+		this.logger.unindent();
+		await this.logger.log(`</${name}>`);
 	}
 	async writeLogs(task, type) {
 		if (task.logs == null || task.logs.length === 0) return;
-		const logType = type === "err" ? "stderr" : "stdout", logs = task.logs.filter((log) => log.type === logType);
-		logs.length !== 0 && await this.writeElement(`system-${type}`, {}, async () => {
+		const logType = type === "err" ? "stderr" : "stdout";
+		const logs = task.logs.filter((log) => log.type === logType);
+		if (logs.length === 0) return;
+		await this.writeElement(`system-${type}`, {}, async () => {
 			for (const log of logs) await this.baseLog(escapeXML(log.content));
 		});
 	}
@@ -3037,12 +3429,20 @@ class JUnitReporter {
 				name: task.name,
 				time: getDuration(task)
 			}, async () => {
-				if (this.options.includeConsoleOutput) await this.writeLogs(task, "out"), await this.writeLogs(task, "err");
+				if (this.options.includeConsoleOutput) {
+					await this.writeLogs(task, "out");
+					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>"), this.logger.indent();
-					for (const annotation of task.annotations) await this.logger.log(`<property name="${escapeXML(annotation.type)}" value="${escapeXML(annotation.message)}">`), await this.logger.log("</property>");
-					this.logger.unindent(), await this.logger.log("</properties>");
+					await this.logger.log("<properties>");
+					this.logger.indent();
+					for (const annotation of task.annotations) {
+						await this.logger.log(`<property name="${escapeXML(annotation.type)}" value="${escapeXML(annotation.message)}">`);
+						await this.logger.log("</property>");
+					}
+					this.logger.unindent();
+					await this.logger.log("</properties>");
 				}
 				if (task.result?.state === "fail") {
 					const errors = task.result.errors || [];
@@ -3065,7 +3465,8 @@ class JUnitReporter {
 		const files = testModules.map((testModule) => testModule.task);
 		await this.logger.log("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
 		const transformed = files.map((file) => {
-			const tasks = file.tasks.flatMap((task) => flattenTasks$1(task)), stats = tasks.reduce((stats, task) => {
+			const tasks = file.tasks.flatMap((task) => flattenTasks$1(task));
+			const stats = tasks.reduce((stats, task) => {
 				return {
 					passed: stats.passed + Number(task.result?.state === "pass"),
 					failures: stats.failures + Number(task.result?.state === "fail"),
@@ -3075,29 +3476,41 @@ class JUnitReporter {
 				passed: 0,
 				failures: 0,
 				skipped: 0
-			}), suites = getSuites(file);
-			for (const suite of suites) if (suite.result?.errors) tasks.push(suite), stats.failures += 1;
-			// If there are no tests, but the file failed to load, we still want to report it as a failure
-			if (tasks.length === 0 && file.result?.state === "fail") stats.failures = 1, tasks.push({
-				id: file.id,
-				type: "test",
-				name: file.name,
-				mode: "run",
-				result: file.result,
-				meta: {},
-				timeout: 0,
-				context: null,
-				suite: null,
-				file: null,
-				annotations: []
 			});
+			// inject failed suites to surface errors during beforeAll/afterAll
+			const suites = getSuites(file);
+			for (const suite of suites) if (suite.result?.errors) {
+				tasks.push(suite);
+				stats.failures += 1;
+			}
+			// If there are no tests, but the file failed to load, we still want to report it as a failure
+			if (tasks.length === 0 && file.result?.state === "fail") {
+				stats.failures = 1;
+				tasks.push({
+					id: file.id,
+					type: "test",
+					name: file.name,
+					mode: "run",
+					result: file.result,
+					meta: {},
+					timeout: 0,
+					context: null,
+					suite: null,
+					file: null,
+					annotations: []
+				});
+			}
 			return {
 				...file,
 				tasks,
 				stats
 			};
-		}), stats = transformed.reduce((stats, file) => {
-			return stats.tests += file.tasks.length, stats.failures += file.stats.failures, stats.time += file.result?.duration || 0, stats;
+		});
+		const stats = transformed.reduce((stats, file) => {
+			stats.tests += file.tasks.length;
+			stats.failures += file.stats.failures;
+			stats.time += file.result?.duration || 0;
+			return stats;
 		}, {
 			name: this.options.suiteName || "vitest tests",
 			tests: 0,
@@ -3105,7 +3518,7 @@ class JUnitReporter {
 			errors: 0,
 			time: 0
 		});
-		if (await this.writeElement("testsuites", {
+		await this.writeElement("testsuites", {
 			...stats,
 			time: executionTime(stats.time)
 		}, async () => {
@@ -3124,13 +3537,16 @@ class JUnitReporter {
 					await this.writeTasks(file.tasks, filename);
 				});
 			}
-		}), this.reportFile) this.ctx.logger.log(`JUNIT report written to ${this.reportFile}`);
-		await this.fileFd?.close(), this.fileFd = void 0;
+		});
+		if (this.reportFile) this.ctx.logger.log(`JUNIT report written to ${this.reportFile}`);
+		await this.fileFd?.close();
+		this.fileFd = void 0;
 	}
 }
 
 function yamlString(str) {
-	return str ? `"${str.replace(/"/g, "\\\"")}"` : "";
+	if (!str) return "";
+	return `"${str.replace(/"/g, "\\\"")}"`;
 }
 function tapString(str) {
 	return str.replace(/\\/g, "\\\\").replace(/#/g, "\\#").replace(/\n/g, " ");
@@ -3139,45 +3555,77 @@ class TapReporter {
 	ctx;
 	logger;
 	onInit(ctx) {
-		this.ctx = ctx, this.logger = new IndentedLogger(ctx.logger.log.bind(ctx.logger));
+		this.ctx = ctx;
+		this.logger = new IndentedLogger(ctx.logger.log.bind(ctx.logger));
 	}
 	static getComment(task) {
-		return task.mode === "skip" ? " # SKIP" : task.mode === "todo" ? " # TODO" : task.result?.duration == null ? "" : ` # time=${task.result.duration.toFixed(2)}ms`;
+		if (task.mode === "skip") return " # SKIP";
+		else if (task.mode === "todo") return " # TODO";
+		else if (task.result?.duration != null) return ` # time=${task.result.duration.toFixed(2)}ms`;
+		else return "";
 	}
 	logErrorDetails(error, stack) {
 		const errorName = error.name || "Unknown Error";
-		if (this.logger.log(`name: ${yamlString(String(errorName))}`), this.logger.log(`message: ${yamlString(String(error.message))}`), stack)
+		this.logger.log(`name: ${yamlString(String(errorName))}`);
+		this.logger.log(`message: ${yamlString(String(error.message))}`);
+		if (stack)
  // For compatibility with tap-mocha-reporter
 		this.logger.log(`stack: ${yamlString(`${stack.file}:${stack.line}:${stack.column}`)}`);
 	}
 	logTasks(tasks) {
 		this.logger.log(`1..${tasks.length}`);
 		for (const [i, task] of tasks.entries()) {
-			const id = i + 1, ok = task.result?.state === "pass" || task.mode === "skip" || task.mode === "todo" ? "ok" : "not ok", comment = TapReporter.getComment(task);
-			if (task.type === "suite" && task.tasks.length > 0) this.logger.log(`${ok} ${id} - ${tapString(task.name)}${comment} {`), this.logger.indent(), this.logTasks(task.tasks), this.logger.unindent(), this.logger.log("}");
-			else {
+			const id = i + 1;
+			const ok = task.result?.state === "pass" || task.mode === "skip" || task.mode === "todo" ? "ok" : "not ok";
+			const comment = TapReporter.getComment(task);
+			if (task.type === "suite" && task.tasks.length > 0) {
+				this.logger.log(`${ok} ${id} - ${tapString(task.name)}${comment} {`);
+				this.logger.indent();
+				this.logTasks(task.tasks);
+				this.logger.unindent();
+				this.logger.log("}");
+			} else {
 				this.logger.log(`${ok} ${id} - ${tapString(task.name)}${comment}`);
 				const project = this.ctx.getProjectByName(task.file.projectName || "");
-				if (task.type === "test" && task.annotations) this.logger.indent(), task.annotations.forEach(({ type, message }) => {
-					this.logger.log(`# ${type}: ${message}`);
-				}), this.logger.unindent();
-				if (task.result?.state === "fail" && task.result.errors) this.logger.indent(), task.result.errors.forEach((error) => {
-					const stack = (task.file.pool === "browser" ? project.browser?.parseErrorStacktrace(error) || [] : parseErrorStacktrace(error, { frameFilter: this.ctx.config.onStackTrace }))[0];
-					if (this.logger.log("---"), this.logger.log("error:"), this.logger.indent(), this.logErrorDetails(error), this.logger.unindent(), stack) this.logger.log(`at: ${yamlString(`${stack.file}:${stack.line}:${stack.column}`)}`);
-					if (error.showDiff) this.logger.log(`actual: ${yamlString(error.actual)}`), this.logger.log(`expected: ${yamlString(error.expected)}`);
-				}), this.logger.log("..."), this.logger.unindent();
+				if (task.type === "test" && task.annotations) {
+					this.logger.indent();
+					task.annotations.forEach(({ type, message }) => {
+						this.logger.log(`# ${type}: ${message}`);
+					});
+					this.logger.unindent();
+				}
+				if (task.result?.state === "fail" && task.result.errors) {
+					this.logger.indent();
+					task.result.errors.forEach((error) => {
+						const stack = (task.file.pool === "browser" ? project.browser?.parseErrorStacktrace(error) || [] : parseErrorStacktrace(error, { frameFilter: this.ctx.config.onStackTrace }))[0];
+						this.logger.log("---");
+						this.logger.log("error:");
+						this.logger.indent();
+						this.logErrorDetails(error);
+						this.logger.unindent();
+						if (stack) this.logger.log(`at: ${yamlString(`${stack.file}:${stack.line}:${stack.column}`)}`);
+						if (error.showDiff) {
+							this.logger.log(`actual: ${yamlString(error.actual)}`);
+							this.logger.log(`expected: ${yamlString(error.expected)}`);
+						}
+					});
+					this.logger.log("...");
+					this.logger.unindent();
+				}
 			}
 		}
 	}
 	onTestRunEnd(testModules) {
 		const files = testModules.map((testModule) => testModule.task);
-		this.logger.log("TAP version 13"), this.logTasks(files);
+		this.logger.log("TAP version 13");
+		this.logTasks(files);
 	}
 }
 
 function flattenTasks(task, baseName = "") {
 	const base = baseName ? `${baseName} > ` : "";
-	return task.type === "suite" && task.tasks.length > 0 ? task.tasks.flatMap((child) => flattenTasks(child, `${base}${task.name}`)) : [{
+	if (task.type === "suite" && task.tasks.length > 0) return task.tasks.flatMap((child) => flattenTasks(child, `${base}${task.name}`));
+	else return [{
 		...task,
 		name: `${base}${task.name}`
 	}];
@@ -3209,9 +3657,18 @@ class VerboseReporter extends DefaultReporter {
 		const testResult = test.result();
 		if (this.ctx.config.hideSkippedTests && testResult.state === "skipped") return;
 		let title = ` ${this.getEntityPrefix(test)} `;
-		if (title += test.module.task.name, test.location) title += c.dim(`:${test.location.line}:${test.location.column}`);
-		if (title += separator, title += getTestName(test.task, separator), title += this.getTestCaseSuffix(test), this.log(title), testResult.state === "failed") testResult.errors.forEach((error) => this.log(c.red(`   ${F_RIGHT} ${error.message}`)));
-		if (test.annotations().length) this.log(), this.printAnnotations(test, "log", 3), this.log();
+		title += test.module.task.name;
+		if (test.location) title += c.dim(`:${test.location.line}:${test.location.column}`);
+		title += separator;
+		title += getTestName(test.task, separator);
+		title += this.getTestCaseSuffix(test);
+		this.log(title);
+		if (testResult.state === "failed") testResult.errors.forEach((error) => this.log(c.red(`   ${F_RIGHT} ${error.message}`)));
+		if (test.annotations().length) {
+			this.log();
+			this.printAnnotations(test, "log", 3);
+			this.log();
+		}
 	}
 }