vitest 4.0.14 → 4.0.16

package/dist/chunks/{config.d.g6OOauRt.d.ts → config.d.CzIjkicf.d.ts}

@@ -182,6 +182,7 @@ interface SerializedConfig {
 	serializedDefines: string;
 	experimental: {
 		fsModuleCache: boolean;
+		printImportBreakdown: boolean | undefined;
 	};
 }
 interface SerializedCoverageConfig {

package/dist/chunks/{coverage.CtyeYmKM.js → coverage.BuJUwVtg.js}

@@ -2474,6 +2474,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		resolved.pool = options.pool.name;
 		resolved.poolRunner = options.pool;
 	}
+	if ("poolOptions" in resolved) logger.deprecate("`test.poolOptions` was removed in Vitest 4. All previous `poolOptions` are now top-level options. Please, refer to the migration guide: https://vitest.dev/guide/migration#pool-rework");
 	resolved.pool ??= "forks";
 	resolved.project = toArray(resolved.project);
 	resolved.provide ??= {};
@@ -2790,7 +2791,7 @@ function resolveConfig$1(vitest, options, viteConfig) {
 		const userFolder = resolved.server.debug?.dump || process.env.VITEST_DEBUG_DUMP;
 		resolved.dumpDir = resolve(resolved.root, typeof userFolder === "string" && userFolder !== "true" ? userFolder : ".vitest-dump", resolved.name || "root");
 	}
-	resolved.testTimeout ??= resolved.browser.enabled ? 3e4 : 5e3;
+	resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3;
 	resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4;
 	resolved.experimental ??= {};
 	if (resolved.experimental.openTelemetry?.sdkPath) {

package/dist/chunks/evaluatedModules.d.BxJ5omdx.d.ts

@@ -0,0 +1,7 @@
+import { EvaluatedModules } from 'vite/module-runner';
+
+declare class VitestEvaluatedModules extends EvaluatedModules {
+	getModuleSourceMapById(id: string): any;
+}
+
+export { VitestEvaluatedModules as V };

package/dist/chunks/{globals.C0izxiX3.js → globals.DOayXfHP.js}

@@ -1,11 +1,11 @@
 import { g as globalApis } from './constants.D_Q9UYh-.js';
-import { i as index } from './index.DBx1AtPJ.js';
-import './vi.BiaV1qII.js';
+import { i as index } from './index.Z5E_ObnR.js';
+import './vi.2VT5v0um.js';
 import '@vitest/expect';
 import '@vitest/runner';
-import '@vitest/runner/utils';
 import './utils.DvEY5TfP.js';
 import '@vitest/utils/timers';
+import '@vitest/runner/utils';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/utils/helpers';

package/dist/chunks/{index.D6PC4Dpu.js → index.456_DGfR.js}

@@ -285,6 +285,62 @@ async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
 	};
 }
 
+function groupBy(collection, iteratee) {
+	return collection.reduce((acc, item) => {
+		const key = iteratee(item);
+		acc[key] ||= [];
+		acc[key].push(item);
+		return acc;
+	}, {});
+}
+function stdout() {
+	// @ts-expect-error Node.js maps process.stdout to console._stdout
+	// eslint-disable-next-line no-console
+	return console._stdout || process.stdout;
+}
+function escapeRegExp(s) {
+	// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function wildcardPatternToRegExp(pattern) {
+	const negated = pattern[0] === "!";
+	if (negated) pattern = pattern.slice(1);
+	let regexp = `${pattern.split("*").map(escapeRegExp).join(".*")}$`;
+	if (negated) regexp = `(?!${regexp})`;
+	return new RegExp(`^${regexp}`, "i");
+}
+function createIndexLocationsMap(source) {
+	const map = /* @__PURE__ */ new Map();
+	let index = 0;
+	let line = 1;
+	let column = 1;
+	for (const char of source) {
+		map.set(index++, {
+			line,
+			column
+		});
+		if (char === "\n" || char === "\r\n") {
+			line++;
+			column = 0;
+		} else column++;
+	}
+	return map;
+}
+function createLocationsIndexMap(source) {
+	const map = /* @__PURE__ */ new Map();
+	let index = 0;
+	let line = 1;
+	let column = 1;
+	for (const char of source) {
+		map.set(`${line}:${column}`, index++);
+		if (char === "\n" || char === "\r\n") {
+			line++;
+			column = 0;
+		} else column++;
+	}
+	return map;
+}
+
 function hasFailedSnapshot(suite) {
 	return getTests(suite).some((s) => {
 		return s.result?.errors?.some((e) => typeof e?.message === "string" && e.message.match(/Snapshot .* mismatched/));
@@ -808,7 +864,76 @@ class BaseReporter {
 			this.log(padSummaryTitle("Duration"), formatTime(executionTime) + c.dim(` (${timers})`));
 			if (blobs?.executionTimes) this.log(padSummaryTitle("Per blob") + blobs.executionTimes.map((time) => ` ${formatTime(time)}`).join(""));
 		}
+		if (this.ctx.config.experimental.printImportBreakdown) this.printImportsBreakdown();
+		this.log();
+	}
+	printImportsBreakdown() {
+		const testModules = this.ctx.state.getTestModules();
+		const allImports = [];
+		for (const testModule of testModules) {
+			const importDurations = testModule.diagnostic().importDurations;
+			for (const filePath in importDurations) {
+				const duration = importDurations[filePath];
+				allImports.push({
+					importedModuleId: filePath,
+					testModule,
+					selfTime: duration.selfTime,
+					totalTime: duration.totalTime,
+					external: duration.external
+				});
+			}
+		}
+		if (allImports.length === 0) return;
+		const sortedImports = allImports.sort((a, b) => b.totalTime - a.totalTime);
+		const maxTotalTime = sortedImports[0].totalTime;
+		const topImports = sortedImports.slice(0, 10);
+		const totalSelfTime = allImports.reduce((sum, imp) => sum + imp.selfTime, 0);
+		const totalTotalTime = allImports.reduce((sum, imp) => sum + imp.totalTime, 0);
+		const slowestImport = sortedImports[0];
+		this.log();
+		this.log(c.bold("Import Duration Breakdown") + c.dim(" (ordered by Total Time) (Top 10)"));
+		// if there are multiple files, it's highly possible that some of them will import the same large file
+		// we group them to show the distinction between those files more easily
+		//     Import Duration Breakdown (ordered by Total Time) (Top 10)
+		// .../fields/FieldFile/__tests__/FieldFile.spec.ts   self:    7ms total:  1.01s ████████████████████
+		//  ↳ tests/support/components/index.ts               self:    0ms total:  861ms █████████████████░░░
+		//  ↳ tests/support/components/renderComponent.ts     self:   59ms total:  861ms █████████████████░░░
+		// ...s__/apps/desktop/form-updater.desktop.spec.ts   self:    8ms total:  991ms ████████████████████
+		// ...sts__/apps/mobile/form-updater.mobile.spec.ts   self:   11ms total:  990ms ████████████████████
+		// shared/components/Form/__tests__/Form.spec.ts      self:    5ms total:  988ms ████████████████████
+		//  ↳ tests/support/components/index.ts               self:    0ms total:  935ms ███████████████████░
+		//  ↳ tests/support/components/renderComponent.ts     self:   61ms total:  935ms ███████████████████░
+		// ...ditor/features/link/__test__/LinkForm.spec.ts   self:    7ms total:  972ms ███████████████████░
+		//  ↳ tests/support/components/renderComponent.ts     self:   56ms total:  936ms ███████████████████░
+		const groupedImports = Object.entries(
+			groupBy(topImports, (i) => i.testModule.id)
+			// the first one is always the highest because the modules are already sorted
+		).sort(([, imps1], [, imps2]) => imps2[0].totalTime - imps1[0].totalTime);
+		for (const [_, group] of groupedImports) group.forEach((imp, index) => {
+			const barWidth = 20;
+			const filledWidth = Math.round(imp.totalTime / maxTotalTime * barWidth);
+			const bar = c.cyan("█".repeat(filledWidth)) + c.dim("░".repeat(barWidth - filledWidth));
+			// only show the arrow if there is more than 1 group
+			const pathDisplay = this.ellipsisPath(imp.importedModuleId, imp.external, groupedImports.length > 1 && index > 0);
+			this.log(`${pathDisplay} ${c.dim("self:")} ${this.importDurationTime(imp.selfTime)} ${c.dim("total:")} ${this.importDurationTime(imp.totalTime)} ${bar}`);
+		});
 		this.log();
+		this.log(c.dim("Total imports: ") + allImports.length);
+		this.log(c.dim("Slowest import (total-time): ") + formatTime(slowestImport.totalTime));
+		this.log(c.dim("Total import time (self/total): ") + formatTime(totalSelfTime) + c.dim(" / ") + formatTime(totalTotalTime));
+	}
+	importDurationTime(duration) {
+		return (duration >= 500 ? c.red : duration >= 100 ? c.yellow : (c) => c)(formatTime(duration).padStart(6));
+	}
+	ellipsisPath(path, external, nested) {
+		const pathDisplay = this.relative(path);
+		const color = external ? c.magenta : (c) => c;
+		const slicedPath = pathDisplay.slice(-44);
+		let title = "";
+		if (pathDisplay.length > slicedPath.length) title += "...";
+		if (nested) title = ` ${F_DOWN_RIGHT} ${title}`;
+		title += slicedPath;
+		return color(title.padEnd(50));
 	}
 	printErrorsSummary(files, errors) {
 		const suites = getSuites(files);
@@ -2526,21 +2651,6 @@ async function getRawErrsMapFromTsCompile(tscErrorStdout) {
 	return rawErrsMap;
 }
 
-function createIndexMap(source) {
-	const map = /* @__PURE__ */ new Map();
-	let index = 0;
-	let line = 1;
-	let column = 1;
-	for (const char of source) {
-		map.set(`${line}:${column}`, index++);
-		if (char === "\n" || char === "\r\n") {
-			line++;
-			column = 0;
-		} else column++;
-	}
-	return map;
-}
-
 class TypeCheckError extends Error {
 	name = "TypeCheckError";
 	constructor(message, stacks) {
@@ -2620,7 +2730,7 @@ class Typechecker {
 			const sortedDefinitions = [...definitions.sort((a, b) => b.start - a.start)];
 			// has no map for ".js" files that use // @ts-check
 			const traceMap = map && new TraceMap(map);
-			const indexMap = createIndexMap(parsed);
+			const indexMap = createLocationsIndexMap(parsed);
 			const markState = (task, state) => {
 				task.result = { state: task.mode === "run" || task.mode === "only" ? state : task.mode };
 				if (task.suite) markState(task.suite, state);
@@ -3141,7 +3251,7 @@ class GithubActionsReporter {
 				const title = getFullName(task, " > ");
 				for (const error of task.result?.errors ?? []) projectErrors.push({
 					project,
-					title,
+					title: project.name ? `[${project.name}] ${title}` : title,
 					error,
 					file
 				});
@@ -3702,4 +3812,4 @@ const ReportersMap = {
 	"github-actions": GithubActionsReporter
 };
 
-export { BlobReporter 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, stringify as d, TraceMap as e, formatProjectName as f, getStateSymbol as g, ancestor as h, printError as i, errorBanner as j, divider as k, Typechecker as l, generateCodeFrame as m, createDefinesScript as n, originalPositionFor as o, parse$1 as p, convertTasksToEvents as q, readBlobs as r, separator as s, truncateString as t, utils as u, withLabel as w };
+export { utils as A, BlobReporter 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, stringify as d, createIndexLocationsMap as e, formatProjectName as f, getStateSymbol as g, TraceMap as h, ancestor as i, printError as j, errorBanner as k, divider as l, Typechecker as m, generateCodeFrame as n, originalPositionFor as o, parse$1 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 };

package/dist/chunks/{index.CQwQ_SLL.js → index.6Qv1eEA6.js}

@@ -1,8 +1,8 @@
 import { chai } from '@vitest/expect';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.DGHc_BUK.js';
-import { r as rpc } from './rpc.BytlcPfC.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.Cm-kSBVi.js';
+import { r as rpc } from './rpc.BoxB0q7B.js';
 import { g as getWorkerState } from './utils.DvEY5TfP.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.DqQZzsWf.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.B8ej_ZHS.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);

package/dist/chunks/index.Chj8NDwU.js

@@ -0,0 +1,206 @@
+//#region src/messages.ts
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+
+//#endregion
+//#region src/utils.ts
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+
+//#endregion
+//#region src/main.ts
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: TYPE_REQUEST
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options$1) => _call(options$1.method, options$1.args, options$1.event, options$1.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ??= error;
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === TYPE_REQUEST) {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn ||= () => void 0;
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+
+export { createBirpc as c };

package/dist/chunks/{index.B88tjlE5.js → index.Drsj_6e7.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.D6PC4Dpu.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.456_DGfR.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils/helpers';
 

package/dist/chunks/{index.DBx1AtPJ.js → index.Z5E_ObnR.js}

@@ -1,4 +1,4 @@
-import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.BiaV1qII.js';
+import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.2VT5v0um.js';
 import { b as bench } from './benchmark.B3N2zMcH.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { expectTypeOf } from 'expect-type';

package/dist/chunks/{init-forks.DmvIFK4U.js → init-forks.v9UONQS6.js}

@@ -1,4 +1,4 @@
-import { i as init } from './init.a5SCIJ0x.js';
+import { i as init } from './init.KmQZdqFg.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them
@@ -9,13 +9,17 @@ const processOff = process.off.bind(process);
 const processRemoveAllListeners = process.removeAllListeners.bind(process);
 // Work-around for nodejs/node#55094
 if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"))) processOn("SIGTERM", () => processExit());
+processOn("error", onError);
 function workerInit(options) {
 	const { runTests } = options;
 	init({
 		post: (v) => processSend(v),
 		on: (cb) => processOn("message", cb),
 		off: (cb) => processOff("message", cb),
-		teardown: () => processRemoveAllListeners("message"),
+		teardown: () => {
+			processRemoveAllListeners("message");
+			processOff("error", onError);
+		},
 		runTests: (state, traces) => executeTests("run", state, traces),
 		collectTests: (state, traces) => executeTests("collect", state, traces),
 		setup: options.setup
@@ -28,5 +32,10 @@ function workerInit(options) {
 		}
 	}
 }
+// Prevent leaving worker in loops where it tries to send message to closed main
+// thread, errors, and tries to send the error.
+function onError(error) {
+	if (error?.code === "ERR_IPC_CHANNEL_CLOSED" || error?.code === "EPIPE") processExit(1);
+}
 
 export { workerInit as w };

package/dist/chunks/{init-threads.De6b3S3g.js → init-threads.DqYg3Trk.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.a5SCIJ0x.js';
+import { i as init } from './init.KmQZdqFg.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {

package/dist/chunks/{init.a5SCIJ0x.js → init.KmQZdqFg.js}

@@ -3,11 +3,11 @@ import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
 import { ModuleRunner } from 'vite/module-runner';
-import { b as VitestTransport } from './startModuleRunner.W28wBIgJ.js';
+import { b as VitestTransport } from './startModuleRunner.DpqpB8k3.js';
 import { e as environments } from './index.BspFP3mn.js';
 import { serializeError } from '@vitest/utils/error';
 import { T as Traces } from './traces.U4xDYhzZ.js';
-import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BytlcPfC.js';
+import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BoxB0q7B.js';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { s as setupInspect } from './inspector.CvyFGlXm.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';

package/dist/chunks/modules.BJuCwlRJ.js

@@ -0,0 +1,36 @@
+import { builtinModules } from 'node:module';
+
+// copied from vite
+// https://github.com/vitejs/vite/blob/814120f2ad387ca3d1e16c7dd403b04ca4b97f75/packages/vite/src/node/utils.ts#L106
+// Supported by Node, Deno, Bun
+const NODE_BUILTIN_NAMESPACE = "node:";
+// Supported by Deno
+const NPM_BUILTIN_NAMESPACE = "npm:";
+// Supported by Bun
+const BUN_BUILTIN_NAMESPACE = "bun:";
+// Some runtimes like Bun injects namespaced modules here, which is not a node builtin
+const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
+const { bun: isBun, deno: isDeno } = process.versions;
+// TODO: Use `isBuiltin` from `node:module`, but Deno doesn't support it
+function isBuiltin(id) {
+	if (isDeno && id.startsWith(NPM_BUILTIN_NAMESPACE)) return true;
+	if (isBun && id.startsWith(BUN_BUILTIN_NAMESPACE)) return true;
+	return isNodeBuiltin(id);
+}
+function isNodeBuiltin(id) {
+	if (id.startsWith(NODE_BUILTIN_NAMESPACE)) return true;
+	return nodeBuiltins.includes(id);
+}
+const browserExternalId = "__vite-browser-external";
+const browserExternalLength = 24;
+function isBrowserExternal(id) {
+	return id.startsWith(browserExternalId);
+}
+function toBuiltin(id) {
+	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);
+	if (id.startsWith(NPM_BUILTIN_NAMESPACE) || id.startsWith(BUN_BUILTIN_NAMESPACE) || id.startsWith(NODE_BUILTIN_NAMESPACE)) return id;
+	if (isDeno || isBun) return id;
+	return `node:${id}`;
+}
+
+export { isBrowserExternal as a, isBuiltin as i, toBuiltin as t };

package/dist/chunks/{plugin.d.B6hlg3fN.d.ts → plugin.d.v1sC_bv1.d.ts}

@@ -1,5 +1,5 @@
 import { DevEnvironment } from 'vite';
-import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.DeFcIuza.js';
+import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.Rsi0PyxX.js';
 
 /**
 * Generate a unique cache identifier.

package/dist/chunks/{reporters.d.DeFcIuza.d.ts → reporters.d.Rsi0PyxX.d.ts}

@@ -2,18 +2,18 @@ import { TaskMeta, Suite, File, TestAnnotation, TestArtifact, ImportDuration, Te
 import { TestError, SerializedError, Arrayable, ParsedStack, Awaitable } from '@vitest/utils';
 import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, L as LabelColor } from './rpc.d.RH3apGEf.js';
 import { Writable } from 'node:stream';
-import { TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
+import { DevEnvironment, TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
+import { S as SerializedTestSpecification, c as SourceModuleDiagnostic, B as BrowserTesterOptions } from './browser.d.Bz3lxTX-.js';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { BrowserCommands } from 'vitest/browser';
-import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.g6OOauRt.js';
-import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.F6jMf15V.js';
+import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.CzIjkicf.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
 import { chai } from '@vitest/expect';
 import { happyDomTypes, jsdomTypes } from 'vitest/optional-types.js';
-import { c as ContextTestEnvironment, d as WorkerExecuteContext, e as WorkerTestEnvironment } from './worker.d.DhEa3KzY.js';
+import { c as ContextTestEnvironment, d as WorkerExecuteContext, e as WorkerTestEnvironment } from './worker.d.5JNaocaN.js';
 import { O as OTELCarrier } from './traces.d.402V_yFI.js';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
 import { a as RuntimeCoverageProviderModule } from './coverage.d.BZtK59WP.js';
@@ -239,6 +239,12 @@ declare class TestModule extends SuiteImplementation {
 	readonly location: undefined;
 	readonly type = "module";
 	/**
+	* The Vite environment that processes files on the server.
+	*
+	* Can be empty if test module did not run yet.
+	*/
+	readonly viteEnvironment: DevEnvironment | undefined;
+	/**
 	* This is usually an absolute UNIX file path.
 	* It can be a virtual ID if the file is not on the disk.
 	* This value corresponds to the ID in the Vite's module graph.
@@ -1278,6 +1284,14 @@ declare class Vitest {
 	*/
 	rerunTestSpecifications(specifications: TestSpecification[], allTestsRun?: boolean): Promise<TestRunResult>;
 	private runFiles;
+	/**
+	* Returns module's diagnostic. If `testModule` is not provided, `selfTime` and `totalTime` will be aggregated across all tests.
+	*
+	* If the module was not transformed or executed, the diagnostic will be empty.
+	* @experimental
+	* @see {@link https://vitest.dev/api/advanced/vitest#getsourcemodulediagnostic}
+	*/
+	experimental_getSourceModuleDiagnostic(moduleId: string, testModule?: TestModule): Promise<SourceModuleDiagnostic>;
 	experimental_parseSpecifications(specifications: TestSpecification[], options?: {
 		/** @default os.availableParallelism() */
 		concurrency?: number;
@@ -2025,6 +2039,9 @@ declare abstract class BaseReporter implements Reporter {
 	onServerRestart(reason?: string): void;
 	reportSummary(files: File[], errors: unknown[]): void;
 	reportTestSummary(files: File[], errors: unknown[]): void;
+	private printImportsBreakdown;
+	private importDurationTime;
+	private ellipsisPath;
 	private printErrorsSummary;
 	reportBenchmarkSummary(files: File[]): void;
 	private printTaskErrors;
@@ -3019,6 +3036,12 @@ interface InlineConfig {
 			enabled: boolean;
 			sdkPath?: string;
 		};
+		/**
+		* Show imports (top 10) that take a long time.
+		*
+		* Enabling this will also show a breakdown by default in UI, but you can always press a button to toggle it.
+		*/
+		printImportBreakdown?: boolean;
 	};
 }
 interface TypecheckConfig {

package/dist/chunks/{rpc.BytlcPfC.js → rpc.BoxB0q7B.js}

@@ -1,5 +1,5 @@
 import { getSafeTimers } from '@vitest/utils/timers';
-import { c as createBirpc } from './index.0kCJoeWi.js';
+import { c as createBirpc } from './index.Chj8NDwU.js';
 import { g as getWorkerState } from './utils.DvEY5TfP.js';
 
 const { get } = Reflect;

package/dist/chunks/{setup-common.DGHc_BUK.js → setup-common.Cm-kSBVi.js}

@@ -26,7 +26,7 @@ async function setupCommonEnv(config) {
 	if (globalSetup) return;
 	globalSetup = true;
 	setSafeTimers();
-	if (config.globals) (await import('./globals.C0izxiX3.js')).registerApiGlobally();
+	if (config.globals) (await import('./globals.DOayXfHP.js')).registerApiGlobally();
 }
 function setupDefines(config) {
 	for (const key in config.defines) globalThis[key] = config.defines[key];