vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/chunks/{index.CmSc2RE5.js → index.DIWhzsUh.js}

@@ -3,8 +3,6 @@ import { Console } from 'node:console';
 // SEE https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/interfaces.js
 const LIVING_KEYS = [
 	"DOMException",
-	"URL",
-	"URLSearchParams",
 	"EventTarget",
 	"NamedNodeMap",
 	"Node",
@@ -161,9 +159,6 @@ const LIVING_KEYS = [
 	"ShadowRoot",
 	"MutationObserver",
 	"MutationRecord",
-	"Headers",
-	"AbortController",
-	"AbortSignal",
 	"Uint8Array",
 	"Uint16Array",
 	"Uint32Array",
@@ -180,8 +175,7 @@ const LIVING_KEYS = [
 	"Audio",
 	"Option",
 	"CSS"
-];
-const OTHER_KEYS = [
+], OTHER_KEYS = [
 	"addEventListener",
 	"alert",
 	"blur",
@@ -244,11 +238,8 @@ const skipKeys = [
 	"parent"
 ];
 function getWindowKeys(global, win, additionalKeys = []) {
-	const keysArray = [...additionalKeys, ...KEYS];
-	const keys = new Set(keysArray.concat(Object.getOwnPropertyNames(win)).filter((k) => {
-		if (skipKeys.includes(k)) return false;
-		if (k in global) return keysArray.includes(k);
-		return true;
+	const keysArray = [...additionalKeys, ...KEYS], keys = new Set(keysArray.concat(Object.getOwnPropertyNames(win)).filter((k) => {
+		return skipKeys.includes(k) ? false : k in global ? keysArray.includes(k) : true;
 	}));
 	return keys;
 }
@@ -256,18 +247,13 @@ function isClassLikeName(name) {
 	return name[0] === name[0].toUpperCase();
 }
 function populateGlobal(global, win, options = {}) {
-	const { bindFunctions = false } = options;
-	const keys = getWindowKeys(global, win, options.additionalKeys);
-	const originals = /* @__PURE__ */ new Map();
-	const overrideObject = /* @__PURE__ */ new Map();
+	const { bindFunctions = false } = options, keys = getWindowKeys(global, win, options.additionalKeys), originals = /* @__PURE__ */ new Map(), overrideObject = /* @__PURE__ */ new Map();
 	for (const key of keys) {
 		const boundFunction = bindFunctions && typeof win[key] === "function" && !isClassLikeName(key) && win[key].bind(win);
 		if (KEYS.includes(key) && key in global) originals.set(key, global[key]);
 		Object.defineProperty(global, key, {
 			get() {
-				if (overrideObject.has(key)) return overrideObject.get(key);
-				if (boundFunction) return boundFunction;
-				return win[key];
+				return overrideObject.has(key) ? overrideObject.get(key) : boundFunction || win[key];
 			},
 			set(v) {
 				overrideObject.set(key, v);
@@ -275,19 +261,14 @@ function populateGlobal(global, win, options = {}) {
 			configurable: true
 		});
 	}
-	global.window = global;
-	global.self = global;
-	global.top = global;
-	global.parent = global;
-	if (global.global) global.global = global;
+	if (global.window = global, global.self = global, global.top = global, global.parent = global, global.global) global.global = global;
 	// rewrite defaultView to reference the same global context
 	if (global.document && global.document.defaultView) Object.defineProperty(global.document, "defaultView", {
 		get: () => global,
 		enumerable: true,
 		configurable: true
 	});
-	skipKeys.forEach((k) => keys.add(k));
-	return {
+	return skipKeys.forEach((k) => keys.add(k)), {
 		keys,
 		skipKeys,
 		originals
@@ -296,13 +277,10 @@ function populateGlobal(global, win, options = {}) {
 
 var edge = {
 	name: "edge-runtime",
-	transformMode: "ssr",
+	viteEnvironment: "ssr",
 	async setupVM() {
-		const { EdgeVM } = await import('@edge-runtime/vm');
-		const vm = new EdgeVM({ extend: (context) => {
-			context.global = context;
-			context.Buffer = Buffer;
-			return context;
+		const { EdgeVM } = await import('@edge-runtime/vm'), vm = new EdgeVM({ extend: (context) => {
+			return context.global = context, context.Buffer = Buffer, context;
 		} });
 		return {
 			getVmContext() {
@@ -314,32 +292,24 @@ var edge = {
 		};
 	},
 	async setup(global) {
-		const { EdgeVM } = await import('@edge-runtime/vm');
-		const vm = new EdgeVM({ extend: (context) => {
-			context.global = context;
-			context.Buffer = Buffer;
-			KEYS.forEach((key) => {
+		const { EdgeVM } = await import('@edge-runtime/vm'), vm = new EdgeVM({ extend: (context) => {
+			return context.global = context, context.Buffer = Buffer, KEYS.forEach((key) => {
 				if (key in global) context[key] = global[key];
-			});
-			return context;
-		} });
-		const { keys, originals } = populateGlobal(global, vm.context, { bindFunctions: true });
+			}), context;
+		} }), { keys, originals } = populateGlobal(global, vm.context, { bindFunctions: true });
 		return { teardown(global) {
-			keys.forEach((key) => delete global[key]);
-			originals.forEach((v, k) => global[k] = v);
+			keys.forEach((key) => delete global[key]), originals.forEach((v, k) => global[k] = v);
 		} };
 	}
 };
 
 async function teardownWindow(win) {
-	if (win.close && win.happyDOM.abort) {
-		await win.happyDOM.abort();
-		win.close();
-	} else win.happyDOM.cancelAsync();
+	if (win.close && win.happyDOM.abort) await win.happyDOM.abort(), win.close();
+	else win.happyDOM.cancelAsync();
 }
 var happy = {
 	name: "happy-dom",
-	transformMode: "web",
+	viteEnvironment: "client",
 	async setupVM({ happyDOM = {} }) {
 		const { Window } = await import('happy-dom');
 		let win = new Window({
@@ -351,25 +321,21 @@ var happy = {
 				disableErrorCapturing: true
 			}
 		});
-		// TODO: browser doesn't expose Buffer, but a lot of dependencies use it
-		win.Buffer = Buffer;
 		// inject structuredClone if it exists
-		if (typeof structuredClone !== "undefined" && !win.structuredClone) win.structuredClone = structuredClone;
+		if (win.Buffer = Buffer, typeof structuredClone !== "undefined" && !win.structuredClone) win.structuredClone = structuredClone;
 		return {
 			getVmContext() {
 				return win;
 			},
 			async teardown() {
-				await teardownWindow(win);
-				win = void 0;
+				await teardownWindow(win), win = void 0;
 			}
 		};
 	},
 	async setup(global, { happyDOM = {} }) {
 		// happy-dom v3 introduced a breaking change to Window, but
 		// provides GlobalWindow as a way to use previous behaviour
-		const { Window, GlobalWindow } = await import('happy-dom');
-		const win = new (GlobalWindow || Window)({
+		const { Window, GlobalWindow } = await import('happy-dom'), win = new (GlobalWindow || Window)({
 			...happyDOM,
 			console: console && global.console ? global.console : void 0,
 			url: happyDOM.url || "http://localhost:3000",
@@ -377,8 +343,7 @@ var happy = {
 				...happyDOM.settings,
 				disableErrorCapturing: true
 			}
-		});
-		const { keys, originals } = populateGlobal(global, win, {
+		}), { keys, originals } = populateGlobal(global, win, {
 			bindFunctions: true,
 			additionalKeys: [
 				"Request",
@@ -388,9 +353,7 @@ var happy = {
 			]
 		});
 		return { async teardown(global) {
-			await teardownWindow(win);
-			keys.forEach((key) => delete global[key]);
-			originals.forEach((v, k) => global[k] = v);
+			await teardownWindow(win), keys.forEach((key) => delete global[key]), originals.forEach((v, k) => global[k] = v);
 		} };
 	}
 };
@@ -400,27 +363,22 @@ function catchWindowErrors(window) {
 	function throwUnhandlerError(e) {
 		if (userErrorListenerCount === 0 && e.error != null) process.emit("uncaughtException", e.error);
 	}
-	const addEventListener = window.addEventListener.bind(window);
-	const removeEventListener = window.removeEventListener.bind(window);
-	window.addEventListener("error", throwUnhandlerError);
-	window.addEventListener = function(...args) {
+	const addEventListener = window.addEventListener.bind(window), removeEventListener = window.removeEventListener.bind(window);
+	return window.addEventListener("error", throwUnhandlerError), window.addEventListener = function(...args) {
 		if (args[0] === "error") userErrorListenerCount++;
 		return addEventListener.apply(this, args);
-	};
-	window.removeEventListener = function(...args) {
+	}, window.removeEventListener = function(...args) {
 		if (args[0] === "error" && userErrorListenerCount) userErrorListenerCount--;
 		return removeEventListener.apply(this, args);
-	};
-	return function clearErrorHandlers() {
+	}, function clearErrorHandlers() {
 		window.removeEventListener("error", throwUnhandlerError);
 	};
 }
 var jsdom = {
 	name: "jsdom",
-	transformMode: "web",
+	viteEnvironment: "client",
 	async setupVM({ jsdom = {} }) {
-		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
-		const { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom;
+		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom'), { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom;
 		let dom = new JSDOM(html, {
 			pretendToBeVisual,
 			resources: resources ?? (userAgent ? new ResourceLoader({ userAgent }) : void 0),
@@ -434,16 +392,11 @@ var jsdom = {
 			...restOptions
 		});
 		const clearWindowErrors = catchWindowErrors(dom.window);
-		// TODO: browser doesn't expose Buffer, but a lot of dependencies use it
-		dom.window.Buffer = Buffer;
-		dom.window.jsdom = dom;
+		dom.window.Buffer = Buffer, dom.window.jsdom = dom;
 		// inject web globals if they missing in JSDOM but otherwise available in Nodejs
 		// https://nodejs.org/dist/latest/docs/api/globals.html
 		const globalNames = [
 			"structuredClone",
-			"fetch",
-			"Request",
-			"Response",
 			"BroadcastChannel",
 			"MessageChannel",
 			"MessagePort",
@@ -454,21 +407,33 @@ var jsdom = {
 			const value = globalThis[name];
 			if (typeof value !== "undefined" && typeof dom.window[name] === "undefined") dom.window[name] = value;
 		}
+		// since we are providing Node.js's Fetch API,
+		// we also should override other APIs they use
+		const overrideGlobals = [
+			"fetch",
+			"Request",
+			"Response",
+			"Headers",
+			"AbortController",
+			"AbortSignal",
+			"URL",
+			"URLSearchParams"
+		];
+		for (const name of overrideGlobals) {
+			const value = globalThis[name];
+			if (typeof value !== "undefined") dom.window[name] = value;
+		}
 		return {
 			getVmContext() {
 				return dom.getInternalVMContext();
 			},
 			teardown() {
-				clearWindowErrors();
-				dom.window.close();
-				dom = void 0;
+				clearWindowErrors(), dom.window.close(), dom = void 0;
 			}
 		};
 	},
 	async setup(global, { jsdom = {} }) {
-		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
-		const { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom;
-		const dom = new JSDOM(html, {
+		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom'), { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom, dom = new JSDOM(html, {
 			pretendToBeVisual,
 			resources: resources ?? (userAgent ? new ResourceLoader({ userAgent }) : void 0),
 			runScripts,
@@ -479,16 +444,9 @@ var jsdom = {
 			contentType,
 			userAgent,
 			...restOptions
-		});
-		const { keys, originals } = populateGlobal(global, dom.window, { bindFunctions: true });
-		const clearWindowErrors = catchWindowErrors(global);
-		global.jsdom = dom;
-		return { teardown(global) {
-			clearWindowErrors();
-			dom.window.close();
-			delete global.jsdom;
-			keys.forEach((key) => delete global[key]);
-			originals.forEach((v, k) => global[k] = v);
+		}), { keys, originals } = populateGlobal(global, dom.window, { bindFunctions: true }), clearWindowErrors = catchWindowErrors(global);
+		return global.jsdom = dom, { teardown(global) {
+			clearWindowErrors(), dom.window.close(), delete global.jsdom, keys.forEach((key) => delete global[key]), originals.forEach((v, k) => global[k] = v);
 		} };
 	}
 };
@@ -501,19 +459,26 @@ const denyList = new Set([
 	"Buffer",
 	"ArrayBuffer",
 	"Uint8Array"
-]);
-const nodeGlobals = new Map(Object.getOwnPropertyNames(globalThis).filter((global) => !denyList.has(global)).map((nodeGlobalsKey) => {
-	const descriptor = Object.getOwnPropertyDescriptor(globalThis, nodeGlobalsKey);
-	if (!descriptor) throw new Error(`No property descriptor for ${nodeGlobalsKey}, this is a bug in Vitest.`);
-	return [nodeGlobalsKey, descriptor];
-}));
+]), nodeGlobals = /* @__PURE__ */ new Map();
+function populateNodeGlobals() {
+	if (nodeGlobals.size !== 0) return;
+	const names = Object.getOwnPropertyNames(globalThis), length = names.length;
+	for (let i = 0; i < length; i++) {
+		const globalName = names[i];
+		if (!denyList.has(globalName)) {
+			const descriptor = Object.getOwnPropertyDescriptor(globalThis, globalName);
+			if (!descriptor) throw new Error(`No property descriptor for ${globalName}, this is a bug in Vitest.`);
+			nodeGlobals.set(globalName, descriptor);
+		}
+	}
+}
 var node = {
 	name: "node",
-	transformMode: "ssr",
+	viteEnvironment: "ssr",
 	async setupVM() {
+		populateNodeGlobals();
 		const vm = await import('node:vm');
-		let context = vm.createContext();
-		let global = vm.runInContext("this", context);
+		let context = vm.createContext(), global = vm.runInContext("this", context);
 		const contextGlobals = new Set(Object.getOwnPropertyNames(global));
 		for (const [nodeGlobalsKey, descriptor] of nodeGlobals) if (!contextGlobals.has(nodeGlobalsKey)) if (descriptor.configurable) Object.defineProperty(global, nodeGlobalsKey, {
 			configurable: true,
@@ -521,14 +486,12 @@ var node = {
 			get() {
 				// @ts-expect-error: no index signature
 				const val = globalThis[nodeGlobalsKey];
-				// override lazy getter
-				Object.defineProperty(global, nodeGlobalsKey, {
+				return Object.defineProperty(global, nodeGlobalsKey, {
 					configurable: true,
 					enumerable: descriptor.enumerable,
 					value: val,
 					writable: descriptor.writable === true || nodeGlobalsKey === "performance"
-				});
-				return val;
+				}), val;
 			},
 			set(val) {
 				// override lazy getter
@@ -552,26 +515,17 @@ var node = {
 			get: descriptor.get,
 			set: descriptor.set
 		});
-		global.global = global;
-		global.Buffer = Buffer;
-		global.ArrayBuffer = ArrayBuffer;
-		// TextEncoder (global or via 'util') references a Uint8Array constructor
-		// different than the global one used by users in tests. This makes sure the
-		// same constructor is referenced by both.
-		global.Uint8Array = Uint8Array;
-		return {
+		return global.global = global, global.Buffer = Buffer, global.ArrayBuffer = ArrayBuffer, global.Uint8Array = Uint8Array, {
 			getVmContext() {
 				return context;
 			},
 			teardown() {
-				context = void 0;
-				global = void 0;
+				context = void 0, global = void 0;
 			}
 		};
 	},
 	async setup(global) {
-		global.console.Console = Console;
-		return { teardown(global) {
+		return global.console.Console = Console, { teardown(global) {
 			delete global.console.Console;
 		} };
 	}

package/dist/chunks/{inspector.C914Efll.js → inspector.CvQD-Nie.js}

@@ -2,55 +2,40 @@ import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 
 const __require = createRequire(import.meta.url);
-let inspector;
-let session;
+let inspector, session;
 /**
 * Enables debugging inside `worker_threads` and `child_process`.
 * Should be called as early as possible when worker/process has been set up.
 */
 function setupInspect(ctx) {
-	const config = ctx.config;
-	const isEnabled = config.inspector.enabled;
+	const config = ctx.config, isEnabled = config.inspector.enabled;
 	if (isEnabled) {
 		inspector = __require("node:inspector");
 		// Inspector may be open already if "isolate: false" is used
 		const isOpen = inspector.url() !== void 0;
 		if (!isOpen) {
-			inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger);
-			if (config.inspectBrk) {
+			if (inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger), config.inspectBrk) {
 				const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
 				// Stop at first test file
-				if (firstTestFile) {
-					session = new inspector.Session();
-					session.connect();
-					session.post("Debugger.enable");
-					session.post("Debugger.setBreakpointByUrl", {
-						lineNumber: 0,
-						url: pathToFileURL(firstTestFile)
-					});
-				}
+				if (firstTestFile) session = new inspector.Session(), session.connect(), session.post("Debugger.enable"), session.post("Debugger.setBreakpointByUrl", {
+					lineNumber: 0,
+					url: pathToFileURL(firstTestFile)
+				});
 			}
 		}
 	}
 	const keepOpen = shouldKeepOpen(config);
 	return function cleanup() {
-		if (isEnabled && !keepOpen && inspector) {
-			inspector.close();
-			session?.disconnect();
-		}
+		if (isEnabled && !keepOpen && inspector) inspector.close(), session?.disconnect();
 	};
 }
 function closeInspector(config) {
 	const keepOpen = shouldKeepOpen(config);
-	if (inspector && !keepOpen) {
-		inspector.close();
-		session?.disconnect();
-	}
+	if (inspector && !keepOpen) inspector.close(), session?.disconnect();
 }
 function shouldKeepOpen(config) {
 	// In watch mode the inspector can persist re-runs if isolation is disabled and a single worker is used
-	const isIsolatedSingleThread = config.pool === "threads" && config.poolOptions?.threads?.isolate === false && config.poolOptions?.threads?.singleThread;
-	const isIsolatedSingleFork = config.pool === "forks" && config.poolOptions?.forks?.isolate === false && config.poolOptions?.forks?.singleFork;
+	const isIsolatedSingleThread = config.pool === "threads" && config.poolOptions?.threads?.isolate === false && config.poolOptions?.threads?.singleThread, isIsolatedSingleFork = config.pool === "forks" && config.poolOptions?.forks?.isolate === false && config.poolOptions?.forks?.singleFork;
 	return config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);
 }
 

package/dist/chunks/moduleRunner.d.BNa-CL9e.d.ts

@@ -0,0 +1,201 @@
+import * as _vitest_spy from '@vitest/spy';
+import vm from 'node:vm';
+import * as viteModuleRunner from 'vite/module-runner';
+import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, EvaluatedModules } from 'vite/module-runner';
+import { a as RuntimeRPC, W as WorkerGlobalState } from './worker.d.B_Fd9M_w.js';
+import { R as ResolveFunctionResult } from './environment.d.BsToaxti.js';
+import { MockedModule, MockedModuleType } from '@vitest/mocker';
+import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './mocker.d.BE_2ls6u.js';
+
+declare class FileMap {
+	private fsCache;
+	private fsBufferCache;
+	readFileAsync(path: string): Promise<string>;
+	readFile(path: string): string;
+	readBuffer(path: string): Buffer<ArrayBuffer>;
+}
+
+interface ModuleEvaluateOptions {
+	timeout?: vm.RunningScriptOptions["timeout"] | undefined;
+	breakOnSigint?: vm.RunningScriptOptions["breakOnSigint"] | undefined;
+}
+type ModuleLinker = (specifier: string, referencingModule: VMModule, extra: {
+	assert: object;
+}) => VMModule | Promise<VMModule>;
+type ModuleStatus = "unlinked" | "linking" | "linked" | "evaluating" | "evaluated" | "errored";
+declare class VMModule {
+	dependencySpecifiers: readonly string[];
+	error: any;
+	identifier: string;
+	context: vm.Context;
+	namespace: object;
+	status: ModuleStatus;
+	evaluate(options?: ModuleEvaluateOptions): Promise<void>;
+	link(linker: ModuleLinker): Promise<void>;
+}
+
+interface ExternalModulesExecutorOptions {
+	context: vm.Context;
+	fileMap: FileMap;
+	packageCache: Map<string, any>;
+	transform: RuntimeRPC["transform"];
+	interopDefault?: boolean;
+	viteClientModule: Record<string, unknown>;
+}
+declare class ExternalModulesExecutor {
+	#private;
+	private options;
+	private cjs;
+	private esm;
+	private vite;
+	private context;
+	private fs;
+	private resolvers;
+	constructor(options: ExternalModulesExecutorOptions);
+	import(identifier: string): Promise<object>;
+	require(identifier: string): any;
+	createRequire(identifier: string): NodeJS.Require;
+	importModuleDynamically: (specifier: string, referencer: VMModule) => Promise<VMModule>;
+	resolveModule: (specifier: string, referencer: string) => Promise<VMModule>;
+	resolve(specifier: string, parent: string): string;
+	private getModuleInformation;
+	private createModule;
+	private get isNetworkSupported();
+}
+
+type ModuleExecutionInfo = Map<string, ModuleExecutionInfoEntry>;
+interface ModuleExecutionInfoEntry {
+	startOffset: number;
+	/** The duration that was spent executing the module. */
+	duration: number;
+	/** The time that was spent executing the module itself and externalized imports. */
+	selfTime: number;
+}
+
+interface VitestModuleEvaluatorOptions {
+	interopDefault?: boolean | undefined;
+	moduleExecutionInfo?: ModuleExecutionInfo;
+	getCurrentTestFilepath?: () => string | undefined;
+	compiledFunctionArgumentsNames?: string[];
+	compiledFunctionArgumentsValues?: unknown[];
+}
+declare class VitestModuleEvaluator implements ModuleEvaluator {
+	private options;
+	stubs: Record<string, any>;
+	env: ModuleRunnerImportMeta["env"];
+	private vm;
+	private compiledFunctionArgumentsNames?;
+	private compiledFunctionArgumentsValues;
+	private primitives;
+	private debug;
+	constructor(vmOptions?: VitestVmOptions | undefined, options?: VitestModuleEvaluatorOptions);
+	private convertIdToImportUrl;
+	runExternalModule(id: string): Promise<any>;
+	runInlinedModule(context: ModuleRunnerContext, code: string, module: Readonly<EvaluatedModuleNode>): Promise<any>;
+	private createRequire;
+	private shouldInterop;
+}
+declare function createImportMetaEnvProxy(): ModuleRunnerImportMeta["env"];
+declare function getDefaultRequestStubs(context?: vm.Context): Record<string, any>;
+declare function isPrimitive(v: any): boolean;
+declare function wrapId(id: string): string;
+declare function unwrapId(id: string): string;
+
+interface VitestTransportOptions {
+	fetchModule: FetchFunction;
+	resolveId: (id: string, importer?: string) => Promise<ResolveFunctionResult | null>;
+}
+
+interface MockContext {
+	/**
+	* When mocking with a factory, this refers to the module that imported the mock.
+	*/
+	callstack: null | string[];
+}
+interface VitestMockerOptions {
+	context?: vm.Context;
+	spyModule?: typeof _vitest_spy;
+	root: string;
+	moduleDirectories: string[];
+	resolveId: (id: string, importer?: string) => Promise<{
+		id: string;
+		file: string;
+		url: string;
+	} | null>;
+	getCurrentTestFilepath: () => string | undefined;
+}
+declare class VitestMocker {
+	moduleRunner: VitestModuleRunner;
+	private options;
+	static pendingIds: PendingSuiteMock[];
+	private spyModule?;
+	private primitives;
+	private filterPublicKeys;
+	private registries;
+	private mockContext;
+	constructor(moduleRunner: VitestModuleRunner, options: VitestMockerOptions);
+	private get root();
+	private get evaluatedModules();
+	private get moduleDirectories();
+	initializeSpyModule(): Promise<void>;
+	private getMockerRegistry;
+	reset(): void;
+	private invalidateModuleById;
+	private isModuleDirectory;
+	getSuiteFilepath(): string;
+	private createError;
+	resolveId(rawId: string, importer?: string): Promise<{
+		id: string;
+		url: string;
+		external: string | null;
+	}>;
+	resolveMocks(): Promise<void>;
+	private ensureModule;
+	private callFunctionMock;
+	getMockContext(): MockContext;
+	getMockPath(dep: string): string;
+	getDependencyMock(id: string): MockedModule | undefined;
+	findMockRedirect(mockPath: string, external: string | null): string | null;
+	mockObject(object: Record<string | symbol, any>, mockExports?: Record<string | symbol, any>, behavior?: "automock" | "autospy"): Record<string | symbol, any>;
+	unmockPath(id: string): void;
+	mockPath(originalId: string, id: string, url: string, external: string | null, mockType: MockedModuleType | undefined, factory: MockFactory | undefined): void;
+	importActual<T>(rawId: string, importer: string, callstack?: string[] | null): Promise<T>;
+	importMock(rawId: string, importer: string): Promise<any>;
+	requestWithMockedModule(url: string, evaluatedNode: EvaluatedModuleNode, callstack: string[], mock: MockedModule): Promise<any>;
+	mockedRequest(url: string, evaluatedNode: EvaluatedModuleNode, callstack: string[]): Promise<any>;
+	queueMock(id: string, importer: string, factoryOrOptions?: MockFactory | MockOptions): void;
+	queueUnmock(id: string, importer: string): void;
+}
+declare module "vite/module-runner" {
+	interface EvaluatedModuleNode {
+		mockedExports?: Record<string, any>;
+	}
+}
+
+type CreateImportMeta = NonNullable<viteModuleRunner.ModuleRunnerOptions["createImportMeta"]>;
+declare class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
+	private vitestOptions;
+	mocker: VitestMocker;
+	moduleExecutionInfo: ModuleExecutionInfo;
+	constructor(vitestOptions: VitestModuleRunnerOptions);
+	import(rawId: string): Promise<any>;
+	fetchModule(url: string, importer?: string): Promise<EvaluatedModuleNode>;
+	private _cachedRequest;
+}
+interface VitestModuleRunnerOptions {
+	transport: VitestTransportOptions;
+	evaluator: VitestModuleEvaluator;
+	evaluatedModules: EvaluatedModules;
+	getWorkerState: () => WorkerGlobalState;
+	mocker?: VitestMocker;
+	vm?: VitestVmOptions;
+	spyModule?: typeof _vitest_spy;
+	createImportMeta?: CreateImportMeta;
+}
+interface VitestVmOptions {
+	context: vm.Context;
+	externalModulesExecutor: ExternalModulesExecutor;
+}
+
+export { VitestModuleRunner as V, VitestModuleEvaluator as b, createImportMetaEnvProxy as c, getDefaultRequestStubs as g, isPrimitive as i, unwrapId as u, wrapId as w };
+export type { VitestModuleEvaluatorOptions as a };

package/dist/chunks/{node.fjCdwEIl.js → node.BsdMi6DV.js}

@@ -1,6 +1,6 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.XdZDrNZV.js';
-import '@vitest/utils';
+import { g as getWorkerState } from './utils.DGKhod2J.js';
+import '@vitest/utils/timers';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
 	getHeader() {

package/dist/chunks/{plugin.d.C2EcJUjo.d.ts → plugin.d.C5phQR6o.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.DxZg19fy.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.CVzhsTvK.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;