vitest 3.2.0-beta.1 → 3.2.0-beta.3

package/dist/chunks/{index.CUacZlWG.js → index.Bter3jj9.js}

@@ -1,540 +1,219 @@
-import fs, { existsSync, readFileSync, promises } from 'node:fs';
+import { performance as performance$1 } from 'node:perf_hooks';
 import { getTestName, hasFailed, getFullName, getTests, getSuites, getTasks } from '@vitest/runner/utils';
-import * as pathe from 'pathe';
-import { relative, normalize, resolve, dirname } from 'pathe';
+import { slash, toArray, isPrimitive, inspect, positionToOffset, lineSplitRE } from '@vitest/utils';
+import { parseStacktrace, parseErrorStacktrace } from '@vitest/utils/source-map';
+import { isAbsolute, relative, dirname, basename, resolve, normalize } from 'pathe';
 import c from 'tinyrainbow';
-import { t as truncateString, e as errorBanner, F as F_POINTER, d as divider, f as formatTimeString, a as taskFail, b as F_CHECK, g as getStateSymbol, c as formatProjectName, h as F_RIGHT, w as withLabel, r as renderSnapshotSummary, p as padSummaryTitle, i as getStateString$1, j as formatTime, k as countTestErrors, l as F_TREE_NODE_END, m as F_TREE_NODE_MIDDLE } from './utils.8gfOgtry.js';
-import { stripVTControlCharacters } from 'node:util';
-import { positionToOffset, lineSplitRE, isPrimitive, inspect, toArray, notNullish } from '@vitest/utils';
-import { performance as performance$1 } from 'node:perf_hooks';
-import { parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
 import { i as isTTY } from './env.Dq0hM4Xv.js';
-import { T as TypeCheckError, g as getOutputFile, h as hasFailedSnapshot } from './typechecker.DYQbn8uK.js';
-import { readdir, stat, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { h as hasFailedSnapshot, g as getOutputFile, T as TypeCheckError } from './typechecker.BgzF-6iO.js';
+import { stripVTControlCharacters } from 'node:util';
+import { existsSync, readFileSync, promises } from 'node:fs';
+import { mkdir, writeFile, readdir, stat, readFile } from 'node:fs/promises';
 import { Console } from 'node:console';
 import { Writable } from 'node:stream';
 import { createRequire } from 'node:module';
 import { hostname } from 'node:os';
 
-/// <reference types="../types/index.d.ts" />
-
-// (c) 2020-present Andrea Giammarchi
-
-const {parse: $parse, stringify: $stringify} = JSON;
-const {keys} = Object;
-
-const Primitive = String;   // it could be Number
-const primitive = 'string'; // it could be 'number'
-
-const ignore = {};
-const object = 'object';
-
-const noop = (_, value) => value;
-
-const primitives = value => (
-  value instanceof Primitive ? Primitive(value) : value
-);
-
-const Primitives = (_, value) => (
-  typeof value === primitive ? new Primitive(value) : value
-);
-
-const revive = (input, parsed, output, $) => {
-  const lazy = [];
-  for (let ke = keys(output), {length} = ke, y = 0; y < length; y++) {
-    const k = ke[y];
-    const value = output[k];
-    if (value instanceof Primitive) {
-      const tmp = input[value];
-      if (typeof tmp === object && !parsed.has(tmp)) {
-        parsed.add(tmp);
-        output[k] = ignore;
-        lazy.push({k, a: [input, parsed, tmp, $]});
-      }
-      else
-        output[k] = $.call(output, k, tmp);
-    }
-    else if (output[k] !== ignore)
-      output[k] = $.call(output, k, value);
-  }
-  for (let {length} = lazy, i = 0; i < length; i++) {
-    const {k, a} = lazy[i];
-    output[k] = $.call(output, k, revive.apply(null, a));
-  }
-  return output;
-};
-
-const set = (known, input, value) => {
-  const index = Primitive(input.push(value) - 1);
-  known.set(value, index);
-  return index;
-};
-
-/**
- * Converts a specialized flatted string into a JS value.
- * @param {string} text
- * @param {(this: any, key: string, value: any) => any} [reviver]
- * @returns {any}
- */
-const parse = (text, reviver) => {
-  const input = $parse(text, Primitives).map(primitives);
-  const value = input[0];
-  const $ = reviver || noop;
-  const tmp = typeof value === object && value ?
-              revive(input, new Set, value, $) :
-              value;
-  return $.call({'': tmp}, '', tmp);
-};
-
-/**
- * Converts a JS value into a specialized flatted string.
- * @param {any} value
- * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
- * @param {string | number | undefined} [space]
- * @returns {string}
- */
-const stringify = (value, replacer, space) => {
-  const $ = replacer && typeof replacer === object ?
-            (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) :
-            (replacer || noop);
-  const known = new Map;
-  const input = [];
-  const output = [];
-  let i = +set(known, input, $.call({'': value}, '', value));
-  let firstRun = !i;
-  while (i < input.length) {
-    firstRun = true;
-    output[i] = $stringify(input[i++], replace, space);
-  }
-  return '[' + output.join(',') + ']';
-  function replace(key, value) {
-    if (firstRun) {
-      firstRun = !firstRun;
-      return value;
-    }
-    const after = $.call(this, key, value);
-    switch (typeof after) {
-      case object:
-        if (after === null) return after;
-      case primitive:
-        return known.get(after) || set(known, input, after);
-    }
-    return after;
-  }
-};
+const F_RIGHT = "→";
+const F_DOWN = "↓";
+const F_DOWN_RIGHT = "↳";
+const F_POINTER = "❯";
+const F_DOT = "·";
+const F_CHECK = "✓";
+const F_CROSS = "×";
+const F_LONG_DASH = "⎯";
+const F_TREE_NODE_MIDDLE = "├──";
+const F_TREE_NODE_END = "└──";
 
-function capturePrintError(error, ctx, options) {
-	let output = "";
-	const writable = new Writable({ write(chunk, _encoding, callback) {
-		output += String(chunk);
-		callback();
-	} });
-	const console = new Console(writable);
-	const logger = {
-		error: console.error.bind(console),
-		highlight: ctx.logger.highlight.bind(ctx.logger)
-	};
-	const result = printError(error, ctx, logger, {
-		showCodeFrame: false,
-		...options
-	});
-	return {
-		nearest: result?.nearest,
-		output
-	};
+const pointer = c.yellow(F_POINTER);
+const skipped = c.dim(c.gray(F_DOWN));
+const benchmarkPass = c.green(F_DOT);
+const testPass = c.green(F_CHECK);
+const taskFail = c.red(F_CROSS);
+const suiteFail = c.red(F_POINTER);
+const pending$1 = c.gray("·");
+const labelDefaultColors = [
+	c.bgYellow,
+	c.bgCyan,
+	c.bgGreen,
+	c.bgMagenta
+];
+function getCols(delta = 0) {
+	let length = process.stdout?.columns;
+	if (!length || Number.isNaN(length)) {
+		length = 30;
+	}
+	return Math.max(length + delta, 0);
 }
-function printError(error, ctx, logger, options) {
-	const project = options.project ?? ctx.coreWorkspaceProject ?? ctx.projects[0];
-	return printErrorInner(error, project, {
-		logger,
-		type: options.type,
-		showCodeFrame: options.showCodeFrame,
-		screenshotPaths: options.screenshotPaths,
-		printProperties: options.verbose,
-		parseErrorStacktrace(error) {
-			if (options.task?.file.pool === "browser" && project.browser) {
-				return project.browser.parseErrorStacktrace(error, { ignoreStackEntries: options.fullStack ? [] : undefined });
-			}
-			return parseErrorStacktrace(error, {
-				frameFilter: project.config.onStackTrace,
-				ignoreStackEntries: options.fullStack ? [] : undefined
-			});
+function errorBanner(message) {
+	return divider(c.bold(c.bgRed(` ${message} `)), null, null, c.red);
+}
+function divider(text, left, right, color) {
+	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;
 		}
-	});
+		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 printErrorInner(error, project, options) {
-	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],
-			stack: String(error)
-		};
+function formatTestPath(root, path) {
+	if (isAbsolute(path)) {
+		path = relative(root, path);
+	}
+	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) {
+	const summary = [];
+	if (snapshots.added) {
+		summary.push(c.bold(c.green(`${snapshots.added} written`)));
 	}
-	if (!e) {
-		const error = new Error("unknown error");
-		e = {
-			message: e ?? error.message,
-			stack: error.stack
-		};
+	if (snapshots.unmatched) {
+		summary.push(c.bold(c.red(`${snapshots.unmatched} failed`)));
 	}
-	if (!project) {
-		printErrorMessage(e, logger);
-		return;
+	if (snapshots.updated) {
+		summary.push(c.bold(c.green(`${snapshots.updated} updated `)));
 	}
-	const stacks = options.parseErrorStacktrace(e);
-	const nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find((stack) => {
-		try {
-			return project.server && project.getModuleById(stack.file) && existsSync(stack.file);
-		} catch {
-			return false;
+	if (snapshots.filesRemoved) {
+		if (snapshots.didUpdate) {
+			summary.push(c.bold(c.green(`${snapshots.filesRemoved} files removed `)));
+		} else {
+			summary.push(c.bold(c.yellow(`${snapshots.filesRemoved} files obsolete `)));
 		}
-	});
-	if (type) {
-		printErrorType(type, project.vitest);
 	}
-	printErrorMessage(e, logger);
-	if (options.screenshotPaths?.length) {
-		const length = options.screenshotPaths.length;
-		logger.error(`\nFailure screenshot${length > 1 ? "s" : ""}:`);
-		logger.error(options.screenshotPaths.map((p) => `  - ${c.dim(relative(process.cwd(), p))}`).join("\n"));
-		if (!e.diff) {
-			logger.error();
+	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_DOT)} ${formatTestPath(rootDir, key)}`);
+		});
+	}
+	if (snapshots.unchecked) {
+		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}`));
+		});
 	}
-	if (e.codeFrame) {
-		logger.error(`${e.codeFrame}\n`);
+	return summary;
+}
+function countTestErrors(tasks) {
+	return tasks.reduce((c, i) => c + (i.result?.errors?.length || 0), 0);
+}
+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");
+	const failed = tasks.filter((i) => i.result?.state === "fail");
+	const skipped = tasks.filter((i) => i.mode === "skip");
+	const todo = tasks.filter((i) => i.mode === "todo");
+	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
+	].filter(Boolean).join(c.dim(" | ")) + (showTotal ? c.gray(` (${tasks.length})`) : "");
+}
+function getStateSymbol(task) {
+	if (task.mode === "skip" || task.mode === "todo") {
+		return skipped;
 	}
-	if ("__vitest_rollup_error__" in e) {
-		const err = e.__vitest_rollup_error__;
-		logger.error([
-			err.plugin && `  Plugin: ${c.magenta(err.plugin)}`,
-			err.id && `  File: ${c.cyan(err.id)}${err.loc ? `:${err.loc.line}:${err.loc.column}` : ""}`,
-			err.frame && c.yellow(err.frame.split(/\r?\n/g).map((l) => ` `.repeat(2) + l).join(`\n`))
-		].filter(Boolean).join("\n"));
+	if (!task.result) {
+		return pending$1;
 	}
-	if (e.diff) {
-		logger.error(`\n${e.diff}\n`);
+	if (task.result.state === "run" || task.result.state === "queued") {
+		if (task.type === "suite") {
+			return pointer;
+		}
 	}
-	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));
-			}
-		});
+	if (task.result.state === "pass") {
+		return task.meta?.benchmark ? benchmarkPass : testPass;
 	}
-	const testPath = e.VITEST_TEST_PATH;
-	const testName = e.VITEST_TEST_NAME;
-	const afterEnvTeardown = e.VITEST_AFTER_ENV_TEARDOWN;
-	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 (task.result.state === "fail") {
+		return task.type === "suite" ? suiteFail : taskFail;
 	}
-	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:` + "\n- The error was thrown, while Vitest was running this test." + "\n- If the error occurred after the test had been completed, this was the last documented test before it was thrown."));
+	return " ";
+}
+function formatTimeString(date) {
+	return date.toTimeString().split(" ")[0];
+}
+function formatTime(time) {
+	if (time > 1e3) {
+		return `${(time / 1e3).toFixed(2)}s`;
 	}
-	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"));
+	return `${Math.round(time)}ms`;
+}
+function formatProjectName(project, suffix = " ") {
+	if (!project?.name) {
+		return "";
 	}
-	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
-		});
+	if (!c.isColorSupported) {
+		return `|${project.name}|${suffix}`;
 	}
-	handleImportOutsideModuleError(e.stack || e.stackStr || "", logger);
-	return { nearest };
+	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];
+	}
+	return c.black(background(` ${project.name} `)) + suffix;
 }
-function printErrorType(type, ctx) {
-	ctx.logger.error(`\n${errorBanner(type)}`);
+function withLabel(color, label, message) {
+	const bgColor = `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
+	return `${c.bold(c[bgColor](` ${label} `))} ${message ? c[color](message) : ""}`;
 }
-const skipErrorProperties = new Set([
-	"nameStr",
-	"stack",
-	"cause",
-	"stacks",
-	"stackStr",
-	"type",
-	"showDiff",
-	"ok",
-	"operator",
-	"diff",
-	"codeFrame",
-	"actual",
-	"expected",
-	"diffOptions",
-	"sourceURL",
-	"column",
-	"line",
-	"fileName",
-	"lineNumber",
-	"columnNumber",
-	"VITEST_TEST_NAME",
-	"VITEST_TEST_PATH",
-	"VITEST_AFTER_ENV_TEARDOWN",
-	...Object.getOwnPropertyNames(Error.prototype),
-	...Object.getOwnPropertyNames(Object.prototype)
-]);
-function getErrorProperties(e) {
-	const errorObject = Object.create(null);
-	if (e.name === "AssertionError") {
-		return errorObject;
-	}
-	for (const key of Object.getOwnPropertyNames(e)) {
-		if (!skipErrorProperties.has(key)) {
-			errorObject[key] = e[key];
-		}
-	}
-	return errorObject;
+function padSummaryTitle(str) {
+	return c.dim(`${str.padStart(11)} `);
 }
-const esmErrors = ["Cannot use import statement outside a module", "Unexpected token 'export'"];
-function handleImportOutsideModuleError(stack, logger) {
-	if (!esmErrors.some((e) => stack.includes(e))) {
-		return;
-	}
-	const path = normalize(stack.split("\n")[0].trim());
-	let name = path.split("/node_modules/").pop() || "";
-	if (name?.startsWith("@")) {
-		name = name.split("/").slice(0, 2).join("/");
-	} else {
-		name = name.split("/")[0];
-	}
-	if (name) {
-		printModuleWarningForPackage(logger, path, name);
-	} else {
-		printModuleWarningForSourceCode(logger, path);
+function truncateString(text, maxLength) {
+	const plainText = stripVTControlCharacters(text);
+	if (plainText.length <= maxLength) {
+		return text;
 	}
+	return `${plainText.slice(0, maxLength - 1)}…`;
 }
-function printModuleWarningForPackage(logger, path, name) {
-	logger.error(c.yellow(`Module ${path} seems to be an ES Module but shipped in a CommonJS package. ` + `You might want to create an issue to the package ${c.bold(`"${name}"`)} asking ` + "them to ship the file in .mjs extension or add \"type\": \"module\" in their package.json." + "\n\n" + "As a temporary workaround you can try to inline the package by updating your config:" + "\n\n" + c.gray(c.dim("// vitest.config.js")) + "\n" + c.green(`export default {
-  test: {
-    server: {
-      deps: {
-        inline: [
-          ${c.yellow(c.bold(`"${name}"`))}
-        ]
-      }
-    }
-  }
-}\n`)));
-}
-function printModuleWarningForSourceCode(logger, path) {
-	logger.error(c.yellow(`Module ${path} seems to be an ES Module but shipped in a CommonJS package. ` + "To fix this issue, change the file extension to .mjs or add \"type\": \"module\" in your package.json."));
-}
-function printErrorMessage(error, logger) {
-	const errorName = error.name || error.nameStr || "Unknown Error";
-	if (!error.message) {
-		logger.error(error);
-		return;
-	}
-	if (error.message.length > 5e3) {
-		logger.error(`${c.red(c.bold(errorName))}: ${error.message}`);
-	} else {
-		logger.error(c.red(`${c.bold(errorName)}: ${error.message}`));
-	}
-}
-function printStack(logger, project, stack, highlight, errorProperties, onStack) {
-	for (const frame of stack) {
-		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)) {
-		logger.error(c.red(c.dim(divider())));
-		const propertiesString = inspect(errorProperties);
-		logger.error(c.red(c.bold("Serialized Error:")), c.gray(propertiesString));
-	}
-}
-function hasProperties(obj) {
-	for (const _key in obj) {
-		return true;
-	}
-	return false;
-}
-function generateCodeFrame(source, indent = 0, loc, range = 2) {
-	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++) {
-		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;
-				if (stripVTControlCharacters(lines[j]).length > 200) {
-					return "";
-				}
-				res.push(lineNo(j + 1) + truncateString(lines[j].replace(/\t/g, " "), columns - 5 - indent));
-				if (j === i) {
-					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) {
-						const length = Math.max(1, Math.min(end - count, lineLength));
-						res.push(lineNo() + c.red("^".repeat(length)));
-					}
-					count += lineLength + 1;
-				}
-			}
-			break;
-		}
-	}
-	if (indent) {
-		res = res.map((line) => " ".repeat(indent) + line);
-	}
-	return res.join("\n");
-}
-function lineNo(no = "") {
-	return c.gray(`${String(no).padStart(3, " ")}| `);
-}
-
-class BlobReporter {
-	start = 0;
-	ctx;
-	options;
-	constructor(options) {
-		this.options = options;
-	}
-	onInit(ctx) {
-		if (ctx.config.watch) {
-			throw new Error("Blob reporter is not supported in watch mode");
-		}
-		this.ctx = ctx;
-		this.start = performance.now();
-	}
-	async onFinished(files = [], errors = [], coverage) {
-		const executionTime = performance.now() - this.start;
-		let outputFile = this.options.outputFile ?? getOutputFile(this.ctx.config, "blob");
-		if (!outputFile) {
-			const shard = this.ctx.config.shard;
-			outputFile = shard ? `.vitest-reports/blob-${shard.index}-${shard.count}.json` : ".vitest-reports/blob.json";
-		}
-		const modules = this.ctx.projects.map((project) => {
-			return [project.name, [...project.vite.moduleGraph.idToModuleMap.entries()].map((mod) => {
-				if (!mod[1].file) {
-					return null;
-				}
-				return [
-					mod[0],
-					mod[1].file,
-					mod[1].url
-				];
-			}).filter((x) => x != null)];
-		});
-		const report = [
-			this.ctx.version,
-			files,
-			errors,
-			modules,
-			coverage,
-			executionTime
-		];
-		const reportFile = resolve(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);
-	const dir = dirname(filename);
-	if (!existsSync(dir)) {
-		await mkdir(dir, { recursive: true });
-	}
-	await writeFile(filename, report, "utf-8");
-}
-async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
-	const resolvedDir = resolve(process.cwd(), blobsDirectory);
-	const blobsFiles = await readdir(resolvedDir);
-	const promises = blobsFiles.map(async (filename) => {
-		const fullPath = resolve(resolvedDir, filename);
-		const stats = await stat(fullPath);
-		if (!stats.isFile()) {
-			throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
-		}
-		const content = await readFile(fullPath, "utf-8");
-		const [version, files, errors, moduleKeys, coverage, executionTime] = parse(content);
-		if (!version) {
-			throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a valid blob file`);
-		}
-		return {
-			version,
-			files,
-			errors,
-			moduleKeys,
-			coverage,
-			file: filename,
-			executionTime
-		};
-	});
-	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")}`);
-	}
-	if (!versions.has(currentVersion)) {
-		throw new Error(`the blobs in "${blobsDirectory}" were generated by a different version of Vitest. Expected v${currentVersion}, but received v${blobs[0].version}`);
-	}
-	const projects = Object.fromEntries(projectsArray.map((p) => [p.name, p]));
-	blobs.forEach((blob) => {
-		blob.moduleKeys.forEach(([projectName, moduleIds]) => {
-			const project = projects[projectName];
-			if (!project) {
-				return;
-			}
-			moduleIds.forEach(([moduleId, file, url]) => {
-				const moduleNode = project.vite.moduleGraph.createFileOnlyEntry(file);
-				moduleNode.url = url;
-				moduleNode.id = moduleId;
-				project.vite.moduleGraph.idToModuleMap.set(moduleId, moduleNode);
-			});
-		});
-	});
-	const files = blobs.flatMap((blob) => blob.files).sort((f1, f2) => {
-		const time1 = f1.result?.startTime || 0;
-		const time2 = f2.result?.startTime || 0;
-		return time1 - time2;
-	});
-	const errors = blobs.flatMap((blob) => blob.errors);
-	const coverages = blobs.map((blob) => blob.coverage);
-	const executionTimes = blobs.map((blob) => blob.executionTime);
-	return {
-		files,
-		errors,
-		coverages,
-		executionTimes
-	};
+function capitalize(text) {
+	return `${text[0].toUpperCase()}${text.slice(1)}`;
 }
 
-class HangingProcessReporter {
-	whyRunning;
-	onInit() {
-		const _require = createRequire(import.meta.url);
-		this.whyRunning = _require("why-is-node-running");
-	}
-	onProcessTimeout() {
-		this.whyRunning?.();
-	}
-}
+var utils = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  benchmarkPass: benchmarkPass,
+  countTestErrors: countTestErrors,
+  divider: divider,
+  errorBanner: errorBanner,
+  formatProjectName: formatProjectName,
+  formatTestPath: formatTestPath,
+  formatTime: formatTime,
+  formatTimeString: formatTimeString,
+  getStateString: getStateString$1,
+  getStateSymbol: getStateSymbol,
+  padSummaryTitle: padSummaryTitle,
+  pending: pending$1,
+  pointer: pointer,
+  renderSnapshotSummary: renderSnapshotSummary,
+  skipped: skipped,
+  suiteFail: suiteFail,
+  taskFail: taskFail,
+  testPass: testPass,
+  truncateString: truncateString,
+  withLabel: withLabel
+});
 
 const BADGE_PADDING = "       ";
 class BaseReporter {
@@ -604,6 +283,8 @@ class BaseReporter {
 		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 = [];
 		const originalLog = this.log.bind(this);
 		this.log = (msg) => logs.push(msg);
@@ -611,6 +292,7 @@ class BaseReporter {
 			for (const child of children) {
 				if (child.type === "suite") {
 					const suiteState = child.state();
+					// Skipped suites are hidden when --hideSkippedTests, print otherwise
 					if (!this.ctx.config.hideSkippedTests || suiteState !== "skipped") {
 						this.printTestSuite(child);
 					}
@@ -624,6 +306,7 @@ class BaseReporter {
 						skippedCount++;
 					}
 					if (this.ctx.config.hideSkippedTests && suiteState === "skipped") {
+						// Skipped suites are hidden when --hideSkippedTests
 						continue;
 					}
 					this.printTestCase(moduleState, child);
@@ -655,6 +338,7 @@ class BaseReporter {
 		}
 		if (testResult.state === "failed") {
 			this.log(c.red(` ${padding}${taskFail} ${this.getTestName(test.task, c.dim(" > "))}`) + suffix);
+			// print short errors, full errors will be at the end in summary
 			testResult.errors.forEach((error) => {
 				const message = this.formatShortError(error);
 				if (message) {
@@ -691,7 +375,9 @@ class BaseReporter {
 		}
 		return ` ${title} ${testModule.task.name} ${suffix}`;
 	}
-	printTestSuite(_suite) {}
+	printTestSuite(_suite) {
+		// Suite name is included in getTestName by default
+	}
 	getTestName(test, separator) {
 		return getTestName(test, separator);
 	}
@@ -728,6 +414,7 @@ class BaseReporter {
 	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
 		files.forEach((filepath) => {
 			let reruns = this._filesInWatchMode.get(filepath) ?? 0;
 			this._filesInWatchMode.set(filepath, ++reruns);
@@ -770,6 +457,7 @@ class BaseReporter {
 		}
 		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");
 			}
@@ -841,6 +529,7 @@ class BaseReporter {
 			this.log(padSummaryTitle("Duration"), formatTime(collectTime + testsTime + setupTime));
 		} else {
 			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);
@@ -906,6 +595,7 @@ class BaseReporter {
 	printTaskErrors(tasks, errorDivider) {
 		const errorsQueue = [];
 		for (const task of tasks) {
+			// Merge identical errors
 			task.result?.errors?.forEach((error) => {
 				let previous;
 				if (error?.stackStr) {
@@ -947,25 +637,255 @@ class BaseReporter {
 		}
 	}
 }
-function sum(items, cb) {
-	return items.reduce((total, next) => {
-		return total + Math.max(cb(next) || 0, 0);
-	}, 0);
-}
-
-class BasicReporter extends BaseReporter {
-	constructor() {
-		super();
-		this.isTTY = false;
+function sum(items, cb) {
+	return items.reduce((total, next) => {
+		return total + Math.max(cb(next) || 0, 0);
+	}, 0);
+}
+
+class BasicReporter extends BaseReporter {
+	constructor() {
+		super();
+		this.isTTY = false;
+	}
+	onInit(ctx) {
+		super.onInit(ctx);
+		ctx.logger.deprecate(`'basic' reporter is deprecated and will be removed in Vitest v3.\n` + `Remove 'basic' from 'reporters' option. To match 'basic' reporter 100%, use configuration:\n${JSON.stringify({ test: { reporters: [["default", { summary: false }]] } }, null, 2)}`);
+	}
+	reportSummary(files, errors) {
+		// non-tty mode doesn't add a new line
+		this.ctx.logger.log();
+		return super.reportSummary(files, errors);
+	}
+}
+
+/// <reference types="../types/index.d.ts" />
+
+// (c) 2020-present Andrea Giammarchi
+
+const {parse: $parse, stringify: $stringify} = JSON;
+const {keys} = Object;
+
+const Primitive = String;   // it could be Number
+const primitive = 'string'; // it could be 'number'
+
+const ignore = {};
+const object = 'object';
+
+const noop = (_, value) => value;
+
+const primitives = value => (
+  value instanceof Primitive ? Primitive(value) : value
+);
+
+const Primitives = (_, value) => (
+  typeof value === primitive ? new Primitive(value) : value
+);
+
+const revive = (input, parsed, output, $) => {
+  const lazy = [];
+  for (let ke = keys(output), {length} = ke, y = 0; y < length; y++) {
+    const k = ke[y];
+    const value = output[k];
+    if (value instanceof Primitive) {
+      const tmp = input[value];
+      if (typeof tmp === object && !parsed.has(tmp)) {
+        parsed.add(tmp);
+        output[k] = ignore;
+        lazy.push({k, a: [input, parsed, tmp, $]});
+      }
+      else
+        output[k] = $.call(output, k, tmp);
+    }
+    else if (output[k] !== ignore)
+      output[k] = $.call(output, k, value);
+  }
+  for (let {length} = lazy, i = 0; i < length; i++) {
+    const {k, a} = lazy[i];
+    output[k] = $.call(output, k, revive.apply(null, a));
+  }
+  return output;
+};
+
+const set = (known, input, value) => {
+  const index = Primitive(input.push(value) - 1);
+  known.set(value, index);
+  return index;
+};
+
+/**
+ * Converts a specialized flatted string into a JS value.
+ * @param {string} text
+ * @param {(this: any, key: string, value: any) => any} [reviver]
+ * @returns {any}
+ */
+const parse = (text, reviver) => {
+  const input = $parse(text, Primitives).map(primitives);
+  const value = input[0];
+  const $ = reviver || noop;
+  const tmp = typeof value === object && value ?
+              revive(input, new Set, value, $) :
+              value;
+  return $.call({'': tmp}, '', tmp);
+};
+
+/**
+ * Converts a JS value into a specialized flatted string.
+ * @param {any} value
+ * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
+ * @param {string | number | undefined} [space]
+ * @returns {string}
+ */
+const stringify = (value, replacer, space) => {
+  const $ = replacer && typeof replacer === object ?
+            (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) :
+            (replacer || noop);
+  const known = new Map;
+  const input = [];
+  const output = [];
+  let i = +set(known, input, $.call({'': value}, '', value));
+  let firstRun = !i;
+  while (i < input.length) {
+    firstRun = true;
+    output[i] = $stringify(input[i++], replace, space);
+  }
+  return '[' + output.join(',') + ']';
+  function replace(key, value) {
+    if (firstRun) {
+      firstRun = !firstRun;
+      return value;
+    }
+    const after = $.call(this, key, value);
+    switch (typeof after) {
+      case object:
+        if (after === null) return after;
+      case primitive:
+        return known.get(after) || set(known, input, after);
+    }
+    return after;
+  }
+};
+
+class BlobReporter {
+	start = 0;
+	ctx;
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	onInit(ctx) {
+		if (ctx.config.watch) {
+			throw new Error("Blob reporter is not supported in watch mode");
+		}
+		this.ctx = ctx;
+		this.start = performance.now();
+	}
+	async onFinished(files = [], errors = [], coverage) {
+		const executionTime = performance.now() - this.start;
+		let outputFile = this.options.outputFile ?? getOutputFile(this.ctx.config, "blob");
+		if (!outputFile) {
+			const shard = this.ctx.config.shard;
+			outputFile = shard ? `.vitest-reports/blob-${shard.index}-${shard.count}.json` : ".vitest-reports/blob.json";
+		}
+		const modules = this.ctx.projects.map((project) => {
+			return [project.name, [...project.vite.moduleGraph.idToModuleMap.entries()].map((mod) => {
+				if (!mod[1].file) {
+					return null;
+				}
+				return [
+					mod[0],
+					mod[1].file,
+					mod[1].url
+				];
+			}).filter((x) => x != null)];
+		});
+		const report = [
+			this.ctx.version,
+			files,
+			errors,
+			modules,
+			coverage,
+			executionTime
+		];
+		const reportFile = resolve(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);
+	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(process.cwd(), blobsDirectory);
+	const blobsFiles = await readdir(resolvedDir);
+	const promises = blobsFiles.map(async (filename) => {
+		const fullPath = resolve(resolvedDir, filename);
+		const stats = await stat(fullPath);
+		if (!stats.isFile()) {
+			throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
+		}
+		const content = await readFile(fullPath, "utf-8");
+		const [version, files, errors, moduleKeys, coverage, executionTime] = parse(content);
+		if (!version) {
+			throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a valid blob file`);
+		}
+		return {
+			version,
+			files,
+			errors,
+			moduleKeys,
+			coverage,
+			file: filename,
+			executionTime
+		};
+	});
+	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`);
 	}
-	onInit(ctx) {
-		super.onInit(ctx);
-		ctx.logger.deprecate(`'basic' reporter is deprecated and will be removed in Vitest v3.\n` + `Remove 'basic' from 'reporters' option. To match 'basic' reporter 100%, use configuration:\n${JSON.stringify({ test: { reporters: [["default", { summary: false }]] } }, null, 2)}`);
+	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")}`);
 	}
-	reportSummary(files, errors) {
-		this.ctx.logger.log();
-		return super.reportSummary(files, errors);
+	if (!versions.has(currentVersion)) {
+		throw new Error(`the blobs in "${blobsDirectory}" were generated by a different version of Vitest. Expected v${currentVersion}, but received v${blobs[0].version}`);
 	}
+	// fake module graph - it is used to check if module is imported, but we don't use values inside
+	const projects = Object.fromEntries(projectsArray.map((p) => [p.name, p]));
+	blobs.forEach((blob) => {
+		blob.moduleKeys.forEach(([projectName, moduleIds]) => {
+			const project = projects[projectName];
+			if (!project) {
+				return;
+			}
+			moduleIds.forEach(([moduleId, file, url]) => {
+				const moduleNode = project.vite.moduleGraph.createFileOnlyEntry(file);
+				moduleNode.url = url;
+				moduleNode.id = moduleId;
+				project.vite.moduleGraph.idToModuleMap.set(moduleId, moduleNode);
+			});
+		});
+	});
+	const files = blobs.flatMap((blob) => blob.files).sort((f1, f2) => {
+		const time1 = f1.result?.startTime || 0;
+		const time2 = f2.result?.startTime || 0;
+		return time1 - time2;
+	});
+	const errors = blobs.flatMap((blob) => blob.errors);
+	const coverages = blobs.map((blob) => blob.coverage);
+	const executionTimes = blobs.map((blob) => blob.executionTime);
+	return {
+		files,
+		errors,
+		coverages,
+		executionTimes
+	};
 }
 
 const DEFAULT_RENDER_INTERVAL_MS = 1e3;
@@ -997,6 +917,7 @@ class WindowRenderer {
 			error: options.logger.errorStream.write.bind(options.logger.errorStream)
 		};
 		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();
@@ -1037,6 +958,7 @@ class WindowRenderer {
 			return this.render();
 		}
 		let current;
+		// Concatenate same types into a single render
 		for (const next of this.buffer.splice(0)) {
 			if (!current) {
 				current = next;
@@ -1088,6 +1010,7 @@ class WindowRenderer {
 	}
 	interceptStream(stream, type) {
 		const original = stream.write;
+		// @ts-expect-error -- not sure how 2 overloads should be typed
 		stream.write = (chunk, _, callback) => {
 			if (chunk) {
 				if (this.finished) {
@@ -1171,6 +1094,7 @@ class SummaryReporter {
 		clearInterval(this.durationInterval);
 	}
 	onTestModuleQueued(module) {
+		// When new test module starts, take the place of previously finished test module, if any
 		if (this.finishedModules.size) {
 			const finished = this.finishedModules.keys().next().value;
 			this.removeTestModule(finished);
@@ -1217,6 +1141,7 @@ class SummaryReporter {
 		stats.hook.visible = false;
 	}
 	onTestCaseReady(test) {
+		// Track slow running tests only on verbose mode
 		if (!this.options.verbose) {
 			return;
 		}
@@ -1270,16 +1195,22 @@ class SummaryReporter {
 			this.modules.skipped++;
 		}
 		const left = this.modules.total - this.modules.completed;
+		// Keep finished tests visible in summary for a while if there are more tests left.
+		// When a new test starts in onTestModuleQueued it will take this ones place.
+		// This reduces flickering by making summary more stable.
 		if (left > this.maxParallelTests) {
 			this.finishedModules.set(module.id, setTimeout(() => {
 				this.removeTestModule(module.id);
 			}, FINISHED_TEST_CLEANUP_TIME_MS).unref());
 		} else {
+			// Run is about to end as there are less tests left than whole run had parallel at max.
+			// Remove finished test immediately.
 			this.removeTestModule(module.id);
 		}
 		this.renderer.schedule();
 	}
 	getHookStats({ entity }) {
+		// Track slow running hooks only on verbose mode
 		if (!this.options.verbose) {
 			return;
 		}
@@ -1363,213 +1294,517 @@ function sortRunningModules(a, b) {
 	if ((a.projectName || "") < (b.projectName || "")) {
 		return -1;
 	}
-	return a.filename.localeCompare(b.filename);
+	return a.filename.localeCompare(b.filename);
+}
+function initializeStats(module) {
+	return {
+		total: 0,
+		completed: 0,
+		filename: module.task.name,
+		projectName: module.project.name,
+		projectColor: module.project.color,
+		tests: new Map(),
+		typecheck: !!module.task.meta.typecheck
+	};
+}
+
+class DefaultReporter extends BaseReporter {
+	options;
+	summary;
+	constructor(options = {}) {
+		super(options);
+		this.options = {
+			summary: true,
+			...options
+		};
+		if (!this.isTTY) {
+			this.options.summary = false;
+		}
+		if (this.options.summary) {
+			this.summary = new SummaryReporter();
+		}
+	}
+	onTestRunStart(specifications) {
+		if (this.isTTY) {
+			if (this.renderSucceed === undefined) {
+				this.renderSucceed = !!this.renderSucceed;
+			}
+			if (this.renderSucceed !== true) {
+				this.renderSucceed = specifications.length <= 1;
+			}
+		}
+		this.summary?.onTestRunStart(specifications);
+	}
+	onTestModuleQueued(file) {
+		this.summary?.onTestModuleQueued(file);
+	}
+	onTestModuleCollected(module) {
+		this.summary?.onTestModuleCollected(module);
+	}
+	onTestModuleEnd(module) {
+		super.onTestModuleEnd(module);
+		this.summary?.onTestModuleEnd(module);
+	}
+	onTestCaseReady(test) {
+		this.summary?.onTestCaseReady(test);
+	}
+	onTestCaseResult(test) {
+		super.onTestCaseResult(test);
+		this.summary?.onTestCaseResult(test);
+	}
+	onHookStart(hook) {
+		this.summary?.onHookStart(hook);
+	}
+	onHookEnd(hook) {
+		this.summary?.onHookEnd(hook);
+	}
+	onInit(ctx) {
+		super.onInit(ctx);
+		this.summary?.onInit(ctx, { verbose: this.verbose });
+	}
+	onTestRunEnd() {
+		this.summary?.onTestRunEnd();
+	}
+}
+
+class DotReporter extends BaseReporter {
+	renderer;
+	tests = new Map();
+	finishedTests = new Set();
+	onInit(ctx) {
+		super.onInit(ctx);
+		if (this.isTTY) {
+			this.renderer = new WindowRenderer({
+				logger: ctx.logger,
+				getWindow: () => this.createSummary()
+			});
+			this.ctx.onClose(() => this.renderer?.stop());
+		}
+	}
+	printTestModule(testModule) {
+		if (!this.isTTY) {
+			super.printTestModule(testModule);
+		}
+	}
+	onWatcherRerun(files, trigger) {
+		this.tests.clear();
+		this.renderer?.start();
+		super.onWatcherRerun(files, trigger);
+	}
+	onFinished(files, errors) {
+		if (this.isTTY) {
+			const finalLog = formatTests(Array.from(this.tests.values()));
+			this.ctx.logger.log(finalLog);
+		}
+		this.tests.clear();
+		this.renderer?.finish();
+		super.onFinished(files, errors);
+	}
+	onTestModuleCollected(module) {
+		for (const test of module.children.allTests()) {
+			// Dot reporter marks pending tests as running
+			this.onTestCaseReady(test);
+		}
+	}
+	onTestCaseReady(test) {
+		if (this.finishedTests.has(test.id)) {
+			return;
+		}
+		this.tests.set(test.id, test.result().state || "run");
+		this.renderer?.schedule();
+	}
+	onTestCaseResult(test) {
+		super.onTestCaseResult(test);
+		this.finishedTests.add(test.id);
+		this.tests.set(test.id, test.result().state || "skipped");
+		this.renderer?.schedule();
+	}
+	onTestModuleEnd(testModule) {
+		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");
+		if (finishedTests.length < columns) {
+			return;
+		}
+		// Remove finished tests from state and render them in static output
+		const states = [];
+		let count = 0;
+		for (const [id, state] of finishedTests) {
+			if (count++ >= columns) {
+				break;
+			}
+			this.tests.delete(id);
+			states.push(state);
+		}
+		this.ctx.logger.log(formatTests(states));
+		this.renderer?.schedule();
+	}
+	createSummary() {
+		return [formatTests(Array.from(this.tests.values())), ""];
+	}
+}
+// These are compared with reference equality in formatTests
+const pass = {
+	char: "·",
+	color: c.green
+};
+const fail = {
+	char: "x",
+	color: c.red
+};
+const pending = {
+	char: "*",
+	color: c.yellow
+};
+const skip = {
+	char: "-",
+	color: (char) => c.dim(c.gray(char))
+};
+function getIcon(state) {
+	switch (state) {
+		case "passed": return pass;
+		case "failed": return fail;
+		case "skipped": return skip;
+		default: return pending;
+	}
+}
+/**
+* Format test states into string while keeping ANSI escapes at minimal.
+* Sibling icons with same color are merged into a single c.color() call.
+*/
+function formatTests(states) {
+	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));
+		// Start tracking new group
+		count = 1;
+		currentIcon = icon;
+	}
+	output += currentIcon.color(currentIcon.char.repeat(count));
+	return output;
 }
-function initializeStats(module) {
+
+// 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();
+	} });
+	const console = new Console(writable);
+	const logger = {
+		error: console.error.bind(console),
+		highlight: ctx.logger.highlight.bind(ctx.logger)
+	};
+	const result = printError(error, ctx, logger, {
+		showCodeFrame: false,
+		...options
+	});
 	return {
-		total: 0,
-		completed: 0,
-		filename: module.task.name,
-		projectName: module.project.name,
-		projectColor: module.project.color,
-		tests: new Map(),
-		typecheck: !!module.task.meta.typecheck
+		nearest: result?.nearest,
+		output
 	};
 }
-
-class DefaultReporter extends BaseReporter {
-	options;
-	summary;
-	constructor(options = {}) {
-		super(options);
-		this.options = {
-			summary: true,
-			...options
-		};
-		if (!this.isTTY) {
-			this.options.summary = false;
-		}
-		if (this.options.summary) {
-			this.summary = new SummaryReporter();
+function printError(error, ctx, logger, options) {
+	const project = options.project ?? ctx.coreWorkspaceProject ?? ctx.projects[0];
+	return printErrorInner(error, project, {
+		logger,
+		type: options.type,
+		showCodeFrame: options.showCodeFrame,
+		screenshotPaths: options.screenshotPaths,
+		printProperties: options.verbose,
+		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, { ignoreStackEntries: options.fullStack ? [] : undefined });
+			}
+			// node.js stack trace already has correct source map locations
+			return parseErrorStacktrace(error, {
+				frameFilter: project.config.onStackTrace,
+				ignoreStackEntries: options.fullStack ? [] : undefined
+			});
 		}
+	});
+}
+function printErrorInner(error, project, options) {
+	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],
+			stack: String(error)
+		};
 	}
-	onTestRunStart(specifications) {
-		this.summary?.onTestRunStart(specifications);
+	if (!e) {
+		const error = new Error("unknown error");
+		e = {
+			message: e ?? error.message,
+			stack: error.stack
+		};
 	}
-	onTestModuleQueued(file) {
-		this.summary?.onTestModuleQueued(file);
+	// Error may have occurred even before the configuration was resolved
+	if (!project) {
+		printErrorMessage(e, logger);
+		return;
 	}
-	onTestModuleCollected(module) {
-		this.summary?.onTestModuleCollected(module);
+	const stacks = options.parseErrorStacktrace(e);
+	const nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find((stack) => {
+		try {
+			return project.server && project.getModuleById(stack.file) && existsSync(stack.file);
+		} catch {
+			return false;
+		}
+	});
+	if (type) {
+		printErrorType(type, project.vitest);
 	}
-	onTestModuleEnd(module) {
-		super.onTestModuleEnd(module);
-		this.summary?.onTestModuleEnd(module);
+	printErrorMessage(e, logger);
+	if (options.screenshotPaths?.length) {
+		const length = options.screenshotPaths.length;
+		logger.error(`\nFailure screenshot${length > 1 ? "s" : ""}:`);
+		logger.error(options.screenshotPaths.map((p) => `  - ${c.dim(relative(process.cwd(), p))}`).join("\n"));
+		if (!e.diff) {
+			logger.error();
+		}
 	}
-	onTestCaseReady(test) {
-		this.summary?.onTestCaseReady(test);
+	if (e.codeFrame) {
+		logger.error(`${e.codeFrame}\n`);
 	}
-	onTestCaseResult(test) {
-		super.onTestCaseResult(test);
-		this.summary?.onTestCaseResult(test);
+	if ("__vitest_rollup_error__" in e) {
+		// https://github.com/vitejs/vite/blob/95020ab49e12d143262859e095025cf02423c1d9/packages/vite/src/node/server/middlewares/error.ts#L25-L36
+		const err = e.__vitest_rollup_error__;
+		logger.error([
+			err.plugin && `  Plugin: ${c.magenta(err.plugin)}`,
+			err.id && `  File: ${c.cyan(err.id)}${err.loc ? `:${err.loc.line}:${err.loc.column}` : ""}`,
+			err.frame && c.yellow(err.frame.split(/\r?\n/g).map((l) => ` `.repeat(2) + l).join(`\n`))
+		].filter(Boolean).join("\n"));
 	}
-	onHookStart(hook) {
-		this.summary?.onHookStart(hook);
+	// E.g. AssertionError from assert does not set showDiff but has both actual and expected properties
+	if (e.diff) {
+		logger.error(`\n${e.diff}\n`);
 	}
-	onHookEnd(hook) {
-		this.summary?.onHookEnd(hook);
+	// 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));
+			}
+		});
 	}
-	onInit(ctx) {
-		super.onInit(ctx);
-		this.summary?.onInit(ctx, { verbose: this.verbose });
+	const testPath = e.VITEST_TEST_PATH;
+	const testName = e.VITEST_TEST_NAME;
+	const afterEnvTeardown = e.VITEST_AFTER_ENV_TEARDOWN;
+	// 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.`));
 	}
-	onPathsCollected(paths = []) {
-		if (this.isTTY) {
-			if (this.renderSucceed === undefined) {
-				this.renderSucceed = !!this.renderSucceed;
-			}
-			if (this.renderSucceed !== true) {
-				this.renderSucceed = paths.length <= 1;
-			}
-		}
+	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:` + "\n- The error was thrown, while Vitest was running this test." + "\n- If the error occurred after the test had been completed, this was the last documented test before it was thrown."));
 	}
-	onTestRunEnd() {
-		this.summary?.onTestRunEnd();
+	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
+		});
 	}
+	handleImportOutsideModuleError(e.stack || e.stackStr || "", logger);
+	return { nearest };
 }
-
-class DotReporter extends BaseReporter {
-	renderer;
-	tests = new Map();
-	finishedTests = new Set();
-	onInit(ctx) {
-		super.onInit(ctx);
-		if (this.isTTY) {
-			this.renderer = new WindowRenderer({
-				logger: ctx.logger,
-				getWindow: () => this.createSummary()
-			});
-			this.ctx.onClose(() => this.renderer?.stop());
-		}
+function printErrorType(type, ctx) {
+	ctx.logger.error(`\n${errorBanner(type)}`);
+}
+const skipErrorProperties = new Set([
+	"nameStr",
+	"cause",
+	"stacks",
+	"stackStr",
+	"type",
+	"showDiff",
+	"ok",
+	"operator",
+	"diff",
+	"codeFrame",
+	"actual",
+	"expected",
+	"diffOptions",
+	"sourceURL",
+	"column",
+	"line",
+	"fileName",
+	"lineNumber",
+	"columnNumber",
+	"VITEST_TEST_NAME",
+	"VITEST_TEST_PATH",
+	"VITEST_AFTER_ENV_TEARDOWN",
+	...Object.getOwnPropertyNames(Error.prototype),
+	...Object.getOwnPropertyNames(Object.prototype)
+]);
+function getErrorProperties(e) {
+	const errorObject = Object.create(null);
+	if (e.name === "AssertionError") {
+		return errorObject;
 	}
-	printTestModule(testModule) {
-		if (!this.isTTY) {
-			super.printTestModule(testModule);
+	for (const key of Object.getOwnPropertyNames(e)) {
+		// print the original stack if it was ever changed manually by the user
+		if (key === "stack" && e[key] != null && typeof e[key] !== "string") {
+			errorObject[key] = e[key];
+		} else if (key !== "stack" && !skipErrorProperties.has(key)) {
+			errorObject[key] = e[key];
 		}
 	}
-	onWatcherRerun(files, trigger) {
-		this.tests.clear();
-		this.renderer?.start();
-		super.onWatcherRerun(files, trigger);
+	return errorObject;
+}
+const esmErrors = ["Cannot use import statement outside a module", "Unexpected token 'export'"];
+function handleImportOutsideModuleError(stack, logger) {
+	if (!esmErrors.some((e) => stack.includes(e))) {
+		return;
 	}
-	onFinished(files, errors) {
-		if (this.isTTY) {
-			const finalLog = formatTests(Array.from(this.tests.values()));
-			this.ctx.logger.log(finalLog);
-		}
-		this.tests.clear();
-		this.renderer?.finish();
-		super.onFinished(files, errors);
+	const path = normalize(stack.split("\n")[0].trim());
+	let name = path.split("/node_modules/").pop() || "";
+	if (name?.startsWith("@")) {
+		name = name.split("/").slice(0, 2).join("/");
+	} else {
+		name = name.split("/")[0];
 	}
-	onTestModuleCollected(module) {
-		for (const test of module.children.allTests()) {
-			this.onTestCaseReady(test);
-		}
+	if (name) {
+		printModuleWarningForPackage(logger, path, name);
+	} else {
+		printModuleWarningForSourceCode(logger, path);
 	}
-	onTestCaseReady(test) {
-		if (this.finishedTests.has(test.id)) {
-			return;
-		}
-		this.tests.set(test.id, test.result().state || "run");
-		this.renderer?.schedule();
+}
+function printModuleWarningForPackage(logger, path, name) {
+	logger.error(c.yellow(`Module ${path} seems to be an ES Module but shipped in a CommonJS package. ` + `You might want to create an issue to the package ${c.bold(`"${name}"`)} asking ` + "them to ship the file in .mjs extension or add \"type\": \"module\" in their package.json." + "\n\n" + "As a temporary workaround you can try to inline the package by updating your config:" + "\n\n" + c.gray(c.dim("// vitest.config.js")) + "\n" + c.green(`export default {
+  test: {
+    server: {
+      deps: {
+        inline: [
+          ${c.yellow(c.bold(`"${name}"`))}
+        ]
+      }
+    }
+  }
+}\n`)));
+}
+function printModuleWarningForSourceCode(logger, path) {
+	logger.error(c.yellow(`Module ${path} seems to be an ES Module but shipped in a CommonJS package. ` + "To fix this issue, change the file extension to .mjs or add \"type\": \"module\" in your package.json."));
+}
+function printErrorMessage(error, logger) {
+	const errorName = error.name || error.nameStr || "Unknown Error";
+	if (!error.message) {
+		logger.error(error);
+		return;
 	}
-	onTestCaseResult(test) {
-		super.onTestCaseResult(test);
-		this.finishedTests.add(test.id);
-		this.tests.set(test.id, test.result().state || "skipped");
-		this.renderer?.schedule();
+	if (error.message.length > 5e3) {
+		// Protect against infinite stack trace in tinyrainbow
+		logger.error(`${c.red(c.bold(errorName))}: ${error.message}`);
+	} else {
+		logger.error(c.red(`${c.bold(errorName)}: ${error.message}`));
 	}
-	onTestModuleEnd(testModule) {
-		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");
-		if (finishedTests.length < columns) {
-			return;
-		}
-		const states = [];
-		let count = 0;
-		for (const [id, state] of finishedTests) {
-			if (count++ >= columns) {
-				break;
-			}
-			this.tests.delete(id);
-			states.push(state);
-		}
-		this.ctx.logger.log(formatTests(states));
-		this.renderer?.schedule();
+}
+function printStack(logger, project, stack, highlight, errorProperties, onStack) {
+	for (const frame of stack) {
+		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);
 	}
-	createSummary() {
-		return [formatTests(Array.from(this.tests.values())), ""];
+	if (stack.length) {
+		logger.error();
+	}
+	if (hasProperties(errorProperties)) {
+		logger.error(c.red(c.dim(divider())));
+		const propertiesString = inspect(errorProperties);
+		logger.error(c.red(c.bold("Serialized Error:")), c.gray(propertiesString));
 	}
 }
-const pass = {
-	char: "·",
-	color: c.green
-};
-const fail = {
-	char: "x",
-	color: c.red
-};
-const pending = {
-	char: "*",
-	color: c.yellow
-};
-const skip = {
-	char: "-",
-	color: (char) => c.dim(c.gray(char))
-};
-function getIcon(state) {
-	switch (state) {
-		case "passed": return pass;
-		case "failed": return fail;
-		case "skipped": return skip;
-		default: return pending;
+function hasProperties(obj) {
+	// eslint-disable-next-line no-unreachable-loop
+	for (const _key in obj) {
+		return true;
 	}
+	return false;
 }
-/**
-* Format test states into string while keeping ANSI escapes at minimal.
-* Sibling icons with same color are merged into a single c.color() call.
-*/
-function formatTests(states) {
-	let currentIcon = pending;
+function generateCodeFrame(source, indent = 0, loc, range = 2) {
+	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 output = "";
-	for (const state of states) {
-		const icon = getIcon(state);
-		if (currentIcon === icon) {
-			count++;
-			continue;
+	let res = [];
+	const columns = process.stdout?.columns || 80;
+	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;
+				// too long, maybe it's a minified file, skip for codeframe
+				if (stripVTControlCharacters(lines[j]).length > 200) {
+					return "";
+				}
+				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);
+					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) {
+						const length = Math.max(1, Math.min(end - count, lineLength));
+						res.push(lineNo() + c.red("^".repeat(length)));
+					}
+					count += lineLength + 1;
+				}
+			}
+			break;
 		}
-		output += currentIcon.color(currentIcon.char.repeat(count));
-		count = 1;
-		currentIcon = icon;
 	}
-	output += currentIcon.color(currentIcon.char.repeat(count));
-	return output;
+	if (indent) {
+		res = res.map((line) => " ".repeat(indent) + line);
+	}
+	return res.join("\n");
+}
+function lineNo(no = "") {
+	return c.gray(`${String(no).padStart(3, " ")}| `);
 }
 
 class GithubActionsReporter {
 	ctx = undefined;
+	options;
+	constructor(options = {}) {
+		this.options = options;
+	}
 	onInit(ctx) {
 		this.ctx = ctx;
 	}
 	onFinished(files = [], errors = []) {
+		// collect all errors and associate them with projects
 		const projectErrors = new Array();
 		for (const error of errors) {
 			projectErrors.push({
@@ -1596,6 +1831,8 @@ class GithubActionsReporter {
 				}
 			}
 		}
+		const onWritePath = this.options.onWritePath ?? defaultOnWritePath;
+		// format errors via `printError`
 		for (const { project, title, error, file } of projectErrors) {
 			const result = capturePrintError(error, this.ctx, {
 				project,
@@ -1608,7 +1845,7 @@ class GithubActionsReporter {
 			const formatted = formatMessage({
 				command: "error",
 				properties: {
-					file: stack.file,
+					file: onWritePath(stack.file),
 					title,
 					line: String(stack.line),
 					column: String(stack.column)
@@ -1619,6 +1856,12 @@ class GithubActionsReporter {
 		}
 	}
 }
+function defaultOnWritePath(path) {
+	return path;
+}
+// workflow command formatting based on
+// https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-an-error-message
+// https://github.com/actions/toolkit/blob/f1d9b4b985e6f0f728b4b766db73498403fd5ca3/packages/core/src/command.ts#L80-L85
 function formatMessage({ command, properties, message }) {
 	let result = `::${command}`;
 	Object.entries(properties).forEach(([k, v], i) => {
@@ -1635,6 +1878,17 @@ function escapeProperty(s) {
 	return s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C");
 }
 
+class HangingProcessReporter {
+	whyRunning;
+	onInit() {
+		const _require = createRequire(import.meta.url);
+		this.whyRunning = _require("why-is-node-running");
+	}
+	onProcessTimeout() {
+		this.whyRunning?.();
+	}
+}
+
 const StatusMap = {
 	fail: "failed",
 	only: "pending",
@@ -1777,16 +2031,18 @@ 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;
 	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[\\uDF" + "FE\\uDFFF])|\\uD8BF[\\uDFFE\\uDFFF]|\\uD8FF[\\uDFFE\\uDFFF]|(?:\\uD93F[\\uDFFE\\uD" + "FFF])|\\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;
@@ -1932,6 +2188,7 @@ class JUnitReporter {
 				failures: 0,
 				skipped: 0
 			});
+			// inject failed suites to surface errors during beforeAll/afterAll
 			const suites = getSuites(file);
 			for (const suite of suites) {
 				if (suite.result?.errors) {
@@ -1939,6 +2196,7 @@ class JUnitReporter {
 					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({
@@ -2029,6 +2287,7 @@ class TapReporter {
 		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}`)}`);
 		}
 	}
@@ -2103,12 +2362,18 @@ class VerboseReporter extends DefaultReporter {
 	verbose = true;
 	renderSucceed = true;
 	printTestModule(module) {
+		// still print the test module in TTY,
+		// but don't print it in the CLI because we
+		// print all the tests when they finish
+		// instead of printing them when the test file finishes
 		if (this.isTTY) {
 			return super.printTestModule(module);
 		}
 	}
 	onTestCaseResult(test) {
 		super.onTestCaseResult(test);
+		// don't print tests in TTY as they go, only print them
+		// in the CLI when they finish
 		if (this.isTTY) {
 			return;
 		}
@@ -2147,6 +2412,7 @@ class VerboseReporter extends DefaultReporter {
 		return "  ".repeat(getIndentation(test));
 	}
 	formatShortError() {
+		// Short errors are not shown in tree-view
 		return "";
 	}
 }
@@ -2157,272 +2423,6 @@ function getIndentation(suite, level = 1) {
 	return level;
 }
 
-function createBenchmarkJsonReport(files) {
-	const report = { files: [] };
-	for (const file of files) {
-		const groups = [];
-		for (const task of getTasks(file)) {
-			if (task?.type === "suite") {
-				const benchmarks = [];
-				for (const t of task.tasks) {
-					const benchmark = t.meta.benchmark && t.result?.benchmark;
-					if (benchmark) {
-						benchmarks.push({
-							id: t.id,
-							...benchmark,
-							samples: []
-						});
-					}
-				}
-				if (benchmarks.length) {
-					groups.push({
-						fullName: getFullName(task, " > "),
-						benchmarks
-					});
-				}
-			}
-		}
-		report.files.push({
-			filepath: file.filepath,
-			groups
-		});
-	}
-	return report;
-}
-function flattenFormattedBenchmarkReport(report) {
-	const flat = {};
-	for (const file of report.files) {
-		for (const group of file.groups) {
-			for (const t of group.benchmarks) {
-				flat[t.id] = t;
-			}
-		}
-	}
-	return flat;
-}
-
-const outputMap = new WeakMap();
-function formatNumber(number) {
-	const res = String(number.toFixed(number < 100 ? 4 : 2)).split(".");
-	return res[0].replace(/(?=(?:\d{3})+$)\B/g, ",") + (res[1] ? `.${res[1]}` : "");
-}
-const tableHead = [
-	"name",
-	"hz",
-	"min",
-	"max",
-	"mean",
-	"p75",
-	"p99",
-	"p995",
-	"p999",
-	"rme",
-	"samples"
-];
-function renderBenchmarkItems(result) {
-	return [
-		result.name,
-		formatNumber(result.hz || 0),
-		formatNumber(result.min || 0),
-		formatNumber(result.max || 0),
-		formatNumber(result.mean || 0),
-		formatNumber(result.p75 || 0),
-		formatNumber(result.p99 || 0),
-		formatNumber(result.p995 || 0),
-		formatNumber(result.p999 || 0),
-		`±${(result.rme || 0).toFixed(2)}%`,
-		(result.sampleCount || 0).toString()
-	];
-}
-function computeColumnWidths(results) {
-	const rows = [tableHead, ...results.map((v) => renderBenchmarkItems(v))];
-	return Array.from(tableHead, (_, i) => Math.max(...rows.map((row) => stripVTControlCharacters(row[i]).length)));
-}
-function padRow(row, widths) {
-	return row.map((v, i) => i ? v.padStart(widths[i], " ") : v.padEnd(widths[i], " "));
-}
-function renderTableHead(widths) {
-	return " ".repeat(3) + padRow(tableHead, widths).map(c.bold).join("  ");
-}
-function renderBenchmark(result, widths) {
-	const padded = padRow(renderBenchmarkItems(result), widths);
-	return [
-		padded[0],
-		c.blue(padded[1]),
-		c.cyan(padded[2]),
-		c.cyan(padded[3]),
-		c.cyan(padded[4]),
-		c.cyan(padded[5]),
-		c.cyan(padded[6]),
-		c.cyan(padded[7]),
-		c.cyan(padded[8]),
-		c.dim(padded[9]),
-		c.dim(padded[10])
-	].join("  ");
-}
-function renderTable(options) {
-	const output = [];
-	const benchMap = {};
-	for (const task of options.tasks) {
-		if (task.meta.benchmark && task.result?.benchmark) {
-			benchMap[task.id] = {
-				current: task.result.benchmark,
-				baseline: options.compare?.[task.id]
-			};
-		}
-	}
-	const benchCount = Object.entries(benchMap).length;
-	const columnWidths = computeColumnWidths(Object.values(benchMap).flatMap((v) => [v.current, v.baseline]).filter(notNullish));
-	let idx = 0;
-	const padding = "  ".repeat(1 );
-	for (const task of options.tasks) {
-		const duration = task.result?.duration;
-		const bench = benchMap[task.id];
-		let prefix = "";
-		if (idx === 0 && task.meta?.benchmark) {
-			prefix += `${renderTableHead(columnWidths)}\n${padding}`;
-		}
-		prefix += ` ${getStateSymbol(task)} `;
-		let suffix = "";
-		if (task.type === "suite") {
-			suffix += c.dim(` (${getTests(task).length})`);
-		}
-		if (task.mode === "skip" || task.mode === "todo") {
-			suffix += c.dim(c.gray(" [skipped]"));
-		}
-		if (duration != null) {
-			const color = duration > options.slowTestThreshold ? c.yellow : c.green;
-			suffix += color(` ${Math.round(duration)}${c.dim("ms")}`);
-		}
-		if (options.showHeap && task.result?.heap != null) {
-			suffix += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
-		}
-		if (bench) {
-			let body = renderBenchmark(bench.current, columnWidths);
-			if (options.compare && bench.baseline) {
-				if (bench.current.hz) {
-					const diff = bench.current.hz / bench.baseline.hz;
-					const diffFixed = diff.toFixed(2);
-					if (diffFixed === "1.0.0") {
-						body += c.gray(`  [${diffFixed}x]`);
-					}
-					if (diff > 1) {
-						body += c.blue(`  [${diffFixed}x] ⇑`);
-					} else {
-						body += c.red(`  [${diffFixed}x] ⇓`);
-					}
-				}
-				output.push(padding + prefix + body + suffix);
-				const bodyBaseline = renderBenchmark(bench.baseline, columnWidths);
-				output.push(`${padding}   ${bodyBaseline}  ${c.dim("(baseline)")}`);
-			} else {
-				if (bench.current.rank === 1 && benchCount > 1) {
-					body += c.bold(c.green("   fastest"));
-				}
-				if (bench.current.rank === benchCount && benchCount > 2) {
-					body += c.bold(c.gray("   slowest"));
-				}
-				output.push(padding + prefix + body + suffix);
-			}
-		} else {
-			output.push(padding + prefix + task.name + suffix);
-		}
-		if (task.result?.state !== "pass" && outputMap.get(task) != null) {
-			let data = outputMap.get(task);
-			if (typeof data === "string") {
-				data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop());
-				if (data === "") {
-					data = undefined;
-				}
-			}
-			if (data != null) {
-				const out = `   ${"  ".repeat(options.level)}${F_RIGHT} ${data}`;
-				output.push(c.gray(truncateString(out, options.columns)));
-			}
-		}
-		idx++;
-	}
-	return output.filter(Boolean).join("\n");
-}
-
-class BenchmarkReporter extends DefaultReporter {
-	compare;
-	async onInit(ctx) {
-		super.onInit(ctx);
-		if (this.ctx.config.benchmark?.compare) {
-			const compareFile = pathe.resolve(this.ctx.config.root, this.ctx.config.benchmark?.compare);
-			try {
-				this.compare = flattenFormattedBenchmarkReport(JSON.parse(await fs.promises.readFile(compareFile, "utf-8")));
-			} catch (e) {
-				this.error(`Failed to read '${compareFile}'`, e);
-			}
-		}
-	}
-	onTaskUpdate(packs) {
-		for (const pack of packs) {
-			const task = this.ctx.state.idMap.get(pack[0]);
-			if (task?.type === "suite" && task.result?.state !== "run") {
-				task.tasks.filter((task) => task.result?.benchmark).sort((benchA, benchB) => benchA.result.benchmark.mean - benchB.result.benchmark.mean).forEach((bench, idx) => {
-					bench.result.benchmark.rank = Number(idx) + 1;
-				});
-			}
-		}
-	}
-	onTestSuiteResult(testSuite) {
-		super.onTestSuiteResult(testSuite);
-		this.printSuiteTable(testSuite);
-	}
-	printTestModule(testModule) {
-		this.printSuiteTable(testModule);
-	}
-	printSuiteTable(testTask) {
-		const state = testTask.state();
-		if (state === "pending" || state === "queued") {
-			return;
-		}
-		const benches = testTask.task.tasks.filter((t) => t.meta.benchmark);
-		const duration = testTask.task.result?.duration || 0;
-		if (benches.length > 0 && benches.every((t) => t.result?.state !== "run" && t.result?.state !== "queued")) {
-			let title = `\n ${getStateSymbol(testTask.task)} ${formatProjectName(testTask.project)}${getFullName(testTask.task, c.dim(" > "))}`;
-			if (duration != null && duration > this.ctx.config.slowTestThreshold) {
-				title += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
-			}
-			this.log(title);
-			this.log(renderTable({
-				tasks: benches,
-				level: 1,
-				columns: this.ctx.logger.getColumns(),
-				compare: this.compare,
-				showHeap: this.ctx.config.logHeapUsage,
-				slowTestThreshold: this.ctx.config.slowTestThreshold
-			}));
-		}
-	}
-	async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-		super.onFinished(files, errors);
-		let outputFile = this.ctx.config.benchmark?.outputJson;
-		if (outputFile) {
-			outputFile = pathe.resolve(this.ctx.config.root, outputFile);
-			const outputDirectory = pathe.dirname(outputFile);
-			if (!fs.existsSync(outputDirectory)) {
-				await fs.promises.mkdir(outputDirectory, { recursive: true });
-			}
-			const output = createBenchmarkJsonReport(files);
-			await fs.promises.writeFile(outputFile, JSON.stringify(output, null, 2));
-			this.log(`Benchmark report written to ${outputFile}`);
-		}
-	}
-}
-
-class VerboseBenchmarkReporter extends BenchmarkReporter {
-	verbose = true;
-}
-
-const BenchmarkReportsMap = {
-	default: BenchmarkReporter,
-	verbose: VerboseBenchmarkReporter
-};
-
 const ReportersMap = {
 	"default": DefaultReporter,
 	"basic": BasicReporter,
@@ -2437,4 +2437,4 @@ const ReportersMap = {
 	"github-actions": GithubActionsReporter
 };
 
-export { BasicReporter as B, DefaultReporter as D, GithubActionsReporter as G, HangingProcessReporter as H, JsonReporter as J, ReportersMap as R, TapFlatReporter as T, VerboseBenchmarkReporter as V, BenchmarkReporter as a, BenchmarkReportsMap as b, DotReporter as c, JUnitReporter as d, TapReporter as e, VerboseReporter as f, printError as g, generateCodeFrame as h, BlobReporter as i, parse as p, readBlobs as r, stringify as s };
+export { BasicReporter as B, DefaultReporter as D, F_RIGHT as F, GithubActionsReporter as G, HangingProcessReporter as H, JsonReporter as J, ReportersMap as R, TapFlatReporter as T, VerboseReporter as V, DotReporter as a, JUnitReporter as b, TapReporter as c, printError as d, errorBanner as e, formatProjectName as f, getStateSymbol as g, divider as h, generateCodeFrame as i, BlobReporter as j, parse as p, readBlobs as r, stringify as s, truncateString as t, utils as u, withLabel as w };