vitest 4.1.1 → 4.1.3

package/dist/chunks/{index.DXMFO5MJ.js → index.DICur-LY.js}

@@ -1,21 +1,23 @@
-import { existsSync, readFileSync, writeFileSync, promises } from 'node:fs';
-import { performance as performance$1 } from 'node:perf_hooks';
+import fs, { existsSync, readFileSync, writeFileSync, promises } from 'node:fs';
 import { getTests, generateHash, createTaskName, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, getTestName, hasFailed, getSuites, getTasks, getFullName } from '@vitest/runner/utils';
-import { slash, isPrimitive, toArray, deepMerge } from '@vitest/utils/helpers';
-import { defaultStackIgnorePatterns, parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
-import { relative, basename, resolve as resolve$1, join, isAbsolute, dirname, normalize } from 'pathe';
+import * as pathe from 'pathe';
+import { relative, basename, resolve as resolve$1, join, normalize, dirname } 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, s as separator, b as F_CHECK, c as F_DOWN_RIGHT, g as formatProjectName, h as getStateSymbol, 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, n as noun, o as F_RIGHT } from './utils.DK8FXp4T.js';
+import { stripVTControlCharacters } from 'node:util';
+import { isPrimitive, toArray, deepMerge, notNullish } from '@vitest/utils/helpers';
+import { performance as performance$1 } from 'node:perf_hooks';
+import { defaultStackIgnorePatterns, parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
 import { i as isTTY } from './env.D4Lgay0q.js';
 import { Console } from 'node:console';
 import { Writable } from 'node:stream';
-import { stripVTControlCharacters } from 'node:util';
 import { inspect } from '@vitest/utils/display';
 import nodeos__default, { hostname } from 'node:os';
 import { x } from 'tinyexec';
 import { distDir } from '../path.js';
 import { parseAstAsync } from 'vite';
 import { positionToOffset, lineSplitRE } from '@vitest/utils/offset';
-import { mkdir, writeFile, readdir, stat, readFile } from 'node:fs/promises';
+import { readdir, stat, readFile, mkdir, writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 
 function groupBy(collection, iteratee) {
@@ -1063,6 +1065,120 @@ base.MethodDefinition = base.PropertyDefinition = base.Property = function (node
   if (node.value) { c(node.value, st, "Expression"); }
 };
 
+/// <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 resolver = (input, lazy, parsed, $) => output => {
+  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({ o: output, k, r: tmp });
+      }
+      else
+        output[k] = $.call(output, k, tmp);
+    }
+    else if (output[k] !== ignore)
+      output[k] = $.call(output, k, value);
+  }
+  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 $ = reviver || noop;
+
+  let value = input[0];
+
+  if (typeof value === object && value) {
+    const lazy = [];
+    const revive = resolver(input, lazy, new Set, $);
+    value = revive(value);
+
+    let i = 0;
+    while (i < lazy.length) {
+      // it could be a lazy.shift() but that's costly
+      const {o, k, r} = lazy[i++];
+      o[k] = $.call(o, k, revive(r));
+    }
+  }
+
+  return $.call({'': value}, '', value);
+};
+
+/**
+ * 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;
+  }
+};
+
 async function collectTests(ctx, filepath) {
 	const request = await ctx.vite.environments.ssr.transformRequest(filepath);
 	if (!request) return null;
@@ -1572,189 +1688,6 @@ function findGeneratedPosition(traceMap, { line, column, source }) {
 	};
 }
 
-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_TODO = "□";
-const F_TREE_NODE_MIDDLE = "├──";
-const F_TREE_NODE_END = "└──";
-
-const pointer = c.yellow(F_POINTER);
-const skipped = c.dim(c.gray(F_DOWN));
-const todo = c.dim(c.gray(F_TODO));
-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 separator = c.dim(" > ");
-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 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 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 (snapshots.unmatched) summary.push(c.bold(c.red(`${snapshots.unmatched} failed`)));
-	if (snapshots.updated) summary.push(c.bold(c.green(`${snapshots.updated} updated `)));
-	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 (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}`));
-		});
-	}
-	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.reduce((acc, i) => {
-		// Exclude expected failures from passed count
-		if (i.result?.state === "pass" && i.type === "test" && i.fails) return acc;
-		return i.result?.state === "pass" ? acc + 1 : acc;
-	}, 0);
-	const failed = tasks.reduce((acc, i) => i.result?.state === "fail" ? acc + 1 : acc, 0);
-	const skipped = tasks.reduce((acc, i) => i.mode === "skip" ? acc + 1 : acc, 0);
-	const todo = tasks.reduce((acc, i) => i.mode === "todo" ? acc + 1 : acc, 0);
-	const expectedFail = tasks.reduce((acc, i) => {
-		// Count tests that are marked as .fails and passed (which means they failed as expected)
-		if (i.result?.state === "pass" && i.type === "test" && i.fails) return acc + 1;
-		return acc;
-	}, 0);
-	return [
-		failed ? c.bold(c.red(`${failed} failed`)) : null,
-		passed ? c.bold(c.green(`${passed} passed`)) : null,
-		expectedFail ? c.cyan(`${expectedFail} expected fail`) : null,
-		skipped ? c.yellow(`${skipped} skipped`) : null,
-		todo ? c.gray(`${todo} todo`) : null
-	].filter(Boolean).join(c.dim(" | ")) + (showTotal ? c.gray(` (${tasks.length})`) : "");
-}
-function getStateSymbol(task) {
-	if (task.mode === "todo") return todo;
-	if (task.mode === "skip") return skipped;
-	if (!task.result) return pending$1;
-	if (task.result.state === "run" || task.result.state === "queued") {
-		if (task.type === "suite") return pointer;
-	}
-	if (task.result.state === "pass") return task.meta?.benchmark ? benchmarkPass : testPass;
-	if (task.result.state === "fail") return task.type === "suite" ? suiteFail : taskFail;
-	return " ";
-}
-function formatTimeString(date) {
-	return date.toTimeString().split(" ")[0];
-}
-function formatTime(time) {
-	if (time > 1e3) return `${(time / 1e3).toFixed(2)}s`;
-	return `${Math.round(time)}ms`;
-}
-function formatProjectName(project, suffix = " ") {
-	if (!project?.name) return "";
-	if (!c.isColorSupported) return `|${project.name}|${suffix}`;
-	let background = project.color && c[`bg${capitalize(project.color)}`];
-	if (!background) background = labelDefaultColors[project.name.split("").reduce((acc, v, idx) => acc + v.charCodeAt(0) + idx, 0) % labelDefaultColors.length];
-	return c.black(background(` ${project.name} `)) + suffix;
-}
-function withLabel(color, label, message) {
-	const bgColor = `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
-	return `${c.bold(c[bgColor](` ${label} `))} ${message ? c[color](message) : ""}`;
-}
-function padSummaryTitle(str) {
-	return c.dim(`${str.padStart(11)} `);
-}
-function truncateString(text, maxLength) {
-	const plainText = stripVTControlCharacters(text);
-	if (plainText.length <= maxLength) return text;
-	return `${plainText.slice(0, maxLength - 1)}…`;
-}
-function capitalize(text) {
-	return `${text[0].toUpperCase()}${text.slice(1)}`;
-}
-/**
-* Returns the singular or plural form of a word based on the count.
-*/
-function noun(count, singular, plural) {
-	if (count === 1) return singular;
-	return plural;
-}
-
-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,
-  noun: noun,
-  padSummaryTitle: padSummaryTitle,
-  pending: pending$1,
-  pointer: pointer,
-  renderSnapshotSummary: renderSnapshotSummary,
-  separator: separator,
-  skipped: skipped,
-  suiteFail: suiteFail,
-  taskFail: taskFail,
-  testPass: testPass,
-  todo: todo,
-  truncateString: truncateString,
-  withLabel: withLabel
-});
-
 // use Logger with custom Console to capture entire error printing
 function capturePrintError(error, ctx, options) {
 	let output = "";
@@ -1903,6 +1836,7 @@ const skipErrorProperties = new Set([
 	"VITEST_TEST_NAME",
 	"VITEST_TEST_PATH",
 	"__vitest_rollup_error__",
+	"__vitest_error_context__",
 	...Object.getOwnPropertyNames(Error.prototype),
 	...Object.getOwnPropertyNames(Object.prototype)
 ]);
@@ -2018,64 +1952,295 @@ function lineNo(no = "") {
 	return c.gray(`${String(no).padStart(3, " ")}|`);
 }
 
-const BADGE_PADDING = "       ";
-class BaseReporter {
+function getOutputFile(config, reporter) {
+	if (!config?.outputFile) return;
+	if (typeof config.outputFile === "string") return config.outputFile;
+	return config.outputFile[reporter];
+}
+function createDefinesScript(define) {
+	if (!define) return "";
+	if (serializeDefine(define) === "{}") return "";
+	return `
+const defines = ${serializeDefine(define)}
+Object.keys(defines).forEach((key) => {
+  const segments = key.split('.')
+  let target = globalThis
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+    if (i === segments.length - 1) {
+      target[segment] = defines[key]
+    } else {
+      target = target[segment] || (target[segment] = {})
+    }
+  }
+})
+  `;
+}
+/**
+* Like `JSON.stringify` but keeps raw string values as a literal
+* in the generated code. For example: `"window"` would refer to
+* the global `window` object directly.
+*/
+function serializeDefine(define) {
+	const userDefine = {};
+	for (const key in define) {
+		// vitest sets this to avoid vite:client-inject plugin
+		if (key === "process.env.NODE_ENV" && define[key] === "process.env.NODE_ENV") continue;
+		// import.meta.env.* is handled in `importAnalysis` plugin
+		if (!key.startsWith("import.meta.env.")) userDefine[key] = define[key];
+	}
+	let res = `{`;
+	const keys = Object.keys(userDefine).sort();
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const val = userDefine[key];
+		res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`;
+		if (i !== keys.length - 1) res += `, `;
+	}
+	return `${res}}`;
+}
+function handleDefineValue(value) {
+	if (typeof value === "undefined") return "undefined";
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
+}
+
+class BlobReporter {
 	start = 0;
-	end = 0;
-	watchFilters;
-	failedUnwatchedFiles = [];
-	isTTY;
-	ctx = void 0;
-	renderSucceed = false;
-	verbose = false;
-	silent;
-	_filesInWatchMode = /* @__PURE__ */ new Map();
-	_timeStart = formatTimeString(/* @__PURE__ */ new Date());
-	constructor(options = {}) {
-		this.isTTY = options.isTTY ?? isTTY;
-		this.silent = options.silent;
+	ctx;
+	options;
+	coverage;
+	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.silent ??= this.ctx.config.silent;
-		this.ctx.logger.printBanner();
-	}
-	log(...messages) {
-		this.ctx.logger.log(...messages);
-	}
-	error(...messages) {
-		this.ctx.logger.error(...messages);
-	}
-	relative(path) {
-		return relative(this.ctx.config.root, path);
+		this.start = performance.now();
+		this.coverage = void 0;
 	}
-	onTestRunStart(_specifications) {
-		this.start = performance$1.now();
-		this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
+	onCoverage(coverage) {
+		this.coverage = coverage;
 	}
-	onTestRunEnd(testModules, unhandledErrors, _reason) {
+	async onTestRunEnd(testModules, unhandledErrors) {
+		const executionTime = performance.now() - this.start;
 		const files = testModules.map((testModule) => testModule.task);
 		const errors = [...unhandledErrors];
-		this.end = performance$1.now();
-		if (!files.length && !errors.length) this.ctx.logger.printNoTestFound(this.ctx.filenamePattern);
-		else this.reportSummary(files, errors);
-	}
-	onTestCaseResult(testCase) {
-		if (testCase.result().state === "failed") this.logFailedTask(testCase.task);
-	}
-	onTestSuiteResult(testSuite) {
-		if (testSuite.state() === "failed") this.logFailedTask(testSuite.task);
-	}
-	onTestModuleEnd(testModule) {
-		if (testModule.state() === "failed") this.logFailedTask(testModule.task);
-		this.printTestModule(testModule);
-	}
-	logFailedTask(task) {
-		if (this.silent === "passed-only") for (const log of task.logs || []) this.onUserConsoleLog(log, "failed");
-	}
-	printTestModule(testModule) {
-		const moduleState = testModule.state();
-		if (moduleState === "queued" || moduleState === "pending") return;
+		const coverage = this.coverage;
+		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 environmentModules = {};
+		this.ctx.projects.forEach((project) => {
+			const serializedProject = {
+				environments: {},
+				external: []
+			};
+			Object.entries(project.vite.environments).forEach(([environmentName, environment]) => {
+				serializedProject.environments[environmentName] = serializeEnvironmentModuleGraph(environment);
+			});
+			if (project.browser?.vite.environments.client) serializedProject.browser = serializeEnvironmentModuleGraph(project.browser.vite.environments.client);
+			for (const [id, value] of project._resolver.externalizeCache.entries()) if (typeof value === "string") serializedProject.external.push([id, value]);
+			environmentModules[project.name] = serializedProject;
+		});
+		const report = [
+			this.ctx.version,
+			files,
+			errors,
+			coverage,
+			executionTime,
+			environmentModules
+		];
+		const reportFile = resolve$1(this.ctx.config.root, outputFile);
+		await writeBlob(report, reportFile);
+		this.ctx.logger.log("blob report written to", reportFile);
+	}
+}
+async function writeBlob(content, filename) {
+	const report = stringify(content);
+	const dir = dirname(filename);
+	if (!existsSync(dir)) await mkdir(dir, { recursive: true });
+	await writeFile(filename, report, "utf-8");
+}
+async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
+	// using process.cwd() because --merge-reports can only be used in CLI
+	const resolvedDir = resolve$1(process.cwd(), blobsDirectory);
+	const promises = (await readdir(resolvedDir)).map(async (filename) => {
+		const fullPath = resolve$1(resolvedDir, filename);
+		if (!(await stat(fullPath)).isFile()) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
+		const [version, files, errors, coverage, executionTime, environmentModules] = parse(await readFile(fullPath, "utf-8"));
+		if (!version) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a valid blob file`);
+		return {
+			version,
+			files,
+			errors,
+			coverage,
+			file: filename,
+			executionTime,
+			environmentModules
+		};
+	});
+	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}`);
+	// Restore module graph
+	const projects = Object.fromEntries(projectsArray.map((p) => [p.name, p]));
+	for (const project of projectsArray) if (project.isBrowserEnabled()) await project._initBrowserServer();
+	blobs.forEach((blob) => {
+		Object.entries(blob.environmentModules).forEach(([projectName, modulesByProject]) => {
+			const project = projects[projectName];
+			if (!project) return;
+			modulesByProject.external.forEach(([id, externalized]) => {
+				project._resolver.externalizeCache.set(id, externalized);
+			});
+			Object.entries(modulesByProject.environments).forEach(([environmentName, moduleGraph]) => {
+				const environment = project.vite.environments[environmentName];
+				deserializeEnvironmentModuleGraph(environment, moduleGraph);
+			});
+			const browserModuleGraph = modulesByProject.browser;
+			if (browserModuleGraph) {
+				const browserEnvironment = project.browser.vite.environments.client;
+				deserializeEnvironmentModuleGraph(browserEnvironment, browserModuleGraph);
+			}
+		});
+	});
+	return {
+		files: blobs.flatMap((blob) => blob.files).sort((f1, f2) => {
+			return (f1.result?.startTime || 0) - (f2.result?.startTime || 0);
+		}),
+		errors: blobs.flatMap((blob) => blob.errors),
+		coverages: blobs.map((blob) => blob.coverage),
+		executionTimes: blobs.map((blob) => blob.executionTime)
+	};
+}
+function serializeEnvironmentModuleGraph(environment) {
+	const idTable = [];
+	const idMap = /* @__PURE__ */ new Map();
+	const getIdIndex = (id) => {
+		const existing = idMap.get(id);
+		if (existing != null) return existing;
+		const next = idTable.length;
+		idMap.set(id, next);
+		idTable.push(id);
+		return next;
+	};
+	const modules = [];
+	for (const [id, mod] of environment.moduleGraph.idToModuleMap.entries()) {
+		if (!mod.file) continue;
+		const importedIds = [];
+		for (const importedNode of mod.importedModules) if (importedNode.id) importedIds.push(getIdIndex(importedNode.id));
+		modules.push([
+			getIdIndex(id),
+			getIdIndex(mod.file),
+			getIdIndex(mod.url),
+			importedIds
+		]);
+	}
+	return {
+		idTable,
+		modules
+	};
+}
+function deserializeEnvironmentModuleGraph(environment, serialized) {
+	const nodesById = /* @__PURE__ */ new Map();
+	serialized.modules.forEach(([id, file, url]) => {
+		const moduleId = serialized.idTable[id];
+		const filePath = serialized.idTable[file];
+		const urlPath = serialized.idTable[url];
+		const moduleNode = environment.moduleGraph.createFileOnlyEntry(filePath);
+		moduleNode.url = urlPath;
+		moduleNode.id = moduleId;
+		moduleNode.transformResult = {
+			code: " ",
+			map: null
+		};
+		environment.moduleGraph.idToModuleMap.set(moduleId, moduleNode);
+		nodesById.set(moduleId, moduleNode);
+	});
+	serialized.modules.forEach(([id, _file, _url, importedIds]) => {
+		const moduleId = serialized.idTable[id];
+		const moduleNode = nodesById.get(moduleId);
+		importedIds.forEach((importedIdIndex) => {
+			const importedId = serialized.idTable[importedIdIndex];
+			const importedNode = nodesById.get(importedId);
+			moduleNode.importedModules.add(importedNode);
+			importedNode.importers.add(moduleNode);
+		});
+	});
+}
+
+class HangingProcessReporter {
+	whyRunning;
+	onInit() {
+		this.whyRunning = createRequire(import.meta.url)("why-is-node-running");
+	}
+	onProcessTimeout() {
+		this.whyRunning?.();
+	}
+}
+
+const BADGE_PADDING = "       ";
+class BaseReporter {
+	start = 0;
+	end = 0;
+	watchFilters;
+	failedUnwatchedFiles = [];
+	isTTY;
+	ctx = void 0;
+	renderSucceed = false;
+	verbose = false;
+	silent;
+	_filesInWatchMode = /* @__PURE__ */ new Map();
+	_timeStart = formatTimeString(/* @__PURE__ */ new Date());
+	constructor(options = {}) {
+		this.isTTY = options.isTTY ?? isTTY;
+		this.silent = options.silent;
+	}
+	onInit(ctx) {
+		this.ctx = ctx;
+		this.silent ??= this.ctx.config.silent;
+		this.ctx.logger.printBanner();
+	}
+	log(...messages) {
+		this.ctx.logger.log(...messages);
+	}
+	error(...messages) {
+		this.ctx.logger.error(...messages);
+	}
+	relative(path) {
+		return relative(this.ctx.config.root, path);
+	}
+	onTestRunStart(_specifications) {
+		this.start = performance$1.now();
+		this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
+	}
+	onTestRunEnd(testModules, unhandledErrors, _reason) {
+		const files = testModules.map((testModule) => testModule.task);
+		const errors = [...unhandledErrors];
+		this.end = performance$1.now();
+		if (!files.length && !errors.length) this.ctx.logger.printNoTestFound(this.ctx.filenamePattern);
+		else this.reportSummary(files, errors);
+	}
+	onTestCaseResult(testCase) {
+		if (testCase.result().state === "failed") this.logFailedTask(testCase.task);
+	}
+	onTestSuiteResult(testSuite) {
+		if (testSuite.state() === "failed") this.logFailedTask(testSuite.task);
+	}
+	onTestModuleEnd(testModule) {
+		if (testModule.state() === "failed") this.logFailedTask(testModule.task);
+		this.printTestModule(testModule);
+	}
+	logFailedTask(task) {
+		if (this.silent === "passed-only") for (const log of task.logs || []) this.onUserConsoleLog(log, "failed");
+	}
+	printTestModule(testModule) {
+		const moduleState = testModule.state();
+		if (moduleState === "queued" || moduleState === "pending") return;
 		let testsCount = 0;
 		let failedCount = 0;
 		let skippedCount = 0;
@@ -2992,341 +3157,6 @@ class AgentReporter extends DefaultReporter {
 	}
 }
 
-/// <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 resolver = (input, lazy, parsed, $) => output => {
-  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({ o: output, k, r: tmp });
-      }
-      else
-        output[k] = $.call(output, k, tmp);
-    }
-    else if (output[k] !== ignore)
-      output[k] = $.call(output, k, value);
-  }
-  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 $ = reviver || noop;
-
-  let value = input[0];
-
-  if (typeof value === object && value) {
-    const lazy = [];
-    const revive = resolver(input, lazy, new Set, $);
-    value = revive(value);
-
-    let i = 0;
-    while (i < lazy.length) {
-      // it could be a lazy.shift() but that's costly
-      const {o, k, r} = lazy[i++];
-      o[k] = $.call(o, k, revive(r));
-    }
-  }
-
-  return $.call({'': value}, '', value);
-};
-
-/**
- * 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;
-  }
-};
-
-function getOutputFile(config, reporter) {
-	if (!config?.outputFile) return;
-	if (typeof config.outputFile === "string") return config.outputFile;
-	return config.outputFile[reporter];
-}
-function createDefinesScript(define) {
-	if (!define) return "";
-	if (serializeDefine(define) === "{}") return "";
-	return `
-const defines = ${serializeDefine(define)}
-Object.keys(defines).forEach((key) => {
-  const segments = key.split('.')
-  let target = globalThis
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i]
-    if (i === segments.length - 1) {
-      target[segment] = defines[key]
-    } else {
-      target = target[segment] || (target[segment] = {})
-    }
-  }
-})
-  `;
-}
-/**
-* Like `JSON.stringify` but keeps raw string values as a literal
-* in the generated code. For example: `"window"` would refer to
-* the global `window` object directly.
-*/
-function serializeDefine(define) {
-	const userDefine = {};
-	for (const key in define) {
-		// vitest sets this to avoid vite:client-inject plugin
-		if (key === "process.env.NODE_ENV" && define[key] === "process.env.NODE_ENV") continue;
-		// import.meta.env.* is handled in `importAnalysis` plugin
-		if (!key.startsWith("import.meta.env.")) userDefine[key] = define[key];
-	}
-	let res = `{`;
-	const keys = Object.keys(userDefine).sort();
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
-		const val = userDefine[key];
-		res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`;
-		if (i !== keys.length - 1) res += `, `;
-	}
-	return `${res}}`;
-}
-function handleDefineValue(value) {
-	if (typeof value === "undefined") return "undefined";
-	if (typeof value === "string") return value;
-	return JSON.stringify(value);
-}
-
-class BlobReporter {
-	start = 0;
-	ctx;
-	options;
-	coverage;
-	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();
-		this.coverage = void 0;
-	}
-	onCoverage(coverage) {
-		this.coverage = coverage;
-	}
-	async onTestRunEnd(testModules, unhandledErrors) {
-		const executionTime = performance.now() - this.start;
-		const files = testModules.map((testModule) => testModule.task);
-		const errors = [...unhandledErrors];
-		const coverage = this.coverage;
-		let outputFile = this.options.outputFile ?? getOutputFile(this.ctx.config, "blob");
-		if (!outputFile) {
-			const shard = this.ctx.config.shard;
-			outputFile = shard ? `.vitest-reports/blob-${shard.index}-${shard.count}.json` : ".vitest-reports/blob.json";
-		}
-		const environmentModules = {};
-		this.ctx.projects.forEach((project) => {
-			const serializedProject = {
-				environments: {},
-				external: []
-			};
-			Object.entries(project.vite.environments).forEach(([environmentName, environment]) => {
-				serializedProject.environments[environmentName] = serializeEnvironmentModuleGraph(environment);
-			});
-			if (project.browser?.vite.environments.client) serializedProject.browser = serializeEnvironmentModuleGraph(project.browser.vite.environments.client);
-			for (const [id, value] of project._resolver.externalizeCache.entries()) if (typeof value === "string") serializedProject.external.push([id, value]);
-			environmentModules[project.name] = serializedProject;
-		});
-		const report = [
-			this.ctx.version,
-			files,
-			errors,
-			coverage,
-			executionTime,
-			environmentModules
-		];
-		const reportFile = resolve$1(this.ctx.config.root, outputFile);
-		await writeBlob(report, reportFile);
-		this.ctx.logger.log("blob report written to", reportFile);
-	}
-}
-async function writeBlob(content, filename) {
-	const report = stringify(content);
-	const dir = dirname(filename);
-	if (!existsSync(dir)) await mkdir(dir, { recursive: true });
-	await writeFile(filename, report, "utf-8");
-}
-async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
-	// using process.cwd() because --merge-reports can only be used in CLI
-	const resolvedDir = resolve$1(process.cwd(), blobsDirectory);
-	const promises = (await readdir(resolvedDir)).map(async (filename) => {
-		const fullPath = resolve$1(resolvedDir, filename);
-		if (!(await stat(fullPath)).isFile()) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
-		const [version, files, errors, coverage, executionTime, environmentModules] = parse(await readFile(fullPath, "utf-8"));
-		if (!version) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a valid blob file`);
-		return {
-			version,
-			files,
-			errors,
-			coverage,
-			file: filename,
-			executionTime,
-			environmentModules
-		};
-	});
-	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}`);
-	// Restore module graph
-	const projects = Object.fromEntries(projectsArray.map((p) => [p.name, p]));
-	for (const project of projectsArray) if (project.isBrowserEnabled()) await project._initBrowserServer();
-	blobs.forEach((blob) => {
-		Object.entries(blob.environmentModules).forEach(([projectName, modulesByProject]) => {
-			const project = projects[projectName];
-			if (!project) return;
-			modulesByProject.external.forEach(([id, externalized]) => {
-				project._resolver.externalizeCache.set(id, externalized);
-			});
-			Object.entries(modulesByProject.environments).forEach(([environmentName, moduleGraph]) => {
-				const environment = project.vite.environments[environmentName];
-				deserializeEnvironmentModuleGraph(environment, moduleGraph);
-			});
-			const browserModuleGraph = modulesByProject.browser;
-			if (browserModuleGraph) {
-				const browserEnvironment = project.browser.vite.environments.client;
-				deserializeEnvironmentModuleGraph(browserEnvironment, browserModuleGraph);
-			}
-		});
-	});
-	return {
-		files: blobs.flatMap((blob) => blob.files).sort((f1, f2) => {
-			return (f1.result?.startTime || 0) - (f2.result?.startTime || 0);
-		}),
-		errors: blobs.flatMap((blob) => blob.errors),
-		coverages: blobs.map((blob) => blob.coverage),
-		executionTimes: blobs.map((blob) => blob.executionTime)
-	};
-}
-function serializeEnvironmentModuleGraph(environment) {
-	const idTable = [];
-	const idMap = /* @__PURE__ */ new Map();
-	const getIdIndex = (id) => {
-		const existing = idMap.get(id);
-		if (existing != null) return existing;
-		const next = idTable.length;
-		idMap.set(id, next);
-		idTable.push(id);
-		return next;
-	};
-	const modules = [];
-	for (const [id, mod] of environment.moduleGraph.idToModuleMap.entries()) {
-		if (!mod.file) continue;
-		const importedIds = [];
-		for (const importedNode of mod.importedModules) if (importedNode.id) importedIds.push(getIdIndex(importedNode.id));
-		modules.push([
-			getIdIndex(id),
-			getIdIndex(mod.file),
-			getIdIndex(mod.url),
-			importedIds
-		]);
-	}
-	return {
-		idTable,
-		modules
-	};
-}
-function deserializeEnvironmentModuleGraph(environment, serialized) {
-	const nodesById = /* @__PURE__ */ new Map();
-	serialized.modules.forEach(([id, file, url]) => {
-		const moduleId = serialized.idTable[id];
-		const filePath = serialized.idTable[file];
-		const urlPath = serialized.idTable[url];
-		const moduleNode = environment.moduleGraph.createFileOnlyEntry(filePath);
-		moduleNode.url = urlPath;
-		moduleNode.id = moduleId;
-		moduleNode.transformResult = {
-			code: " ",
-			map: null
-		};
-		environment.moduleGraph.idToModuleMap.set(moduleId, moduleNode);
-		nodesById.set(moduleId, moduleNode);
-	});
-	serialized.modules.forEach(([id, _file, _url, importedIds]) => {
-		const moduleId = serialized.idTable[id];
-		const moduleNode = nodesById.get(moduleId);
-		importedIds.forEach((importedIdIndex) => {
-			const importedId = serialized.idTable[importedIdIndex];
-			const importedNode = nodesById.get(importedId);
-			moduleNode.importedModules.add(importedNode);
-			importedNode.importers.add(moduleNode);
-		});
-	});
-}
-
 class DotReporter extends BaseReporter {
 	renderer;
 	tests = /* @__PURE__ */ new Map();
@@ -3702,16 +3532,6 @@ function renderSummary(summaryData, fileLinks) {
 	return summary;
 }
 
-class HangingProcessReporter {
-	whyRunning;
-	onInit() {
-		this.whyRunning = createRequire(import.meta.url)("why-is-node-running");
-	}
-	onProcessTimeout() {
-		this.whyRunning?.();
-	}
-}
-
 const StatusMap = {
 	fail: "failed",
 	only: "pending",
@@ -4186,6 +4006,228 @@ class VerboseReporter extends DefaultReporter {
 	}
 }
 
+function createBenchmarkJsonReport(files) {
+	const report = { files: [] };
+	for (const file of files) {
+		const groups = [];
+		for (const task of getTasks(file)) if (task?.type === "suite") {
+			const benchmarks = [];
+			for (const t of task.tasks) {
+				const benchmark = t.meta.benchmark && t.result?.benchmark;
+				if (benchmark) benchmarks.push({
+					id: t.id,
+					...benchmark,
+					samples: []
+				});
+			}
+			if (benchmarks.length) groups.push({
+				fullName: getFullName(task, " > "),
+				benchmarks
+			});
+		}
+		report.files.push({
+			filepath: file.filepath,
+			groups
+		});
+	}
+	return report;
+}
+function flattenFormattedBenchmarkReport(report) {
+	const flat = {};
+	for (const file of report.files) for (const group of file.groups) for (const t of group.benchmarks) flat[t.id] = t;
+	return flat;
+}
+
+const outputMap = /* @__PURE__ */ new WeakMap();
+function formatNumber(number) {
+	const res = String(number.toFixed(number < 100 ? 4 : 2)).split(".");
+	return res[0].replace(/(?=(?:\d{3})+$)\B/g, ",") + (res[1] ? `.${res[1]}` : "");
+}
+const tableHead = [
+	"name",
+	"hz",
+	"min",
+	"max",
+	"mean",
+	"p75",
+	"p99",
+	"p995",
+	"p999",
+	"rme",
+	"samples"
+];
+function renderBenchmarkItems(result) {
+	return [
+		result.name,
+		formatNumber(result.hz || 0),
+		formatNumber(result.min || 0),
+		formatNumber(result.max || 0),
+		formatNumber(result.mean || 0),
+		formatNumber(result.p75 || 0),
+		formatNumber(result.p99 || 0),
+		formatNumber(result.p995 || 0),
+		formatNumber(result.p999 || 0),
+		`±${(result.rme || 0).toFixed(2)}%`,
+		(result.sampleCount || 0).toString()
+	];
+}
+function computeColumnWidths(results) {
+	const rows = [tableHead, ...results.map((v) => renderBenchmarkItems(v))];
+	return Array.from(tableHead, (_, i) => Math.max(...rows.map((row) => stripVTControlCharacters(row[i]).length)));
+}
+function padRow(row, widths) {
+	return row.map((v, i) => i ? v.padStart(widths[i], " ") : v.padEnd(widths[i], " "));
+}
+function renderTableHead(widths) {
+	return " ".repeat(3) + padRow(tableHead, widths).map(c.bold).join("  ");
+}
+function renderBenchmark(result, widths) {
+	const padded = padRow(renderBenchmarkItems(result), widths);
+	return [
+		padded[0],
+		c.blue(padded[1]),
+		c.cyan(padded[2]),
+		c.cyan(padded[3]),
+		c.cyan(padded[4]),
+		c.cyan(padded[5]),
+		c.cyan(padded[6]),
+		c.cyan(padded[7]),
+		c.cyan(padded[8]),
+		c.dim(padded[9]),
+		c.dim(padded[10])
+	].join("  ");
+}
+function renderTable(options) {
+	const output = [];
+	const benchMap = {};
+	for (const task of options.tasks) if (task.meta.benchmark && task.result?.benchmark) benchMap[task.id] = {
+		current: task.result.benchmark,
+		baseline: options.compare?.[task.id]
+	};
+	const benchCount = Object.entries(benchMap).length;
+	const columnWidths = computeColumnWidths(Object.values(benchMap).flatMap((v) => [v.current, v.baseline]).filter(notNullish));
+	let idx = 0;
+	const padding = "  ".repeat(1 );
+	for (const task of options.tasks) {
+		const duration = task.result?.duration;
+		const bench = benchMap[task.id];
+		let prefix = "";
+		if (idx === 0 && task.meta?.benchmark) prefix += `${renderTableHead(columnWidths)}\n${padding}`;
+		prefix += ` ${getStateSymbol(task)} `;
+		let suffix = "";
+		if (task.type === "suite") suffix += c.dim(` (${getTests(task).length})`);
+		if (task.mode === "skip" || task.mode === "todo") suffix += c.dim(c.gray(" [skipped]"));
+		if (duration != null) {
+			const color = duration > options.slowTestThreshold ? c.yellow : c.green;
+			suffix += color(` ${Math.round(duration)}${c.dim("ms")}`);
+		}
+		if (options.showHeap && task.result?.heap != null) suffix += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
+		if (bench) {
+			let body = renderBenchmark(bench.current, columnWidths);
+			if (options.compare && bench.baseline) {
+				if (bench.current.hz) {
+					const diff = bench.current.hz / bench.baseline.hz;
+					const diffFixed = diff.toFixed(2);
+					if (diffFixed === "1.0.0") body += c.gray(`  [${diffFixed}x]`);
+					if (diff > 1) body += c.blue(`  [${diffFixed}x] ⇑`);
+					else body += c.red(`  [${diffFixed}x] ⇓`);
+				}
+				output.push(padding + prefix + body + suffix);
+				const bodyBaseline = renderBenchmark(bench.baseline, columnWidths);
+				output.push(`${padding}   ${bodyBaseline}  ${c.dim("(baseline)")}`);
+			} else {
+				if (bench.current.rank === 1 && benchCount > 1) body += c.bold(c.green("   fastest"));
+				if (bench.current.rank === benchCount && benchCount > 2) body += c.bold(c.gray("   slowest"));
+				output.push(padding + prefix + body + suffix);
+			}
+		} else output.push(padding + prefix + task.name + suffix);
+		if (task.result?.state !== "pass" && outputMap.get(task) != null) {
+			let data = outputMap.get(task);
+			if (typeof data === "string") {
+				data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop());
+				if (data === "") data = void 0;
+			}
+			if (data != null) {
+				const out = `   ${"  ".repeat(options.level)}${F_RIGHT} ${data}`;
+				output.push(c.gray(truncateString(out, options.columns)));
+			}
+		}
+		idx++;
+	}
+	return output.filter(Boolean).join("\n");
+}
+
+class BenchmarkReporter extends DefaultReporter {
+	compare;
+	async onInit(ctx) {
+		super.onInit(ctx);
+		if (this.ctx.config.benchmark?.compare) {
+			const compareFile = pathe.resolve(this.ctx.config.root, this.ctx.config.benchmark?.compare);
+			try {
+				this.compare = flattenFormattedBenchmarkReport(JSON.parse(await fs.promises.readFile(compareFile, "utf-8")));
+			} catch (e) {
+				this.error(`Failed to read '${compareFile}'`, e);
+			}
+		}
+	}
+	onTaskUpdate(packs) {
+		for (const pack of packs) {
+			const task = this.ctx.state.idMap.get(pack[0]);
+			if (task?.type === "suite" && task.result?.state !== "run") task.tasks.filter((task) => task.result?.benchmark).sort((benchA, benchB) => benchA.result.benchmark.mean - benchB.result.benchmark.mean).forEach((bench, idx) => {
+				bench.result.benchmark.rank = Number(idx) + 1;
+			});
+		}
+	}
+	onTestSuiteResult(testSuite) {
+		super.onTestSuiteResult(testSuite);
+		this.printSuiteTable(testSuite);
+	}
+	printTestModule(testModule) {
+		this.printSuiteTable(testModule);
+	}
+	printSuiteTable(testTask) {
+		const state = testTask.state();
+		if (state === "pending" || state === "queued") return;
+		const benches = testTask.task.tasks.filter((t) => t.meta.benchmark);
+		const duration = testTask.task.result?.duration || 0;
+		if (benches.length > 0 && benches.every((t) => t.result?.state !== "run" && t.result?.state !== "queued")) {
+			let title = `\n ${getStateSymbol(testTask.task)} ${formatProjectName(testTask.project)}${getFullName(testTask.task, separator)}`;
+			if (duration != null && duration > this.ctx.config.slowTestThreshold) title += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
+			this.log(title);
+			this.log(renderTable({
+				tasks: benches,
+				level: 1,
+				columns: this.ctx.logger.getColumns(),
+				compare: this.compare,
+				showHeap: this.ctx.config.logHeapUsage,
+				slowTestThreshold: this.ctx.config.slowTestThreshold
+			}));
+		}
+	}
+	async onTestRunEnd(testModules, unhandledErrors, reason) {
+		super.onTestRunEnd(testModules, unhandledErrors, reason);
+		// write output for future comparison
+		let outputFile = this.ctx.config.benchmark?.outputJson;
+		if (outputFile) {
+			outputFile = pathe.resolve(this.ctx.config.root, outputFile);
+			const outputDirectory = pathe.dirname(outputFile);
+			if (!fs.existsSync(outputDirectory)) await fs.promises.mkdir(outputDirectory, { recursive: true });
+			const output = createBenchmarkJsonReport(testModules.map((t) => t.task.file));
+			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,
 	"agent": AgentReporter,
@@ -4201,4 +4243,4 @@ const ReportersMap = {
 	"github-actions": GithubActionsReporter
 };
 
-export { AgentReporter as A, BlobReporter as B, utils as C, DefaultReporter as D, F_RIGHT as F, GithubActionsReporter as G, HangingProcessReporter as H, JUnitReporter as J, ReportersMap as R, TapFlatReporter as T, VerboseReporter as V, DotReporter as a, JsonReporter as b, TapReporter as c, createIndexLocationsMap as d, TraceMap as e, formatProjectName as f, getStateSymbol as g, ancestor as h, stringify as i, printError as j, errorBanner as k, divider as l, Typechecker as m, generateCodeFrame as n, originalPositionFor as o, parse as p, escapeRegExp as q, createDefinesScript as r, separator as s, truncateString as t, groupBy as u, readBlobs as v, withLabel as w, convertTasksToEvents as x, wildcardPatternToRegExp as y, stdout as z };
+export { AgentReporter as A, BenchmarkReporter as B, DefaultReporter as D, GithubActionsReporter as G, HangingProcessReporter as H, JUnitReporter as J, ReportersMap as R, TapFlatReporter as T, VerboseBenchmarkReporter as V, BenchmarkReportsMap as a, DotReporter as b, JsonReporter as c, TapReporter as d, VerboseReporter as e, createIndexLocationsMap as f, TraceMap as g, ancestor as h, printError as i, Typechecker as j, generateCodeFrame as k, escapeRegExp as l, createDefinesScript as m, groupBy as n, originalPositionFor as o, parse as p, BlobReporter as q, readBlobs as r, stringify as s, convertTasksToEvents as t, stdout as u, wildcardPatternToRegExp as w };