vitest 4.0.14 → 4.0.16

package/dist/chunks/{startModuleRunner.W28wBIgJ.js → startModuleRunner.DpqpB8k3.js}

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
-import nodeModule, { isBuiltin } from 'node:module';
 import { isBareImport } from '@vitest/utils/helpers';
+import { i as isBuiltin, a as isBrowserExternal, t as toBuiltin } from './modules.BJuCwlRJ.js';
 import { pathToFileURL } from 'node:url';
 import { normalize as normalize$1, join as join$1 } from 'pathe';
 import { distDir } from '../path.js';
@@ -9,6 +9,7 @@ import { VitestModuleEvaluator, unwrapId } from '../module-evaluator.js';
 import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
 import vm from 'node:vm';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
+import nodeModule from 'node:module';
 import * as viteModuleRunner from 'vite/module-runner';
 import { T as Traces } from './traces.U4xDYhzZ.js';
 
@@ -754,8 +755,6 @@ function listenForErrors(state) {
 }
 
 const { readFileSync } = fs;
-const browserExternalId = "__vite-browser-external";
-const browserExternalLength = 24;
 const VITEST_VM_CONTEXT_SYMBOL = "__vitest_vm_context__";
 const cwd = process.cwd();
 const isWindows = process.platform === "win32";
@@ -777,6 +776,7 @@ function startVitestModuleRunner(options) {
 	} : void 0;
 	const evaluator = options.evaluator || new VitestModuleEvaluator(vm, {
 		traces,
+		evaluatedModules: options.evaluatedModules,
 		get moduleExecutionInfo() {
 			return state().moduleExecutionInfo;
 		},
@@ -817,7 +817,11 @@ function startVitestModuleRunner(options) {
 						invalidate: false,
 						mockedModule: resolvedMock
 					};
-					if (isBuiltin(rawId) || rawId.startsWith(browserExternalId)) return {
+					if (isBuiltin(rawId)) return {
+						externalize: rawId,
+						type: "builtin"
+					};
+					if (isBrowserExternal(rawId)) return {
 						externalize: toBuiltin(rawId),
 						type: "builtin"
 					};
@@ -853,10 +857,5 @@ function startVitestModuleRunner(options) {
 	});
 	return moduleRunner;
 }
-function toBuiltin(id) {
-	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);
-	if (!id.startsWith("node:")) id = `node:${id}`;
-	return id;
-}
 
 export { VitestModuleRunner as V, VITEST_VM_CONTEXT_SYMBOL as a, VitestTransport as b, createNodeImportMeta as c, startVitestModuleRunner as s };

package/dist/chunks/{test.DqQZzsWf.js → test.B8ej_ZHS.js}

@@ -7,8 +7,8 @@ import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
 import { getTests, getNames, getTestName } from '@vitest/runner/utils';
 import { processError } from '@vitest/utils/error';
 import { normalize } from 'pathe';
-import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.BiaV1qII.js';
-import { r as rpc } from './rpc.BytlcPfC.js';
+import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.2VT5v0um.js';
+import { r as rpc } from './rpc.BoxB0q7B.js';
 
 function createBenchmarkResult(name) {
 	return {
@@ -122,8 +122,11 @@ class VitestTestRunner {
 	assertionsErrors = /* @__PURE__ */ new WeakMap();
 	pool = this.workerState.ctx.pool;
 	_otel;
+	viteEnvironment;
 	constructor(config) {
 		this.config = config;
+		const environment = this.workerState.environment;
+		this.viteEnvironment = environment.viteEnvironment || environment.name;
 	}
 	importFile(filepath, source) {
 		if (source === "setup") {
@@ -223,9 +226,11 @@ class VitestTestRunner {
 	getImportDurations() {
 		const importDurations = {};
 		const entries = this.workerState.moduleExecutionInfo?.entries() || [];
-		for (const [filepath, { duration, selfTime }] of entries) importDurations[normalize(filepath)] = {
+		for (const [filepath, { duration, selfTime, external, importer }] of entries) importDurations[normalize(filepath)] = {
 			selfTime,
-			totalTime: duration
+			totalTime: duration,
+			external,
+			importer
 		};
 		return importDurations;
 	}

package/dist/chunks/{vi.BiaV1qII.js → vi.2VT5v0um.js}

@@ -1,8 +1,8 @@
 import { chai, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
 import { getCurrentTest } from '@vitest/runner';
-import { getNames, getTestName } from '@vitest/runner/utils';
 import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.DvEY5TfP.js';
-import { getSafeTimers } from '@vitest/utils/timers';
+import { getSafeTimers, delay } from '@vitest/utils/timers';
+import { getNames } from '@vitest/runner/utils';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import '@vitest/utils/error';
 import { assertTypes, createSimpleStackTrace } from '@vitest/utils/helpers';
@@ -25,6 +25,18 @@ const unsupported = [
 	"toThrow",
 	"toThrowError"
 ];
+/**
+* Attaches a `cause` property to the error if missing, copies the stack trace from the source, and throws.
+*
+* @param error - The error to throw
+* @param source - Error to copy the stack trace from
+*
+* @throws Always throws the provided error with an amended stack trace
+*/
+function throwWithCause(error, source) {
+	if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
+	throw copyStackTrace$1(error, source);
+}
 function createExpectPoll(expect) {
 	return function poll(fn, options = {}) {
 		const defaults = getWorkerState().config.expect?.poll ?? {};
@@ -41,35 +53,33 @@ function createExpectPoll(expect) {
 			if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
 			return function(...args) {
 				const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
-				const promise = () => new Promise((resolve, reject) => {
-					let intervalId;
-					let timeoutId;
-					let lastError;
+				const promise = async () => {
 					const { setTimeout, clearTimeout } = getSafeTimers();
-					const check = async () => {
-						try {
-							chai.util.flag(assertion, "_name", key);
-							const obj = await fn();
-							chai.util.flag(assertion, "object", obj);
-							resolve(await assertionFunction.call(assertion, ...args));
-							clearTimeout(intervalId);
-							clearTimeout(timeoutId);
-						} catch (err) {
-							lastError = err;
-							if (!chai.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
-						}
-					};
-					timeoutId = setTimeout(() => {
-						clearTimeout(intervalId);
-						chai.util.flag(assertion, "_isLastPollAttempt", true);
-						const rejectWithCause = (error) => {
-							if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
-							reject(copyStackTrace$1(error, STACK_TRACE_ERROR));
-						};
-						check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
+					let executionPhase = "fn";
+					let hasTimedOut = false;
+					const timerId = setTimeout(() => {
+						hasTimedOut = true;
 					}, timeout);
-					check();
-				});
+					chai.util.flag(assertion, "_name", key);
+					try {
+						while (true) {
+							const isLastAttempt = hasTimedOut;
+							if (isLastAttempt) chai.util.flag(assertion, "_isLastPollAttempt", true);
+							try {
+								executionPhase = "fn";
+								const obj = await fn();
+								chai.util.flag(assertion, "object", obj);
+								executionPhase = "assertion";
+								return await assertionFunction.call(assertion, ...args);
+							} catch (err) {
+								if (isLastAttempt || executionPhase === "assertion" && chai.util.flag(assertion, "_poll.assert_once")) throwWithCause(err, STACK_TRACE_ERROR);
+								await delay(interval, setTimeout);
+							}
+						}
+					} finally {
+						clearTimeout(timerId);
+					}
+				};
 				let awaited = false;
 				test.onFinished ??= [];
 				test.onFinished.push(() => {
@@ -315,7 +325,7 @@ function createExpect(test) {
 		get testPath() {
 			return getWorkerState().filepath;
 		},
-		currentTestName: test ? getTestName(test) : globalState.currentTestName
+		currentTestName: test ? test.fullTestName ?? "" : globalState.currentTestName
 	}, expect);
 	expect.assert = chai.assert;
 	// @ts-expect-error untyped

package/dist/chunks/{vm.BbVD4fJ5.js → vm.qFl6P1nF.js}

@@ -1,7 +1,7 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import vm, { isContext, runInContext } from 'node:vm';
 import { dirname, basename, extname, normalize, resolve } from 'pathe';
-import { l as loadEnvironment } from './init.a5SCIJ0x.js';
+import { l as loadEnvironment } from './init.KmQZdqFg.js';
 import { distDir } from '../path.js';
 import { createCustomConsole } from './console.Cf-YriPC.js';
 import fs from 'node:fs';
@@ -11,7 +11,7 @@ import { findNearestPackageData } from '@vitest/utils/resolver';
 import { dirname as dirname$1 } from 'node:path';
 import { CSS_LANGS_RE, KNOWN_ASSET_RE } from '@vitest/utils/constants';
 import { getDefaultRequestStubs } from '../module-evaluator.js';
-import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.W28wBIgJ.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta, a as VITEST_VM_CONTEXT_SYMBOL } from './startModuleRunner.DpqpB8k3.js';
 import { p as provideWorkerState } from './utils.DvEY5TfP.js';
 
 function interopCommonJsModule(interopDefault, mod) {

package/dist/chunks/worker.d.5JNaocaN.d.ts

@@ -0,0 +1,254 @@
+import { FileSpecification, Task, CancelReason } from '@vitest/runner';
+import { EvaluatedModules } from 'vite/module-runner';
+import { S as SerializedConfig } from './config.d.CzIjkicf.js';
+import { E as Environment } from './environment.d.CrsxCzP1.js';
+import { R as RuntimeRPC, a as RunnerRPC } from './rpc.d.RH3apGEf.js';
+
+//#region src/messages.d.ts
+declare const TYPE_REQUEST: "q";
+interface RpcRequest {
+  /**
+   * Type
+   */
+  t: typeof TYPE_REQUEST;
+  /**
+   * ID
+   */
+  i?: string;
+  /**
+   * Method
+   */
+  m: string;
+  /**
+   * Arguments
+   */
+  a: any[];
+  /**
+   * Optional
+   */
+  o?: boolean;
+}
+//#endregion
+//#region src/utils.d.ts
+type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
+type ReturnType<T> = T extends ((...args: any) => infer R) ? R : never;
+type Thenable<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/main.d.ts
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver<This> = (this: This, name: string, resolved: (...args: unknown[]) => unknown) => Thenable<((...args: any[]) => any) | undefined>;
+interface ChannelOptions {
+  /**
+   * Function to post raw message
+   */
+  post: (data: any, ...extras: any[]) => Thenable<any>;
+  /**
+   * Listener to receive raw message
+   */
+  on: (fn: (data: any, ...extras: any[]) => void) => Thenable<any>;
+  /**
+   * Clear the listener when `$close` is called
+   */
+  off?: (fn: (data: any, ...extras: any[]) => void) => Thenable<any>;
+  /**
+   * Custom function to serialize data
+   *
+   * by default it passes the data as-is
+   */
+  serialize?: (data: any) => any;
+  /**
+   * Custom function to deserialize data
+   *
+   * by default it passes the data as-is
+   */
+  deserialize?: (data: any) => any;
+  /**
+   * Call the methods with the RPC context or the original functions object
+   */
+  bind?: 'rpc' | 'functions';
+  /**
+   * Custom meta data to attached to the RPC instance's `$meta` property
+   */
+  meta?: any;
+}
+interface EventOptions<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> {
+  /**
+   * Names of remote functions that do not need response.
+   */
+  eventNames?: (keyof RemoteFunctions)[];
+  /**
+   * Maximum timeout for waiting for response, in milliseconds.
+   *
+   * @default 60_000
+   */
+  timeout?: number;
+  /**
+   * Whether to proxy the remote functions.
+   *
+   * When `proxify` is false, calling the remote function
+   * with `rpc.$call('method', ...args)` instead of `rpc.method(...args)`
+   * explicitly is required.
+   *
+   * @default true
+   */
+  proxify?: Proxify;
+  /**
+   * Custom resolver to resolve function to be called
+   *
+   * For advanced use cases only
+   */
+  resolver?: BirpcResolver<BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>>;
+  /**
+   * Hook triggered before an event is sent to the remote
+   *
+   * @param req - Request parameters
+   * @param next - Function to continue the request
+   * @param resolve - Function to resolve the response directly
+   */
+  onRequest?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, req: RpcRequest, next: (req?: RpcRequest) => Promise<any>, resolve: (res: any) => void) => void | Promise<void>;
+  /**
+   * Custom error handler for errors occurred in local functions being called
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onFunctionError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, error: Error, functionName: string, args: any[]) => boolean | void;
+  /**
+   * Custom error handler for errors occurred during serialization or messsaging
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onGeneralError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, error: Error, functionName?: string, args?: any[]) => boolean | void;
+  /**
+   * Custom error handler for timeouts
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onTimeoutError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = EventOptions<RemoteFunctions, LocalFunctions, Proxify> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+  /**
+   * Send event without asking for response
+   */
+  asEvent: (...args: ArgumentsType<T>) => Promise<void>;
+};
+interface BirpcReturnBuiltin<RemoteFunctions, LocalFunctions = Record<string, unknown>> {
+  /**
+   * Raw functions object
+   */
+  $functions: LocalFunctions;
+  /**
+   * Whether the RPC is closed
+   */
+  readonly $closed: boolean;
+  /**
+   * Custom meta data attached to the RPC instance
+   */
+  readonly $meta: any;
+  /**
+   * Close the RPC connection
+   */
+  $close: (error?: Error) => void;
+  /**
+   * Reject pending calls
+   */
+  $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
+  /**
+   * Call the remote function and wait for the result.
+   * An alternative to directly calling the function
+   */
+  $call: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<Awaited<ReturnType<RemoteFunctions[K$1]>>>;
+  /**
+   * Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
+   */
+  $callOptional: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<Awaited<ReturnType<RemoteFunctions[K$1]> | undefined>>;
+  /**
+   * Send event without asking for response
+   */
+  $callEvent: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<void>;
+  /**
+   * Call the remote function with the raw options.
+   */
+  $callRaw: (options: {
+    method: string;
+    args: unknown[];
+    event?: boolean;
+    optional?: boolean;
+  }) => Promise<Awaited<ReturnType<any>>[]>;
+}
+type ProxifiedRemoteFunctions<RemoteFunctions extends object = Record<string, unknown>> = { [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]> };
+type BirpcReturn<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = Proxify extends true ? ProxifiedRemoteFunctions<RemoteFunctions> & BirpcReturnBuiltin<RemoteFunctions, LocalFunctions> : BirpcReturnBuiltin<RemoteFunctions, LocalFunctions>;
+type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
+interface PromiseEntry {
+  resolve: (arg: any) => void;
+  reject: (error: any) => void;
+  method: string;
+  timeoutId?: ReturnType<typeof setTimeout>;
+}
+declare const setTimeout: typeof globalThis.setTimeout;
+
+type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
+interface ContextTestEnvironment {
+	name: string;
+	options: Record<string, any> | null;
+}
+interface WorkerTestEnvironment {
+	name: string;
+	options: Record<string, any> | null;
+}
+type TestExecutionMethod = "run" | "collect";
+interface WorkerExecuteContext {
+	files: FileSpecification[];
+	providedContext: Record<string, any>;
+	invalidates?: string[];
+	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
+	workerId: number;
+}
+interface ContextRPC {
+	pool: string;
+	config: SerializedConfig;
+	projectName: string;
+	environment: WorkerTestEnvironment;
+	rpc: WorkerRPC;
+	files: FileSpecification[];
+	providedContext: Record<string, any>;
+	invalidates?: string[];
+	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
+	workerId: number;
+}
+interface WorkerSetupContext {
+	environment: WorkerTestEnvironment;
+	pool: string;
+	config: SerializedConfig;
+	projectName: string;
+	rpc: WorkerRPC;
+}
+interface WorkerGlobalState {
+	ctx: ContextRPC;
+	config: SerializedConfig;
+	rpc: WorkerRPC;
+	current?: Task;
+	filepath?: string;
+	metaEnv: {
+		[key: string]: any;
+		BASE_URL: string;
+		MODE: string;
+		DEV: boolean;
+		PROD: boolean;
+		SSR: boolean;
+	};
+	environment: Environment;
+	evaluatedModules: EvaluatedModules;
+	resolvingModules: Set<string>;
+	moduleExecutionInfo: Map<string, any>;
+	onCancel: (listener: (reason: CancelReason) => unknown) => void;
+	onCleanup: (listener: () => unknown) => void;
+	providedContext: Record<string, any>;
+	durations: {
+		environment: number;
+		prepare: number;
+	};
+	onFilterStackTrace?: (trace: string) => string;
+}
+
+export type { BirpcOptions as B, ContextRPC as C, TestExecutionMethod as T, WorkerGlobalState as W, WorkerSetupContext as a, BirpcReturn as b, ContextTestEnvironment as c, WorkerExecuteContext as d, WorkerTestEnvironment as e };

package/dist/cli.js

@@ -1,10 +1,10 @@
-import { c as createCLI } from './chunks/cac.DnEx6DOX.js';
+import { c as createCLI } from './chunks/cac.BGonGPac.js';
 import '@vitest/utils/helpers';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
 import './chunks/constants.D_Q9UYh-.js';
-import './chunks/index.D6PC4Dpu.js';
+import './chunks/index.456_DGfR.js';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:perf_hooks';

package/dist/config.d.ts

@@ -1,9 +1,9 @@
 import { HookHandler, ConfigEnv, UserConfig } from 'vite';
 export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.DeFcIuza.js';
-export { b as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.DeFcIuza.js';
-import { V as VitestPluginContext } from './chunks/plugin.d.B6hlg3fN.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d.g6OOauRt.js';
+import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.Rsi0PyxX.js';
+export { b as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.Rsi0PyxX.js';
+import { V as VitestPluginContext } from './chunks/plugin.d.v1sC_bv1.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.CzIjkicf.js';
 import '@vitest/runner';
 import '@vitest/utils';
 import './chunks/rpc.d.RH3apGEf.js';
@@ -11,12 +11,12 @@ import '@vitest/snapshot';
 import 'vite/module-runner';
 import './chunks/traces.d.402V_yFI.js';
 import 'node:stream';
+import './chunks/browser.d.Bz3lxTX-.js';
+import './chunks/worker.d.5JNaocaN.js';
+import './chunks/environment.d.CrsxCzP1.js';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
 import 'vitest/browser';
-import './chunks/browser.d.F6jMf15V.js';
-import './chunks/worker.d.DhEa3KzY.js';
-import './chunks/environment.d.CrsxCzP1.js';
 import '@vitest/pretty-format';
 import '@vitest/utils/diff';
 import '@vitest/expect';

package/dist/coverage.d.ts

@@ -1,20 +1,20 @@
-import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, a as ReportContext } from './chunks/reporters.d.DeFcIuza.js';
+import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, a as ReportContext } from './chunks/reporters.d.Rsi0PyxX.js';
 import { TransformResult } from 'vite';
 import { A as AfterSuiteRunMeta } from './chunks/rpc.d.RH3apGEf.js';
 import '@vitest/runner';
 import '@vitest/utils';
 import 'node:stream';
-import '@vitest/mocker';
-import '@vitest/utils/source-map';
-import 'vitest/browser';
-import './chunks/config.d.g6OOauRt.js';
+import './chunks/browser.d.Bz3lxTX-.js';
+import './chunks/worker.d.5JNaocaN.js';
+import 'vite/module-runner';
+import './chunks/config.d.CzIjkicf.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
-import './chunks/browser.d.F6jMf15V.js';
-import './chunks/worker.d.DhEa3KzY.js';
-import 'vite/module-runner';
 import './chunks/environment.d.CrsxCzP1.js';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import 'vitest/browser';
 import '@vitest/expect';
 import 'vitest/optional-types.js';
 import './chunks/traces.d.402V_yFI.js';

package/dist/coverage.js

@@ -1,4 +1,4 @@
-export { B as BaseCoverageProvider } from './chunks/coverage.CtyeYmKM.js';
+export { B as BaseCoverageProvider } from './chunks/coverage.BuJUwVtg.js';
 import 'node:fs';
 import 'node:path';
 import '@vitest/utils/helpers';

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { S as SerializedTestSpecification } from './chunks/browser.d.F6jMf15V.js';
-export { B as BrowserTesterOptions } from './chunks/browser.d.F6jMf15V.js';
+import { M as ModuleDefinitionDurationsDiagnostic, U as UntrackedModuleDefinitionDiagnostic, S as SerializedTestSpecification, a as ModuleDefinitionDiagnostic, b as ModuleDefinitionLocation, c as SourceModuleDiagnostic, d as SourceModuleLocations } from './chunks/browser.d.Bz3lxTX-.js';
+export { B as BrowserTesterOptions } from './chunks/browser.d.Bz3lxTX-.js';
 import './chunks/global.d.B15mdLcR.js';
 import { File, TestAnnotation, TestArtifact, TaskResultPack, TaskEventPack, Test, TaskPopulated } from '@vitest/runner';
 export { CancelReason, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestAnnotationArtifact, TestArtifact, TestArtifactBase, TestArtifactLocation, TestArtifactRegistry, TestAttachment, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
 import { Awaitable } from '@vitest/utils';
 export { ParsedStack, SerializedError, TestError } from '@vitest/utils';
-import { b as BirpcReturn } from './chunks/worker.d.DhEa3KzY.js';
-export { C as ContextRPC, c as ContextTestEnvironment, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.DhEa3KzY.js';
-import { S as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.g6OOauRt.js';
-export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.d.g6OOauRt.js';
+import { b as BirpcReturn } from './chunks/worker.d.5JNaocaN.js';
+export { C as ContextRPC, c as ContextTestEnvironment, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.5JNaocaN.js';
+import { S as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.CzIjkicf.js';
+export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.d.CzIjkicf.js';
 import { U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext } from './chunks/rpc.d.RH3apGEf.js';
 export { A as AfterSuiteRunMeta, a as RunnerRPC, R as RuntimeRPC } from './chunks/rpc.d.RH3apGEf.js';
 import { ExpectStatic } from '@vitest/expect';
@@ -16,13 +16,14 @@ export { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectPol
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
 export { Mock, MockContext, MockInstance, MockResult, MockResultIncomplete, MockResultReturn, MockResultThrow, MockSettledResult, MockSettledResultFulfilled, MockSettledResultIncomplete, MockSettledResultRejected, Mocked, MockedClass, MockedFunction, MockedObject } from '@vitest/spy';
 export { b as bench } from './chunks/suite.d.BJWk38HB.js';
-import { EvaluatedModules } from 'vite/module-runner';
+export { V as EvaluatedModules } from './chunks/evaluatedModules.d.BxJ5omdx.js';
 export { a as BenchFunction, b as Benchmark, c as BenchmarkAPI, B as BenchmarkResult } from './chunks/benchmark.d.DAaHLpsq.js';
 export { ExpectTypeOf, expectTypeOf } from 'expect-type';
 export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
 export { DiffOptions } from '@vitest/utils/diff';
 export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
 import '@vitest/pretty-format';
+import 'vite/module-runner';
 import './chunks/environment.d.CrsxCzP1.js';
 import './chunks/traces.d.402V_yFI.js';
 import '@vitest/runner/utils';
@@ -37,6 +38,9 @@ interface SourceMap {
 	toString: () => string;
 	toUrl: () => string;
 }
+interface ExternalResult {
+	source?: string;
+}
 interface TransformResultWithSource {
 	code: string;
 	map: SourceMap | {
@@ -46,6 +50,9 @@ interface TransformResultWithSource {
 	deps?: string[];
 	dynamicDeps?: string[];
 	source?: string;
+	transformTime?: number;
+	modules?: ModuleDefinitionDurationsDiagnostic[];
+	untrackedModules?: UntrackedModuleDefinitionDiagnostic[];
 }
 interface WebSocketHandlers {
 	onTaskUpdate: (packs: TaskResultPack[], events: TaskEventPack[]) => void;
@@ -58,7 +65,8 @@ interface WebSocketHandlers {
 		color?: LabelColor;
 	}[];
 	getModuleGraph: (projectName: string, id: string, browser?: boolean) => Promise<ModuleGraphData>;
-	getTransformResult: (projectName: string, id: string, browser?: boolean) => Promise<TransformResultWithSource | undefined>;
+	getTransformResult: (projectName: string, id: string, testFileId: string, browser?: boolean) => Promise<TransformResultWithSource | undefined>;
+	getExternalResult: (id: string, testFileId: string) => Promise<ExternalResult | undefined>;
 	readTestFile: (id: string) => Promise<string | null>;
 	saveTestFile: (id: string, content: string) => Promise<void>;
 	rerun: (files: string[], resetTestNamePattern?: boolean) => Promise<void>;
@@ -484,10 +492,6 @@ interface VitestUtils {
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
 
-declare class VitestEvaluatedModules extends EvaluatedModules {
-	getModuleSourceMapById(id: string): any;
-}
-
 interface AssertType {
 	<T>(value: T): void;
 }
@@ -498,5 +502,9 @@ interface BrowserUI {
 	setIframeViewport: (width: number, height: number) => Promise<void>;
 }
 
-export { VitestEvaluatedModules as EvaluatedModules, LabelColor, ModuleGraphData, ProvidedContext, SerializedConfig, SerializedTestSpecification, UserConsoleLog, assert, assertType, createExpect, globalExpect as expect, inject, should, vi, vitest };
-export type { AssertType, BrowserUI, TransformResultWithSource, VitestUtils, WebSocketEvents, WebSocketHandlers, WebSocketRPC };
+declare namespace Experimental {
+	export { ModuleDefinitionDiagnostic, ModuleDefinitionDurationsDiagnostic, ModuleDefinitionLocation, SourceModuleDiagnostic, SourceModuleLocations, UntrackedModuleDefinitionDiagnostic };
+}
+
+export { Experimental, LabelColor, ModuleGraphData, ProvidedContext, SerializedConfig, SerializedTestSpecification, UserConsoleLog, assert, assertType, createExpect, globalExpect as expect, inject, should, vi, vitest };
+export type { AssertType, BrowserUI, ExternalResult, TransformResultWithSource, VitestUtils, WebSocketEvents, WebSocketHandlers, WebSocketRPC };

package/dist/index.js

@@ -1,13 +1,13 @@
-export { b as assert, c as createExpect, g as expect, i as inject, s as should, v as vi, d as vitest } from './chunks/vi.BiaV1qII.js';
+export { b as assert, c as createExpect, g as expect, i as inject, s as should, v as vi, d as vitest } from './chunks/vi.2VT5v0um.js';
 export { b as bench } from './chunks/benchmark.B3N2zMcH.js';
 export { V as EvaluatedModules } from './chunks/evaluatedModules.Dg1zASAC.js';
-export { a as assertType } from './chunks/index.DBx1AtPJ.js';
+export { a as assertType } from './chunks/index.Z5E_ObnR.js';
 export { expectTypeOf } from 'expect-type';
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
 export { chai } from '@vitest/expect';
-import '@vitest/runner/utils';
 import './chunks/utils.DvEY5TfP.js';
 import '@vitest/utils/timers';
+import '@vitest/runner/utils';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/utils/helpers';