vitest 4.0.0-beta.4 → 4.0.0-beta.6

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.8kKUsuDg.d.ts

@@ -0,0 +1,202 @@
+import vm from 'node:vm';
+import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, ModuleRunner, EvaluatedModules } from 'vite/module-runner';
+import { R as RuntimeRPC, W as WorkerGlobalState } from './worker.d.D9QWnzAe.js';
+import { R as ResolveFunctionResult } from './environment.d.2fYMoz3o.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;
+}
+
+// need to copy paste types for vm
+// because they require latest @types/node which we don't bundle
+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>;
+}
+// TODO: improve Node.js strict mode support in #2854
+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;
+	// dynamic import can be used in both ESM and CJS, so we have it in the executor
+	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;
+	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;
+	// public method to avoid circular dependency
+	getMockContext(): MockContext;
+	// path used to store mocked dependencies
+	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>;
+	}
+}
+
+// @ts-expect-error overriding private method
+declare class VitestModuleRunner extends ModuleRunner {
+	private options;
+	mocker: VitestMocker;
+	moduleExecutionInfo: ModuleExecutionInfo;
+	constructor(options: 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;
+}
+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/moduleTransport.I-bgQy0S.js

@@ -0,0 +1,19 @@
+class VitestTransport {
+	constructor(options) {
+		this.options = options;
+	}
+	async invoke(event) {
+		if (event.type !== "custom") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support Vite HMR events.`) };
+		if (event.event !== "vite:invoke") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support ${event.event} event.`) };
+		const { name, data } = event.data;
+		if (name !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
+		try {
+			const result = await this.options.fetchModule(...data);
+			return { result };
+		} catch (error) {
+			return { error };
+		}
+	}
+}
+
+export { VitestTransport as V };

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

@@ -1,5 +1,5 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.XdZDrNZV.js';
+import { g as getWorkerState } from './utils.C7__0Iv5.js';
 import '@vitest/utils';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {

package/dist/chunks/{plugin.d.CLhMcYdD.d.ts → plugin.d.DuiQJfUL.d.ts}

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

package/dist/chunks/{reporters.d.DWg40D2B.d.ts → reporters.d.CqR9-CDJ.d.ts}

@@ -1,21 +1,20 @@
-import { Task, CancelReason, TaskMeta, Suite, File, TestAnnotation, ImportDuration, TaskResultPack, TaskEventPack, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
-import { P as ProvidedContext, U as UserConsoleLog, b as Awaitable$1, c as Arrayable$1, A as AfterSuiteRunMeta, L as LabelColor } from './environment.d.Bhm9oc0v.js';
+import { Task, CancelReason, TaskMeta, Suite, File, TestAnnotation, ImportDuration, TaskResultPack, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
 import { ParsedStack, Awaitable, TestError, SerializedError, Arrayable } from '@vitest/utils';
+import { P as ProvidedContext, U as UserConsoleLog, b as Awaitable$1, c as Arrayable$1, A as AfterSuiteRunMeta, L as LabelColor } from './environment.d.2fYMoz3o.js';
 import { Writable } from 'node:stream';
 import { ViteDevServer, ModuleNode, TransformResult as TransformResult$1, DepOptimizationConfig, ServerOptions, UserConfig as UserConfig$1, ConfigEnv, AliasOptions } from 'vite';
 import { Console } from 'node:console';
-import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.BRP8scJf.js';
+import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.Cawq_X_N.js';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
-import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.DZo8c7fw.js';
+import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.CKNVOKm0.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { ViteNodeServerOptions } from 'vite-node';
 import * as chai from 'chai';
 import { happyDomTypes, jsdomTypes } from 'vitest/optional-types.js';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
-import { a as RuntimeCoverageProviderModule } from './coverage.d.CNYjU4GF.js';
+import { a as RuntimeCoverageProviderModule } from './coverage.d.BZtK59WP.js';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { Stats } from 'node:fs';
 
@@ -152,7 +151,7 @@ interface BrowserProviderModule {
 }
 interface BrowserProviderOptions {}
 type BrowserBuiltinProvider = "webdriverio" | "playwright" | "preview";
-type UnsupportedProperties = "browser" | "typecheck" | "alias" | "sequence" | "root" | "pool" | "poolOptions" | "runner" | "api" | "deps" | "testTransformMode" | "environment" | "environmentOptions" | "server" | "benchmark" | "name";
+type UnsupportedProperties = "browser" | "typecheck" | "alias" | "sequence" | "root" | "pool" | "poolOptions" | "runner" | "api" | "deps" | "environment" | "environmentOptions" | "server" | "benchmark" | "name";
 interface BrowserInstanceOption extends BrowserProviderOptions, Omit<ProjectConfig, UnsupportedProperties>, Pick<BrowserConfigOptions, "headless" | "locators" | "viewport" | "testerHtmlPath" | "screenshotDirectory" | "screenshotFailures"> {
 	/**
 	* Name of the browser
@@ -1174,9 +1173,11 @@ declare class BlobReporter implements Reporter {
 	start: number;
 	ctx: Vitest;
 	options: BlobOptions;
+	coverage: unknown | undefined;
 	constructor(options: BlobOptions);
 	onInit(ctx: Vitest): void;
-	onFinished(files: File[] | undefined, errors: unknown[] | undefined, coverage: unknown): Promise<void>;
+	onCoverage(coverage: unknown): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>): Promise<void>;
 }
 interface MergedBlobs {
 	files: File[];
@@ -1194,6 +1195,7 @@ declare class StateManager {
 	processTimeoutCauses: Set<string>;
 	reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
 	blobs?: MergedBlobs;
+	transformTime: number;
 	onUnhandledError?: OnUnhandledErrorCallback;
 	constructor(options: {
 		onUnhandledError?: OnUnhandledErrorCallback;
@@ -1510,26 +1512,6 @@ interface Reporter {
 	* @experimental
 	*/
 	onBrowserInit?: (project: TestProject) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestRunStart` instead
-	*/
-	onPathsCollected?: (paths?: string[]) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestRunStart` instead
-	*/
-	onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestModuleCollected` instead
-	*/
-	onCollected?: (files: File[]) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestRunEnd` instead
-	*/
-	onFinished?: (files: File[], errors: unknown[], coverage?: unknown) => Awaitable$1<void>;
-	/**
-	* @deprecated use `onTestModuleQueued`, `onTestModuleStart`, `onTestModuleEnd`, `onTestCaseReady`, `onTestCaseResult` instead
-	*/
-	onTaskUpdate?: (packs: TaskResultPack[], events: TaskEventPack[]) => Awaitable$1<void>;
 	onTestRemoved?: (trigger?: string) => Awaitable$1<void>;
 	onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable$1<void>;
 	onWatcherRerun?: (files: string[], trigger?: string) => Awaitable$1<void>;
@@ -1614,7 +1596,7 @@ declare abstract class BaseReporter implements Reporter {
 	log(...messages: any): void;
 	error(...messages: any): void;
 	relative(path: string): string;
-	onFinished(files?: File[], errors?: unknown[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, _reason: TestRunEndReason): void;
 	onTestCaseResult(testCase: TestCase): void;
 	onTestSuiteResult(testSuite: TestSuite): void;
 	onTestModuleEnd(testModule: TestModule): void;
@@ -1650,6 +1632,7 @@ declare class DefaultReporter extends BaseReporter {
 	private summary?;
 	constructor(options?: DefaultReporterOptions);
 	onTestRunStart(specifications: ReadonlyArray<TestSpecification>): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): void;
 	onTestModuleQueued(file: TestModule): void;
 	onTestModuleCollected(module: TestModule): void;
 	onTestModuleEnd(module: TestModule): void;
@@ -1658,7 +1641,6 @@ declare class DefaultReporter extends BaseReporter {
 	onHookStart(hook: ReportedHookContext): void;
 	onHookEnd(hook: ReportedHookContext): void;
 	onInit(ctx: Vitest): void;
-	onTestRunEnd(): void;
 }
 
 interface HTMLOptions {
@@ -1819,10 +1801,11 @@ declare class JsonReporter implements Reporter {
 	start: number;
 	ctx: Vitest;
 	options: JsonOptions$1;
+	coverageMap?: CoverageMap;
 	constructor(options: JsonOptions$1);
 	onInit(ctx: Vitest): void;
-	protected logTasks(files: File[], coverageMap?: CoverageMap | null): Promise<void>;
-	onFinished(files?: File[], _errors?: unknown[], coverageMap?: unknown): Promise<void>;
+	onCoverage(coverageMap: unknown): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
 	/**
 	* Writes the report to an output file if specified in the config,
 	* or logs it to the console otherwise.
@@ -1866,7 +1849,7 @@ declare class JUnitReporter implements Reporter {
 	writeElement(name: string, attrs: Record<string, any>, children: () => Promise<void>): Promise<void>;
 	writeLogs(task: Task, type: "err" | "out"): Promise<void>;
 	writeTasks(tasks: Task[], filename: string): Promise<void>;
-	onFinished(files?: File[]): Promise<void>;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
 }
 
 declare class DotReporter extends BaseReporter {
@@ -1877,7 +1860,7 @@ declare class DotReporter extends BaseReporter {
 	// Ignore default logging of base reporter
 	printTestModule(): void;
 	onWatcherRerun(files: string[], trigger?: string): void;
-	onFinished(files?: File[], errors?: unknown[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): void;
 	onTestModuleCollected(module: TestModule): void;
 	onTestCaseReady(test: TestCase): void;
 	onTestCaseResult(test: TestCase): void;
@@ -1894,7 +1877,7 @@ declare class GithubActionsReporter implements Reporter {
 	constructor(options?: GithubActionsReporterOptions);
 	onInit(ctx: Vitest): void;
 	onTestCaseAnnotate(testCase: TestCase, annotation: TestAnnotation): void;
-	onFinished(files?: File[], errors?: unknown[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>): void;
 }
 
 declare class HangingProcessReporter implements Reporter {
@@ -1910,12 +1893,12 @@ declare class TapReporter implements Reporter {
 	static getComment(task: Task): string;
 	private logErrorDetails;
 	protected logTasks(tasks: Task[]): void;
-	onFinished(files?: File[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): void;
 }
 
 declare class TapFlatReporter extends TapReporter {
 	onInit(ctx: Vitest): void;
-	onFinished(files?: File[]): void;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>): void;
 }
 
 declare class VerboseReporter extends DefaultReporter {
@@ -1950,7 +1933,7 @@ declare class BenchmarkReporter extends DefaultReporter {
 	onTestSuiteResult(testSuite: TestSuite): void;
 	protected printTestModule(testModule: TestModule): void;
 	private printSuiteTable;
-	onFinished(files?: File[], errors?: unknown[]): Promise<void>;
+	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, reason: TestRunEndReason): Promise<void>;
 }
 
 declare class VerboseBenchmarkReporter extends BenchmarkReporter {
@@ -2413,31 +2396,11 @@ interface SequenceOptions {
 type DepsOptimizationOptions = Omit<DepOptimizationConfig, "disabled" | "noDiscovery"> & {
 	enabled?: boolean;
 };
-interface TransformModePatterns {
-	/**
-	* Use SSR transform pipeline for all modules inside specified tests.
-	* Vite plugins will receive `ssr: true` flag when processing those files.
-	*
-	* @default tests with node or edge environment
-	*/
-	ssr?: string[];
-	/**
-	* First do a normal transform pipeline (targeting browser),
-	* then then do a SSR rewrite to run the code in Node.
-	* Vite plugins will receive `ssr: false` flag when processing those files.
-	*
-	* @default tests with jsdom or happy-dom environment
-	*/
-	web?: string[];
-}
 interface DepsOptions {
 	/**
 	* Enable dependency optimization. This can improve the performance of your tests.
 	*/
-	optimizer?: {
-		web?: DepsOptimizationOptions;
-		ssr?: DepsOptimizationOptions;
-	};
+	optimizer?: Partial<Record<"client" | "ssr" | ({} & string), DepsOptimizationOptions>>;
 	web?: {
 		/**
 		* Should Vitest process assets (.png, .svg, .jpg, etc) files and resolve them like Vite does in the browser.
@@ -2471,43 +2434,12 @@ interface DepsOptions {
 		transformGlobPattern?: RegExp | RegExp[];
 	};
 	/**
-	* Externalize means that Vite will bypass the package to native Node.
-	*
-	* Externalized dependencies will not be applied Vite's transformers and resolvers.
-	* And does not support HMR on reload.
-	*
-	* Typically, packages under `node_modules` are externalized.
-	*
-	* @deprecated If you rely on vite-node directly, use `server.deps.external` instead. Otherwise, consider using `deps.optimizer.{web,ssr}.exclude`.
-	*/
-	external?: (string | RegExp)[];
-	/**
-	* Vite will process inlined modules.
-	*
-	* This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
-	*
-	* If `true`, every dependency will be inlined
-	*
-	* @deprecated If you rely on vite-node directly, use `server.deps.inline` instead. Otherwise, consider using `deps.optimizer.{web,ssr}.include`.
-	*/
-	inline?: (string | RegExp)[] | true;
-	/**
 	* Interpret CJS module's default as named exports
 	*
 	* @default true
 	*/
 	interopDefault?: boolean;
 	/**
-	* When a dependency is a valid ESM package, try to guess the cjs version based on the path.
-	* This will significantly improve the performance in huge repo, but might potentially
-	* cause some misalignment if a package have different logic in ESM and CJS mode.
-	*
-	* @default false
-	*
-	* @deprecated Use `server.deps.fallbackCJS` instead.
-	*/
-	fallbackCJS?: boolean;
-	/**
 	* A list of directories relative to the config file that should be treated as module directories.
 	*
 	* @default ['node_modules']
@@ -2554,10 +2486,9 @@ interface InlineConfig {
 	*
 	*/
 	deps?: DepsOptions;
-	/**
-	* Vite-node server options
-	*/
-	server?: Omit<ViteNodeServerOptions, "transformMode">;
+	server?: {
+		deps?: ServerDepsOptions;
+	};
 	/**
 	* Base directory to scan for the test files
 	*
@@ -2694,7 +2625,7 @@ interface InlineConfig {
 	*/
 	globalSetup?: string | string[];
 	/**
-	* Glob patter of file paths that will trigger the whole suite rerun
+	* Glob pattern of file paths that will trigger the whole suite rerun
 	*
 	* Useful if you are testing calling CLI commands
 	*
@@ -2773,10 +2704,6 @@ interface InlineConfig {
 	*/
 	uiBase?: string;
 	/**
-	* Determine the transform method for all modules imported inside a test that matches the glob pattern.
-	*/
-	testTransformMode?: TransformModePatterns;
-	/**
 	* Format options for snapshot testing.
 	*/
 	snapshotFormat?: Omit<PrettyFormatOptions, "plugins" | "compareKeys"> & {
@@ -3194,6 +3121,30 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config"
 	minWorkers: number;
 }
 type NonProjectOptions = "shard" | "watch" | "run" | "cache" | "update" | "reporters" | "outputFile" | "teardownTimeout" | "silent" | "forceRerunTriggers" | "testNamePattern" | "ui" | "open" | "uiBase" | "snapshotFormat" | "resolveSnapshotPath" | "passWithNoTests" | "onConsoleLog" | "onStackTrace" | "dangerouslyIgnoreUnhandledErrors" | "slowTestThreshold" | "inspect" | "inspectBrk" | "coverage" | "maxWorkers" | "minWorkers" | "fileParallelism" | "watchTriggerPatterns";
+interface ServerDepsOptions {
+	/**
+	* Externalize means that Vite will bpass the package to native Node.
+	*
+	* Externalized dependencies will not be applied Vite's transformers and resolvers.
+	* And does not support HMR on reload.
+	*
+	* Typically, packages under `node_modules` are externalized.
+	*/
+	external?: (string | RegExp)[];
+	/**
+	* Vite will process inlined modules.
+	*
+	* This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
+	*
+	* If `true`, every dependency will be inlined
+	*/
+	inline?: (string | RegExp)[] | true;
+	/**
+	* Try to guess the CJS version of a package when it's invalid ESM
+	* @default false
+	*/
+	fallbackCJS?: boolean;
+}
 type ProjectConfig = Omit<InlineConfig, NonProjectOptions | "sequencer" | "deps" | "poolOptions"> & {
 	mode?: string;
 	sequencer?: Omit<SequenceOptions, "sequencer" | "seed">;
@@ -3221,5 +3172,5 @@ type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
 });
 type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 
-export { CoverageMap as C, TestSuite as E, Logger as L, TestProject as T, Vitest as V, BenchmarkReporter as aB, BenchmarkReportsMap as aC, DefaultReporter as aD, DotReporter as aE, GithubActionsReporter as aF, HangingProcessReporter as aG, JsonReporter as aH, JUnitReporter as aI, ReportersMap as aJ, TapFlatReporter as aK, TapReporter as aL, VerboseBenchmarkReporter as aM, VerboseReporter as aN, BaseReporter as aO, TestSpecification as l, VitestPackageInstaller as n, getFilePoolName as p, TestCase as s, TestCollection as t, TestModule as v };
-export type { BrowserOrchestrator as $, ApiConfig as A, TestResultSkipped as B, TestState as D, TestSuiteState as F, TestSequencerConstructor as G, HTMLOptions as H, InlineConfig as I, JsonOptions$1 as J, BenchmarkUserOptions as K, ModuleDiagnostic as M, BrowserBuiltinProvider as N, OnServerRestartHandler as O, ProcessPool as P, BrowserCommand as Q, ResolvedCoverageOptions as R, SerializedTestProject as S, UserWorkspaceConfig as U, WatcherTriggerPattern as W, BrowserCommandContext as X, BrowserConfigOptions as Y, BrowserInstanceOption as Z, BrowserModuleMocker as _, TestProjectConfiguration as a, BrowserProvider as a0, BrowserProviderInitializationOptions as a1, BrowserProviderModule as a2, BrowserProviderOptions as a3, BrowserScript as a4, BrowserServerState as a5, BrowserServerStateSession as a6, CDPSession as a7, ParentProjectBrowser as a8, ProjectBrowser as a9, TestRunEndReason as aA, BenchmarkBuiltinReporters as aP, BuiltinReporterOptions as aQ, BuiltinReporters as aR, JsonAssertionResult as aS, JsonTestResult as aT, JsonTestResults as aU, ResolvedBrowserOptions as aa, ToMatchScreenshotComparators as ab, ToMatchScreenshotOptions as ac, BuiltinEnvironment as ad, CSSModuleScopeStrategy as ae, DepsOptimizationOptions as af, EnvironmentOptions as ag, Pool as ah, PoolOptions as ai, ProjectConfig as aj, ResolvedProjectConfig as ak, ResolveSnapshotPathHandler as al, ResolveSnapshotPathHandlerContext as am, TransformModePatterns as an, TypecheckConfig as ao, VitestEnvironment as ap, BaseCoverageOptions as aq, CoverageIstanbulOptions as ar, CoverageOptions as as, CoverageProvider as at, CoverageProviderModule as au, CoverageReporter as av, CustomProviderOptions as aw, TestRunResult as ax, ReportedHookContext as ay, Reporter as az, ReportContext as b, CoverageV8Options as c, UserProjectConfigFn as d, UserProjectConfigExport as e, UserConfig as f, TestProjectInlineConfiguration as g, ResolvedConfig as h, VitestRunMode as i, VitestOptions as j, TestSequencer as k, OnTestsRerunHandler as m, WorkspaceSpec as o, JUnitOptions as q, TaskOptions as r, TestDiagnostic as u, TestModuleState as w, TestResult as x, TestResultFailed as y, TestResultPassed as z };
+export { CoverageMap as C, TestSuite as E, Logger as L, TestProject as T, Vitest as V, BenchmarkReporter as aA, BenchmarkReportsMap as aB, DefaultReporter as aC, DotReporter as aD, GithubActionsReporter as aE, HangingProcessReporter as aF, JsonReporter as aG, JUnitReporter as aH, ReportersMap as aI, TapFlatReporter as aJ, TapReporter as aK, VerboseBenchmarkReporter as aL, VerboseReporter as aM, BaseReporter as aN, TestSpecification as l, VitestPackageInstaller as n, getFilePoolName as p, TestCase as s, TestCollection as t, TestModule as v };
+export type { BrowserOrchestrator as $, ApiConfig as A, TestResultSkipped as B, TestState as D, TestSuiteState as F, TestSequencerConstructor as G, HTMLOptions as H, InlineConfig as I, JsonOptions$1 as J, BenchmarkUserOptions as K, ModuleDiagnostic as M, BrowserBuiltinProvider as N, OnServerRestartHandler as O, ProcessPool as P, BrowserCommand as Q, ResolvedCoverageOptions as R, SerializedTestProject as S, UserWorkspaceConfig as U, WatcherTriggerPattern as W, BrowserCommandContext as X, BrowserConfigOptions as Y, BrowserInstanceOption as Z, BrowserModuleMocker as _, TestProjectConfiguration as a, BrowserProvider as a0, BrowserProviderInitializationOptions as a1, BrowserProviderModule as a2, BrowserProviderOptions as a3, BrowserScript as a4, BrowserServerState as a5, BrowserServerStateSession as a6, CDPSession as a7, ParentProjectBrowser as a8, ProjectBrowser as a9, BenchmarkBuiltinReporters as aO, BuiltinReporterOptions as aP, BuiltinReporters as aQ, JsonAssertionResult as aR, JsonTestResult as aS, JsonTestResults as aT, ResolvedBrowserOptions as aa, ToMatchScreenshotComparators as ab, ToMatchScreenshotOptions as ac, BuiltinEnvironment as ad, CSSModuleScopeStrategy as ae, DepsOptimizationOptions as af, EnvironmentOptions as ag, Pool as ah, PoolOptions as ai, ProjectConfig as aj, ResolvedProjectConfig as ak, ResolveSnapshotPathHandler as al, ResolveSnapshotPathHandlerContext as am, TypecheckConfig as an, VitestEnvironment as ao, BaseCoverageOptions as ap, CoverageIstanbulOptions as aq, CoverageOptions as ar, CoverageProvider as as, CoverageProviderModule as at, CoverageReporter as au, CustomProviderOptions as av, TestRunResult as aw, ReportedHookContext as ax, Reporter as ay, TestRunEndReason as az, ReportContext as b, CoverageV8Options as c, UserProjectConfigFn as d, UserProjectConfigExport as e, UserConfig as f, TestProjectInlineConfiguration as g, ResolvedConfig as h, VitestRunMode as i, VitestOptions as j, TestSequencer as k, OnTestsRerunHandler as m, WorkspaceSpec as o, JUnitOptions as q, TaskOptions as r, TestDiagnostic as u, TestModuleState as w, TestResult as x, TestResultFailed as y, TestResultPassed as z };