vitest 3.2.0-beta.1 → 3.2.0-beta.2

package/dist/chunks/{index.CUacZlWG.js → index.CV36oG_L.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.DnTrplSJ.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;
-}
-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 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 padSummaryTitle(str) {
+	return c.dim(`${str.padStart(11)} `);
 }
-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 truncateString(text, maxLength) {
+	const plainText = stripVTControlCharacters(text);
+	if (plainText.length <= maxLength) {
+		return text;
 	}
+	return `${plainText.slice(0, maxLength - 1)}…`;
 }
-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, " ")}| `);
+function capitalize(text) {
+	return `${text[0].toUpperCase()}${text.slice(1)}`;
 }
 
-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
-	};
-}
-
-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 {
@@ -952,20 +631,247 @@ function sum(items, cb) {
 		return total + Math.max(cb(next) || 0, 0);
 	}, 0);
 }
-
-class BasicReporter extends BaseReporter {
-	constructor() {
-		super();
-		this.isTTY = false;
+
+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) {
+		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) {
+	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}`);
 	}
+	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;
@@ -1360,208 +1266,490 @@ function sortRunningModules(a, b) {
 	if ((a.projectName || "") > (b.projectName || "")) {
 		return 1;
 	}
-	if ((a.projectName || "") < (b.projectName || "")) {
-		return -1;
+	if ((a.projectName || "") < (b.projectName || "")) {
+		return -1;
+	}
+	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) {
+		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 });
+	}
+	onPathsCollected(paths = []) {
+		if (this.isTTY) {
+			if (this.renderSucceed === undefined) {
+				this.renderSucceed = !!this.renderSucceed;
+			}
+			if (this.renderSucceed !== true) {
+				this.renderSucceed = paths.length <= 1;
+			}
+		}
+	}
+	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()) {
+			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;
+		}
+		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())), ""];
+	}
+}
+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));
+		count = 1;
+		currentIcon = icon;
 	}
-	return a.filename.localeCompare(b.filename);
+	output += currentIcon.color(currentIcon.char.repeat(count));
+	return output;
 }
-function initializeStats(module) {
+
+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) {
+			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 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);
+	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) {
+		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);
+	if (e.diff) {
+		logger.error(`\n${e.diff}\n`);
 	}
-	onHookEnd(hook) {
-		this.summary?.onHookEnd(hook);
+	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;
+	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",
+	"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;
 	}
-	printTestModule(testModule) {
-		if (!this.isTTY) {
-			super.printTestModule(testModule);
+	for (const key of Object.getOwnPropertyNames(e)) {
+		if (!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;
+	}
+	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];
 	}
-	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);
+	if (name) {
+		printModuleWarningForPackage(logger, path, name);
+	} else {
+		printModuleWarningForSourceCode(logger, path);
 	}
-	onTestModuleCollected(module) {
-		for (const test of module.children.allTests()) {
-			this.onTestCaseReady(test);
-		}
+}
+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;
 	}
-	onTestCaseReady(test) {
-		if (this.finishedTests.has(test.id)) {
-			return;
-		}
-		this.tests.set(test.id, test.result().state || "run");
-		this.renderer?.schedule();
+	if (error.message.length > 5e3) {
+		logger.error(`${c.red(c.bold(errorName))}: ${error.message}`);
+	} else {
+		logger.error(c.red(`${c.bold(errorName)}: ${error.message}`));
 	}
-	onTestCaseResult(test) {
-		super.onTestCaseResult(test);
-		this.finishedTests.add(test.id);
-		this.tests.set(test.id, test.result().state || "skipped");
-		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);
 	}
-	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();
+	if (stack.length) {
+		logger.error();
 	}
-	createSummary() {
-		return [formatTests(Array.from(this.tests.values())), ""];
+	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) {
+	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;
+				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;
 		}
-		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 {
@@ -1635,6 +1823,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",
@@ -2157,272 +2356,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 +2370,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 };