vitest 5.0.5 → 5.1.0-beta.1

package/dist/chunks/{config.d.QBNYCgFU.d.ts → config.d.BgktgHfG.d.ts}

@@ -1,93 +1,7 @@
+/// <reference types="chai" />
 import { Disposable } from 'vitest/optional-runtime-types.js';
 import { Fn, FnOptions, BenchOptions as BenchOptions$1, TaskResultCompleted, TaskResultRuntimeInfo, TaskResultTimestampProviderInfo, Statistics } from 'tinybench';
 
-type VoidVarArgsFunc = (...args: unknown[]) => void;
-type SetImmediate = (callback: VoidVarArgsFunc, ...args: unknown[]) => NodeImmediate;
-type SetTimeout = (callback: VoidVarArgsFunc, delay?: number, ...args: unknown[]) => TimerId;
-type ClearTimeout = (id?: TimerId) => void;
-type SetInterval = (callback: VoidVarArgsFunc, delay?: number, ...args: unknown[]) => TimerId;
-type ClearInterval = (id?: TimerId) => void;
-type QueueMicrotask = (callback: VoidVarArgsFunc) => void;
-type TimeRemaining = () => number;
-type IdleDeadline = {
-    didTimeout: boolean;
-    timeRemaining: TimeRemaining;
-};
-type RequestIdleCallbackCallback = (deadline: IdleDeadline) => any;
-type RequestIdleCallback = (callback: RequestIdleCallbackCallback, options?: {
-    timeout?: number;
-}) => number;
-type AnimationFrameCallback = (timestamp: number) => any;
-type RequestAnimationFrame = (callback: AnimationFrameCallback) => TimerId;
-type CancelAnimationFrame = (id: TimerId) => void;
-type CancelIdleCallback = (id: TimerId) => void;
-type ClearImmediate = (id: NodeImmediate) => void;
-type TemporalTimelike = {
-    epochMilliseconds: number;
-};
-type FakeMethod = "setTimeout" | "clearTimeout" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "Date" | "nextTick" | "hrtime" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "performance" | "queueMicrotask" | "Intl" | "Temporal";
-type TimerId = number | NodeImmediate | Timer;
-type GlobalObject = Record<string, any> & {
-    setTimeout?: SetTimeout;
-    clearTimeout?: ClearTimeout;
-    setInterval?: SetInterval;
-    clearInterval?: ClearInterval;
-    setImmediate?: SetImmediate;
-    clearImmediate?: ClearImmediate;
-    queueMicrotask?: QueueMicrotask;
-    requestAnimationFrame?: RequestAnimationFrame;
-    cancelAnimationFrame?: CancelAnimationFrame;
-    requestIdleCallback?: RequestIdleCallback;
-    cancelIdleCallback?: CancelIdleCallback;
-    process?: any;
-    performance?: any;
-    Performance?: any;
-    Intl?: any;
-    Temporal?: any;
-    Promise?: typeof Promise;
-    Date: typeof Date & {
-        isFake?: boolean;
-        toSource?: () => string;
-        clock?: any;
-    };
-};
-type TimerInitialProps = {
-    func: VoidVarArgsFunc;
-    args?: unknown[];
-    type?: 'Timeout' | 'Interval' | 'Immediate' | 'AnimationFrame' | 'IdleCallback';
-    delay?: number;
-    callAt?: number;
-    createdAt?: number;
-    immediate?: boolean;
-    id?: number;
-    error?: Error;
-    interval?: number;
-    animation?: boolean;
-    requestIdleCallback?: boolean;
-    order?: number;
-    heapIndex?: number;
-};
-type Config$1 = {
-    now?: number | Date | TemporalTimelike;
-    toFake?: FakeMethod[];
-    toNotFake?: FakeMethod[];
-    loopLimit?: number;
-    shouldAdvanceTime?: boolean;
-    advanceTimeDelta?: number;
-    shouldClearNativeTimers?: boolean;
-    ignoreMissingTimers?: boolean;
-    target?: GlobalObject;
-};
-type Timer = TimerInitialProps;
-type NodeImmediateHasRef = () => boolean;
-type NodeImmediateRef = () => NodeImmediate;
-type NodeImmediateUnref = () => NodeImmediate;
-type NodeImmediate = {
-    hasRef: NodeImmediateHasRef;
-    ref: NodeImmediateRef;
-    unref: NodeImmediateUnref;
-};
-
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -250,7 +164,7 @@ interface PrettyFormatOptions {
 	quoteKeys?: boolean;
 }
 type OptionsReceived = PrettyFormatOptions;
-interface Config {
+interface Config$1 {
 	callToJSON: boolean;
 	compareKeys: CompareKeys;
 	colors: Colors;
@@ -270,10 +184,10 @@ interface Config {
 	quoteKeys: boolean;
 	maxOutputLength: number;
 }
-type Printer = (val: unknown, config: Config, indentation: string, depth: number, refs: Refs, hasCalledToJSON?: boolean) => string;
+type Printer = (val: unknown, config: Config$1, indentation: string, depth: number, refs: Refs, hasCalledToJSON?: boolean) => string;
 type Test$1 = (arg0: any) => boolean;
 interface NewPlugin {
-	serialize: (val: any, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer) => string;
+	serialize: (val: any, config: Config$1, indentation: string, depth: number, refs: Refs, printer: Printer) => string;
 	test: Test$1;
 }
 interface PluginOptions {
@@ -607,6 +521,109 @@ interface Memorize {
 declare function diff(a: any, b: any, options?: DiffOptions, memorize?: Memorize): string | undefined;
 declare function printDiffOrStringify(received: unknown, expected: unknown, options?: DiffOptions, memory?: StringifiedMemory): string | undefined;
 
+type VoidVarArgsFunc = (...args: unknown[]) => void;
+type SetImmediate = (callback: VoidVarArgsFunc, ...args: unknown[]) => NodeImmediate;
+type SetTimeout = (callback: VoidVarArgsFunc, delay?: number, ...args: unknown[]) => TimerId;
+type ClearTimeout = (id?: TimerId) => void;
+type SetInterval = (callback: VoidVarArgsFunc, delay?: number, ...args: unknown[]) => TimerId;
+type ClearInterval = (id?: TimerId) => void;
+type QueueMicrotask = (callback: VoidVarArgsFunc) => void;
+type TimeRemaining = () => number;
+type IdleDeadline = {
+    didTimeout: boolean;
+    timeRemaining: TimeRemaining;
+};
+type RequestIdleCallbackCallback = (deadline: IdleDeadline) => any;
+type RequestIdleCallback = (callback: RequestIdleCallbackCallback, options?: {
+    timeout?: number;
+}) => number;
+type AnimationFrameCallback = (timestamp: number) => any;
+type RequestAnimationFrame = (callback: AnimationFrameCallback) => TimerId;
+type CancelAnimationFrame = (id: TimerId) => void;
+type CancelIdleCallback = (id: TimerId) => void;
+type ClearImmediate = (id: NodeImmediate) => void;
+type TemporalTimelike = {
+    epochMilliseconds: number;
+};
+type FakeMethod = "setTimeout" | "clearTimeout" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "Date" | "nextTick" | "hrtime" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "performance" | "queueMicrotask" | "Intl" | "Temporal";
+type TimerId = number | NodeImmediate | Timer;
+type GlobalObject = Record<string, any> & {
+    setTimeout?: SetTimeout;
+    clearTimeout?: ClearTimeout;
+    setInterval?: SetInterval;
+    clearInterval?: ClearInterval;
+    setImmediate?: SetImmediate;
+    clearImmediate?: ClearImmediate;
+    queueMicrotask?: QueueMicrotask;
+    requestAnimationFrame?: RequestAnimationFrame;
+    cancelAnimationFrame?: CancelAnimationFrame;
+    requestIdleCallback?: RequestIdleCallback;
+    cancelIdleCallback?: CancelIdleCallback;
+    process?: any;
+    performance?: any;
+    Performance?: any;
+    Intl?: any;
+    Temporal?: any;
+    Promise?: typeof Promise;
+    Date: typeof Date & {
+        isFake?: boolean;
+        toSource?: () => string;
+        clock?: any;
+    };
+};
+type TimerInitialProps = {
+    func: VoidVarArgsFunc;
+    args?: unknown[];
+    type?: 'Timeout' | 'Interval' | 'Immediate' | 'AnimationFrame' | 'IdleCallback';
+    delay?: number;
+    callAt?: number;
+    createdAt?: number;
+    immediate?: boolean;
+    id?: number;
+    error?: Error;
+    interval?: number;
+    animation?: boolean;
+    requestIdleCallback?: boolean;
+    order?: number;
+    heapIndex?: number;
+};
+type Config = {
+    now?: number | Date | TemporalTimelike;
+    toFake?: FakeMethod[];
+    toNotFake?: FakeMethod[];
+    loopLimit?: number;
+    shouldAdvanceTime?: boolean;
+    advanceTimeDelta?: number;
+    shouldClearNativeTimers?: boolean;
+    ignoreMissingTimers?: boolean;
+    target?: GlobalObject;
+};
+type Timer = TimerInitialProps;
+type NodeImmediateHasRef = () => boolean;
+type NodeImmediateRef = () => NodeImmediate;
+type NodeImmediateUnref = () => NodeImmediate;
+type NodeImmediate = {
+    hasRef: NodeImmediateHasRef;
+    ref: NodeImmediateRef;
+    unref: NodeImmediateUnref;
+};
+
+/**
+* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of https://github.com/jestjs/jest.
+*/
+
+interface FakeTimersConfig extends Config {
+	/**
+	* Mock timer APIs imported from `node:timers` and `node:timers/promises`.
+	*
+	* @default false
+	*/
+	fakeNodeBuiltins?: boolean;
+}
+
 interface AfterSuiteRunMeta {
 	coverage?: unknown;
 	testFiles: string[];
@@ -2429,6 +2446,23 @@ interface TaskMeta {
 	__vitest_label__?: string;
 }
 /**
+* The result of an individual test attempt.
+*/
+interface TaskResultAttempt {
+	/** The state after applying the test's expected failure option. */
+	state: "pass" | "fail" | "skip";
+	/** Errors produced by this attempt. */
+	errors?: TestError[];
+	/** How long in milliseconds the attempt took to run. */
+	duration: number;
+	/** Time in milliseconds when the attempt started running. */
+	startTime: number;
+	/** The zero-based retry index within the repeat. */
+	retryIndex: number;
+	/** The zero-based repeat index. */
+	repeatIndex: number;
+}
+/**
 * The result of calling a task.
 */
 interface TaskResult {
@@ -2445,6 +2479,10 @@ interface TaskResult {
 	*/
 	errors?: TestError[];
 	/**
+	* Individual results for every retry and repeat attempt.
+	*/
+	attempts?: TaskResultAttempt[];
+	/**
 	* How long in milliseconds the task took to run.
 	*/
 	duration?: number;
@@ -3480,6 +3518,7 @@ interface FileSpecification {
 	testNamePattern?: RegExp | undefined;
 	testTagsFilter?: string[] | undefined;
 	testIds?: string[] | undefined;
+	testNames?: string[] | undefined;
 }
 type VitestRunnerImportSource = "collect" | "setup";
 type CancelReason = "keyboard-input" | "test-failure" | (string & Record<string, never>);
@@ -3655,7 +3694,7 @@ interface SerializedConfig {
 	restoreMocks: boolean;
 	unstubGlobals: boolean;
 	unstubEnvs: boolean;
-	fakeTimers: Config$1;
+	fakeTimers: FakeTimersConfig;
 	defines: Record<string, any>;
 	expect: {
 		requireAssertions?: boolean;
@@ -3731,8 +3770,10 @@ interface SerializedConfig {
 			enabled: boolean;
 			recordCanvas: boolean;
 			inlineImages: boolean;
+			ariaSnapshot: boolean;
 		};
 		trackUnhandledErrors: boolean;
+		importMapMocks: boolean | undefined;
 		detailsPanelPosition: "right" | "bottom";
 	};
 	standalone: boolean;
@@ -3793,5 +3834,5 @@ type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookT
 type RuntimeOptions = Partial<RuntimeConfig>;
 type BrowserTraceViewMode = "on" | "off" | "on-first-retry" | "on-all-retries" | "retain-on-failure";
 
-export { _vitest_spy as _, createChainable as a1, afterAll as b7, afterEach as b8, aroundAll as b9, aroundEach as ba, beforeAll as bb, beforeEach as bc, onTestFailed as bd, onTestFinished as be, disableDefaultColors as bh, SnapshotState as bn, format as f, inspect as i, stringify as s, spyOn as x, fn as y };
-export type { TestContext as $, Awaitable as A, MaybeMocked as B, Config$1 as C, DiffOptions as D, ExpectStatic as E, FileSpecification as F, MaybePartiallyMocked as G, MaybePartiallyMockedDeep as H, MockInstance as I, TestAPI as J, SuiteCollector as K, LabelColor as L, ModuleGraphData as M, SuiteAPI as N, Suite as O, ParsedStack as P, SuiteHooks as Q, RuntimeOptions as R, SerializedCoverageConfig as S, TestError as T, UserConsoleLog as U, VitestRunner as V, VitestRunnerImportSource as W, Task as X, CancelReason as Y, TestTryOptions as Z, File as a, TestAttachment as a$, ImportDuration as a0, AfterSuiteRunMeta as a2, Assertion as a3, AsymmetricMatchersContaining as a4, BaselineData as a5, Bench as a6, BenchFn as a7, BenchFnOptions as a8, BenchFromSource as a9, MockedClass as aA, MockedFunction as aB, MockedObject as aC, OnTestFailedHandler as aD, OnTestFinishedHandler as aE, RunMode as aF, TaskBase as aG, TaskResult as aH, RuntimeConfig as aI, SerializedError as aJ, SnapshotData as aK, SnapshotMatchOptions as aL, SnapshotResult as aM, SnapshotSerializer as aN, SnapshotStateOptions as aO, SnapshotSummary as aP, SnapshotUpdateState as aQ, SuiteFactory as aR, SuiteOptions as aS, TaskCustomOptions as aT, TaskMeta as aU, TaskState as aV, TestAnnotationArtifact as aW, TestAnnotationLocation as aX, TestArtifactBase as aY, TestArtifactLocation as aZ, TestArtifactRegistry as a_, BenchOptions as aa, BenchRegistration as ab, BenchRegistrationInput as ac, BenchResult as ad, BenchRunOptions as ae, BenchStorage as af, BenchmarkGroup as ag, BenchmarkProvider as ah, BrowserTraceArtifact as ai, DeeplyAllowMatchers as aj, DomainMatchResult as ak, FailureScreenshotArtifact as al, JestAssertion as am, RawMatcherFn as an, Matchers as ao, MatchersObject as ap, MockContext as aq, MockResult as ar, MockResultIncomplete as as, MockResultReturn as at, MockResultThrow as au, MockSettledResult as av, MockSettledResultFulfilled as aw, MockSettledResultIncomplete as ax, MockSettledResultRejected as ay, Mocked as az, SerializedConfig as b, TestBenchmark as b0, TestBenchmarkTask as b1, TestFunction as b2, TestOptions as b3, TestTags as b4, UncheckedSnapshot as b5, VisualRegressionArtifact as b6, SequenceHooks as bf, SequenceSetupFiles as bg, SerializableRetry as bi, BrowserTraceViewMode as bj, Arrayable as bk, AsyncLeak as bl, PrettyFormatOptions as bm, PromisifyAssertion as bo, Tester as bp, Plugin as bq, SnapshotEnvironment as br, SnapshotEnvironmentOptions as bs, FetchCachedFileSystemResult as bt, ResolveFunctionResult as bu, SerializedDiffOptions as c, StringifyOptions as d, TestTagDefinition as e, TestAnnotation as g, TestArtifact as h, TaskResultPack as j, TaskEventPack as k, SerializedRootConfig as l, Test as m, TaskPopulated as n, ProvidedContext as o, MatcherState as p, SyncExpectationResult as q, AsyncExpectationResult as r, DomainSnapshotAdapter as t, ExpectationResult as u, Procedure as v, Mock as w, MaybeMockedDeep as z };
+export { fn as B, _vitest_spy as _, createChainable as a2, afterAll as b9, afterEach as ba, aroundAll as bb, aroundEach as bc, beforeAll as bd, beforeEach as be, onTestFailed as bf, onTestFinished as bg, disableDefaultColors as bj, SnapshotState as bp, format as f, inspect as i, stringify as s, spyOn as z };
+export type { TestTryOptions as $, Awaitable as A, MaybeMockedDeep as C, DiffOptions as D, ExpectStatic as E, FileSpecification as F, MaybeMocked as G, MaybePartiallyMocked as H, MaybePartiallyMockedDeep as I, MockInstance as J, TestAPI as K, LabelColor as L, ModuleGraphData as M, SuiteCollector as N, SuiteAPI as O, ParsedStack as P, Suite as Q, RuntimeOptions as R, SerializedCoverageConfig as S, TestError as T, UserConsoleLog as U, VitestRunner as V, SuiteHooks as W, VitestRunnerImportSource as X, Task as Y, CancelReason as Z, File as a, TestArtifactLocation as a$, TestContext as a0, ImportDuration as a1, AfterSuiteRunMeta as a3, Assertion as a4, AsymmetricMatchersContaining as a5, BaselineData as a6, Bench as a7, BenchFn as a8, BenchFnOptions as a9, Mocked as aA, MockedClass as aB, MockedFunction as aC, MockedObject as aD, OnTestFailedHandler as aE, OnTestFinishedHandler as aF, RunMode as aG, TaskBase as aH, TaskResult as aI, TaskResultAttempt as aJ, RuntimeConfig as aK, SerializedError as aL, SnapshotData as aM, SnapshotMatchOptions as aN, SnapshotResult as aO, SnapshotSerializer as aP, SnapshotStateOptions as aQ, SnapshotSummary as aR, SnapshotUpdateState as aS, SuiteFactory as aT, SuiteOptions as aU, TaskCustomOptions as aV, TaskMeta as aW, TaskState as aX, TestAnnotationArtifact as aY, TestAnnotationLocation as aZ, TestArtifactBase as a_, BenchFromSource as aa, BenchOptions as ab, BenchRegistration as ac, BenchRegistrationInput as ad, BenchResult as ae, BenchRunOptions as af, BenchStorage as ag, BenchmarkGroup as ah, BenchmarkProvider as ai, BrowserTraceArtifact as aj, DeeplyAllowMatchers as ak, DomainMatchResult as al, FailureScreenshotArtifact as am, JestAssertion as an, RawMatcherFn as ao, Matchers as ap, MatchersObject as aq, MockContext as ar, MockResult as as, MockResultIncomplete as at, MockResultReturn as au, MockResultThrow as av, MockSettledResult as aw, MockSettledResultFulfilled as ax, MockSettledResultIncomplete as ay, MockSettledResultRejected as az, SerializedConfig as b, TestArtifactRegistry as b0, TestAttachment as b1, TestBenchmark as b2, TestBenchmarkTask as b3, TestFunction as b4, TestOptions as b5, TestTags as b6, UncheckedSnapshot as b7, VisualRegressionArtifact as b8, SequenceHooks as bh, SequenceSetupFiles as bi, SerializableRetry as bk, BrowserTraceViewMode as bl, Arrayable as bm, AsyncLeak as bn, PrettyFormatOptions as bo, PromisifyAssertion as bq, Tester as br, Plugin as bs, SnapshotEnvironment as bt, SnapshotEnvironmentOptions as bu, FetchCachedFileSystemResult as bv, ResolveFunctionResult as bw, SerializedDiffOptions as c, StringifyOptions as d, FakeTimersConfig as e, TestTagDefinition as g, TestAnnotation as h, TestArtifact as j, TaskResultPack as k, TaskEventPack as l, SerializedRootConfig as m, Test as n, TaskPopulated as o, ProvidedContext as p, MatcherState as q, SyncExpectationResult as r, AsyncExpectationResult as t, DomainSnapshotAdapter as u, ExpectationResult as v, Procedure as w, Mock as x, TemporalTimelike as y };

package/dist/chunks/{console.DtI4yxfN.js → console.DrMPSuFo.js}

@@ -1,9 +1,9 @@
 import { Console } from 'node:console';
 import { relative } from 'node:path';
 import { Writable } from 'node:stream';
-import { a as getSafeTimers } from './source-map.DdKI5IHB.js';
+import { a as getSafeTimers } from './source-map.BjWcsIL9.js';
 import { $ } from './tinyrainbow.Do8I1XRG.js';
-import { g as getWorkerState } from './utils.DYj33du9.js';
+import { g as getWorkerState, E as EnvironmentTeardownError } from './utils.DYj33du9.js';
 import './index.D0heQG4v.js';
 import './pathe.M-eThtNZ.Ba-7h1rE.js';
 
@@ -78,6 +78,9 @@ function createCustomConsole(defaultState) {
 			time: time || RealDate.now(),
 			size,
 			origin
+		}).catch((error) => {
+			// the log is already sent, the worker only closed before the reporter answered
+			if (!(error instanceof EnvironmentTeardownError)) throw error;
 		});
 	}
 	const stdout = new Writable({ write(data, encoding, callback) {

package/dist/chunks/{constants.-juJ8b_4.js → constants.DLYM6cZY.js}

@@ -1,6 +1,6 @@
 // if changed, update also jsdocs and docs
 const defaultPort = 51204;
-const defaultBrowserPort = 63315;
+const defaultBrowserPort = 23315;
 const defaultInspectPort = 9229;
 const API_PATH = "/__vitest_api__";
 const CONFIG_NAMES = ["vitest.config", "vite.config"];

package/dist/chunks/{creator.C5g4egeG.js → creator.BQ3onxbh.js}

@@ -2,7 +2,7 @@ import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { resolve, dirname, relative } from 'node:path';
 import { detectPackageManager, installPackage } from './index.BoyTG_B7.js';
-import { p as prompt, n as findConfigFile } from './index.1TqnEahn.js';
+import { p as prompt, n as findConfigFile } from './index.D14IAvnE.js';
 import { x } from 'tinyexec';
 import { $ } from './tinyrainbow.Do8I1XRG.js';
 import 'node:process';
@@ -16,7 +16,7 @@ import 'node:util';
 import 'vite/module-runner';
 import 'tinyglobby';
 import 'vite';
-import './constants.-juJ8b_4.js';
+import './constants.DLYM6cZY.js';
 import './defaults.B1FCaFfh.js';
 import 'node:os';
 import './env.BKKtU2WC.js';
@@ -31,8 +31,8 @@ import 'node:stream';
 import './display.BlTmubjj.js';
 import './index.D0heQG4v.js';
 import 'node:perf_hooks';
-import './source-map.DdKI5IHB.js';
-import './run.BPv-BBRv.js';
+import './source-map.BjWcsIL9.js';
+import './run.BfrMbGVD.js';
 import '../task-utils.js';
 import 'obug';
 import './resolver.CtCcxIy1.js';
@@ -48,7 +48,7 @@ import 'node:events';
 import './index.DmDMHCg8.js';
 import 'node:child_process';
 import 'node:worker_threads';
-import './cac.CLrZKo1g.js';
+import './cac.Ccf5Je_F.js';
 import 'events';
 import 'readline';
 

package/dist/chunks/{doctor.BK86Cncq.js → doctor.CPlMs7-y.js}

@@ -100,7 +100,7 @@ function log(...args) {
 	console.log(...args);
 }
 async function doctor(cliFilters, options) {
-	const { prepareVitest } = await import('./cli-api.De07GUeT.js').then(function (n) { return n.g; });
+	const { prepareVitest } = await import('./cli-api.DE22LIzq.js').then(function (n) { return n.j; });
 	log();
 	log($.inverse($.bold($.blue(" DOCTOR "))), "resolving the current configuration...");
 	const ctx = await prepareVitest({

package/dist/chunks/{environment.d.BY56MoGs.d.ts → environment.d.CbTLsZSj.d.ts}

@@ -1,4 +1,4 @@
-import { A as Awaitable } from './config.d.QBNYCgFU.js';
+import { A as Awaitable } from './config.d.BgktgHfG.js';
 
 interface EnvironmentReturn {
 	teardown: (global: any) => Awaitable<void>;

package/dist/chunks/{globals.CXEE6_2C.js → globals.TipXUFcZ.js}

@@ -1,18 +1,18 @@
-import { g as globalApis } from './constants.-juJ8b_4.js';
-import { i as index } from './index.aTZaPVhf.js';
-import './run.BPv-BBRv.js';
+import { g as globalApis } from './constants.DLYM6cZY.js';
+import { i as index } from './index.BXttT2gP.js';
+import './run.BfrMbGVD.js';
 import './index.D0heQG4v.js';
 import './tinyrainbow.Do8I1XRG.js';
 import './display.BlTmubjj.js';
 import './pathe.M-eThtNZ.Ba-7h1rE.js';
-import './source-map.DdKI5IHB.js';
+import './source-map.BjWcsIL9.js';
 import '../task-utils.js';
 import './utils.DYj33du9.js';
 import './spy.DDMXghXv.js';
 import 'chai';
 import './plugins.DPQHVT0p.js';
 import './offset.Dy-5Fdfn.js';
-import './rpc.DpkUyY1N.js';
+import './rpc.BV0XpJ5q.js';
 import 'vite/module-runner';
 import './index.DmDMHCg8.js';
 import 'tinybench';

package/dist/chunks/{index.CoUIxZd4.js → index.B03wg4V0.js}

@@ -1,10 +1,10 @@
 import * as chai from 'chai';
 import { createHook } from 'node:async_hooks';
 import { t as takeCoverageInsideWorker } from './coverage.-bm5IxnW.js';
-import { r as rpc } from './rpc.DpkUyY1N.js';
-import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.HGAqWOnX.js';
+import { r as rpc } from './rpc.BV0XpJ5q.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.llxJkJaD.js';
 import { g as getWorkerState } from './utils.DYj33du9.js';
-import { T as TestRunner } from './index.aTZaPVhf.js';
+import { T as TestRunner } from './index.BXttT2gP.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);

package/dist/chunks/{index.CK-t0WMg.js → index.BFXLpwll.js}

@@ -5,6 +5,7 @@ import { E as EnvironmentTeardownError, a as getSafeWorkerState } from './utils.
 import { pathToFileURL, URL as URL$1 } from 'node:url';
 import { distDir } from '../path.js';
 import { VitestModuleEvaluator, unwrapId } from '../module-evaluator.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { isAbsolute, resolve } from 'node:path';
 import vm from 'node:vm';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
@@ -104,10 +105,20 @@ class BareModuleMocker {
 			};
 		});
 	}
+	registeringMocks;
 	async resolveMocks() {
-		if (!BareModuleMocker.pendingIds.length) return;
-		const pendingIds = BareModuleMocker.pendingIds;
-		BareModuleMocker.pendingIds = [];
+		if (BareModuleMocker.pendingIds.length) {
+			const pendingIds = BareModuleMocker.pendingIds;
+			BareModuleMocker.pendingIds = [];
+			const registration = this.registerMocks(pendingIds, this.registeringMocks).finally(() => {
+				if (this.registeringMocks === registration) this.registeringMocks = void 0;
+			});
+			this.registeringMocks = registration;
+		}
+		await this.registeringMocks;
+	}
+	async registerMocks(pendingIds, previous) {
+		await previous?.catch(() => {});
 		const resolveMock = async (mock) => {
 			return {
 				mock,
@@ -275,6 +286,9 @@ class VitestMocker extends BareModuleMocker {
 	moduleRunner;
 	options;
 	filterPublicKeys;
+	// factories that run in the current async context, the innermost is last
+	factoryContexts = new AsyncLocalStorage();
+	pendingFactories = /* @__PURE__ */ new Map();
 	constructor(moduleRunner, options) {
 		super(options);
 		this.moduleRunner = moduleRunner;
@@ -308,12 +322,48 @@ class VitestMocker extends BareModuleMocker {
 	}
 	invalidateModuleById(id) {
 		const mockId = this.getMockPath(id);
+		this.pendingFactories.delete(mockId);
 		const node = this.evaluatedModules.getModuleById(mockId);
 		if (node) {
 			this.evaluatedModules.invalidateModule(node);
 			node.mockedExports = void 0;
 		}
 	}
+	getMockContext() {
+		return { callstack: (this.factoryContexts.getStore()?.findLast((context) => this.pendingFactories.has(context.mockId)))?.callstack ?? null };
+	}
+	/**
+	* Whether the factory of this mock runs in the current async context,
+	* or waits for a factory that runs in it. Such imports get the original module.
+	* The callstack cannot tell it: all imports from one module share the same array.
+	*/
+	isResolvingMock(mockId) {
+		if (!this.pendingFactories.has(mockId)) return false;
+		return (this.factoryContexts.getStore() ?? []).some((context) => context.mockId === mockId) || this.waitsForCurrentFactory(mockId);
+	}
+	/**
+	* Whether the module is still evaluating and waits for a factory
+	* that runs in the current async context.
+	*/
+	isWaitingForFactory(mod) {
+		return !!mod.promise && !mod.evaluated && this.waitsForCurrentFactory(mod.id);
+	}
+	waitsForCurrentFactory(id) {
+		const factories = (this.factoryContexts.getStore() ?? []).map((context) => context.mockId);
+		const visited = new Set(factories);
+		// a factory that waits for the current one makes everything that waits for it wait too
+		while (factories.length) {
+			const waiting = this.pendingFactories.get(factories.pop())?.waiting;
+			if (waiting?.has(id)) return true;
+			waiting?.forEach((waiter) => {
+				if (this.pendingFactories.has(waiter) && !visited.has(waiter)) {
+					visited.add(waiter);
+					factories.push(waiter);
+				}
+			});
+		}
+		return false;
+	}
 	ensureModule(id, url) {
 		const node = this.evaluatedModules.ensureModule(id, url);
 		// TODO
@@ -326,9 +376,53 @@ class VitestMocker extends BareModuleMocker {
 		};
 		return node;
 	}
-	async callFunctionMock(id, url, mock) {
+	callFunctionMock(id, url, mock, callstack) {
 		const node = this.ensureModule(id, url);
-		if (node.exports) return node.exports;
+		if (node.exports) return Promise.resolve(node.exports);
+		return this.resolveMockOnce(id, callstack, () => this.resolveFunctionMock(node, mock));
+	}
+	resolveMockOnce(id, callstack, resolve) {
+		const contexts = this.factoryContexts.getStore() ?? [];
+		const waiting = [...callstack, ...contexts.map((context) => context.mockId)];
+		const pending = this.pendingFactories.get(id);
+		if (pending) {
+			waiting.forEach((waiter) => pending.waiting.add(waiter));
+			return pending.promise;
+		}
+		const factory = {
+			promise: this.factoryContexts.run([...contexts, {
+				mockId: id,
+				callstack
+			}], resolve).finally(() => {
+				if (this.pendingFactories.get(id) === factory) this.pendingFactories.delete(id);
+				if (!this.pendingFactories.size)
+ // an enabled storage slows down every promise on Node 22
+				this.factoryContexts.disable();
+			}),
+			waiting: new Set(waiting)
+		};
+		this.pendingFactories.set(id, factory);
+		return factory.promise;
+	}
+	async resolveAutomock(url, mockId, evaluatedNode, callstack, type) {
+		const Object = this.primitives.Object;
+		// we have to define a separate object that will copy all properties into itself
+		// and can't just use the same `exports` define automatically by Vite before the evaluator
+		const exports = Object.create(null);
+		Object.defineProperty(exports, Symbol.toStringTag, {
+			value: "Module",
+			configurable: true,
+			writable: true
+		});
+		const node = this.ensureModule(mockId, this.getMockPath(evaluatedNode.url));
+		node.meta = evaluatedNode.meta;
+		node.file = evaluatedNode.file;
+		node.mockedExports = exports;
+		const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
+		this.mockObject(mod, exports, type);
+		return exports;
+	}
+	async resolveFunctionMock(node, mock) {
 		const exports = await mock.resolve();
 		const moduleExports = new Proxy(exports, { get: (target, prop) => {
 			const val = target[prop];
@@ -372,7 +466,10 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			const Object = this.primitives.Object;
 			return this.mockObject(mod, Object.create(Object.prototype), mock.type);
 		}
-		if (mock.type === "manual") return this.callFunctionMock(this.getMockPath(id), this.getMockPath(url), mock);
+		if (mock.type === "manual") {
+			const mockId = this.getMockPath(id);
+			return this.callFunctionMock(mockId, this.getMockPath(url), mock, [importer, mockId]);
+		}
 		const node = await this.moduleRunner.fetchModule(mock.redirect);
 		return this.moduleRunner.cachedRequest(mock.redirect, node, [importer], void 0, true);
 	}
@@ -388,36 +485,14 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			});
 			if (mock.type === "automock" || mock.type === "autospy") {
 				const cache = this.evaluatedModules.getModuleById(mockId);
-				if (cache && cache.mockedExports) return cache.mockedExports;
-				const Object = this.primitives.Object;
-				// we have to define a separate object that will copy all properties into itself
-				// and can't just use the same `exports` define automatically by Vite before the evaluator
-				const exports = Object.create(null);
-				Object.defineProperty(exports, Symbol.toStringTag, {
-					value: "Module",
-					configurable: true,
-					writable: true
-				});
-				const node = this.ensureModule(mockId, this.getMockPath(evaluatedNode.url));
-				node.meta = evaluatedNode.meta;
-				node.file = evaluatedNode.file;
-				node.mockedExports = exports;
-				const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
-				this.mockObject(mod, exports, mock.type);
-				return exports;
-			}
-			if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url)) try {
-				callstack.push(mockId);
-				// this will not work if user does Promise.all(import(), import())
-				// we can also use AsyncLocalStorage to store callstack, but this won't work in the browser
-				// maybe we should improve mock API in the future?
-				this.mockContext.callstack = callstack;
-				return await this.callFunctionMock(mockId, this.getMockPath(url), mock);
-			} finally {
-				this.mockContext.callstack = null;
-				const indexMock = callstack.indexOf(mockId);
-				callstack.splice(indexMock, 1);
+				if (cache?.mockedExports) {
+					// while the original module evaluates, only its own imports get the partial object, like in a cycle
+					const isSelfImport = callstack.includes(evaluatedNode.id) || this.isResolvingMock(mockId);
+					if (!this.pendingFactories.has(mockId) || isSelfImport) return cache.mockedExports;
+				}
+				return this.resolveMockOnce(mockId, [...callstack, mockId], () => this.resolveAutomock(url, mockId, evaluatedNode, callstack, mock.type));
 			}
+			if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url) && !this.isResolvingMock(mockId)) return this.callFunctionMock(mockId, this.getMockPath(url), mock, [...callstack, mockId]);
 			else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) {
 				span.setAttribute("vitest.mock.redirect", mock.redirect);
 				return mock.redirect;
@@ -574,6 +649,8 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	async cachedRequest(url, mod, callstack = [], metadata, ignoreMock = false) {
 		// Track for a better error message if dynamic import is not resolved properly
 		this._callstacks.set(mod, callstack);
+		// the factory imports a module that waits for this factory, treat it as a cycle
+		if (mod.exports && this.mocker.isWaitingForFactory(mod)) return mod.exports;
 		if (ignoreMock) return this._cachedRequest(url, mod, callstack, metadata);
 		let mocked;
 		if (mod.meta && "mockedModule" in mod.meta) {
@@ -585,7 +662,7 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 				const node = await this.fetchModule(injectQuery(url, "_vitest_original"));
 				return this._cachedRequest(node.url, node, callstack, metadata);
 			}
-			if (callstack.includes(mockId) || callstack.includes(url) || "redirect" in currentMock && callstack.includes(currentMock.redirect)) {
+			if (callstack.includes(mockId) || this.mocker.isResolvingMock(mockId) || callstack.includes(url) || "redirect" in currentMock && callstack.includes(currentMock.redirect)) {
 				const node = await this.fetchModule(injectQuery(url, "_vitest_original"));
 				return this._cachedRequest(node.url, node, callstack, metadata);
 			}
@@ -758,7 +835,7 @@ function startVitestModuleRunner(options) {
 				const rawId = unwrapId(id);
 				resolvingModules.add(rawId);
 				try {
-					if (VitestMocker.pendingIds.length) await moduleRunner.mocker.resolveMocks();
+					if (VitestMocker.pendingIds.length || moduleRunner.mocker.registeringMocks) await moduleRunner.mocker.resolveMocks();
 					if (!isImportActual) {
 						const resolvedMock = moduleRunner.mocker.getDependencyMockByUrl(id);
 						if (resolvedMock?.type === "manual" || resolvedMock?.type === "redirect") return {