vitest 3.2.4 → 4.0.0-beta.10

package/dist/module-evaluator.js

@@ -0,0 +1,276 @@
+import { isBuiltin, createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import vm from 'node:vm';
+import { isAbsolute } from 'pathe';
+import { ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey } from 'vite/module-runner';
+
+const performanceNow = performance.now.bind(performance);
+class ModuleDebug {
+	executionStack = [];
+	startCalculateModuleExecutionInfo(filename, startOffset) {
+		const startTime = performanceNow();
+		return this.executionStack.push({
+			filename,
+			startTime,
+			subImportTime: 0
+		}), () => {
+			const duration = performanceNow() - startTime, currentExecution = this.executionStack.pop();
+			if (currentExecution == null) throw new Error("Execution stack is empty, this should never happen");
+			const selfTime = duration - currentExecution.subImportTime;
+			if (this.executionStack.length > 0) this.executionStack.at(-1).subImportTime += duration;
+			return {
+				startOffset,
+				duration,
+				selfTime
+			};
+		};
+	}
+}
+
+const isWindows = process.platform === "win32";
+class VitestModuleEvaluator {
+	stubs = {};
+	env = createImportMetaEnvProxy();
+	vm;
+	compiledFunctionArgumentsNames;
+	compiledFunctionArgumentsValues = [];
+	primitives;
+	debug = new ModuleDebug();
+	constructor(vmOptions, options = {}) {
+		if (this.options = options, this.vm = vmOptions, this.stubs = getDefaultRequestStubs(vmOptions?.context), options.compiledFunctionArgumentsNames) this.compiledFunctionArgumentsNames = options.compiledFunctionArgumentsNames;
+		if (options.compiledFunctionArgumentsValues) this.compiledFunctionArgumentsValues = options.compiledFunctionArgumentsValues;
+		if (vmOptions) this.primitives = vm.runInContext("({ Object, Proxy, Reflect })", vmOptions.context);
+		else this.primitives = {
+			Object,
+			Proxy,
+			Reflect
+		};
+	}
+	convertIdToImportUrl(id) {
+		// TODO: vitest returns paths for external modules, but Vite returns file://
+		// unfortunetly, there is a bug in Vite where ID is resolved incorrectly, so we can't return files until the fix is merged
+		// https://github.com/vitejs/vite/pull/20449
+		if (!isWindows || isBuiltin(id) || /^(?:node:|data:|http:|https:|file:)/.test(id)) return id;
+		const [filepath, query] = id.split("?");
+		return query ? `${pathToFileURL(filepath).toString()}?${query}` : pathToFileURL(filepath).toString();
+	}
+	async runExternalModule(id) {
+		if (id in this.stubs) return this.stubs[id];
+		const file = this.convertIdToImportUrl(id), namespace = this.vm ? await this.vm.externalModulesExecutor.import(file) : await import(file);
+		if (!this.shouldInterop(file, namespace)) return namespace;
+		const { mod, defaultExport } = interopModule(namespace), { Proxy, Reflect } = this.primitives, proxy = new Proxy(mod, {
+			get(mod, prop) {
+				return prop === "default" ? defaultExport : mod[prop] ?? defaultExport?.[prop];
+			},
+			has(mod, prop) {
+				return prop === "default" ? defaultExport !== void 0 : prop in mod || defaultExport && prop in defaultExport;
+			},
+			getOwnPropertyDescriptor(mod, prop) {
+				const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+				if (descriptor) return descriptor;
+				if (prop === "default" && defaultExport !== void 0) return {
+					value: defaultExport,
+					enumerable: true,
+					configurable: true
+				};
+			}
+		});
+		return proxy;
+	}
+	async runInlinedModule(context, code, module) {
+		context.__vite_ssr_import_meta__.env = this.env;
+		const { Reflect, Proxy, Object } = this.primitives, exportsObject = context[ssrModuleExportsKey], SYMBOL_NOT_DEFINED = Symbol("not defined");
+		let moduleExports = SYMBOL_NOT_DEFINED;
+		// this proxy is triggered only on exports.{name} and module.exports access
+		// inside the module itself. imported module is always "exports"
+		const cjsExports = new Proxy(exportsObject, {
+			get: (target, p, receiver) => {
+				return Reflect.has(target, p) ? Reflect.get(target, p, receiver) : Reflect.get(Object.prototype, p, receiver);
+			},
+			getPrototypeOf: () => Object.prototype,
+			set: (_, p, value) => {
+				// treat "module.exports =" the same as "exports.default =" to not have nested "default.default",
+				// so "exports.default" becomes the actual module
+				if (p === "default" && this.shouldInterop(module.file, { default: value }) && cjsExports !== value) return exportAll(cjsExports, value), exportsObject.default = value, true;
+				if (!Reflect.has(exportsObject, "default")) exportsObject.default = {};
+				// returns undefined, when accessing named exports, if default is not an object
+				// but is still present inside hasOwnKeys, this is Node behaviour for CJS
+				if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) return defineExport(exportsObject, p, () => void 0), true;
+				if (!isPrimitive(exportsObject.default)) exportsObject.default[p] = value;
+				if (p !== "default") defineExport(exportsObject, p, () => value);
+				return true;
+			}
+		}), moduleProxy = {
+			set exports(value) {
+				exportAll(cjsExports, value), exportsObject.default = value, moduleExports = value;
+			},
+			get exports() {
+				return cjsExports;
+			}
+		}, meta = context[ssrImportMetaKey], testFilepath = this.options.getCurrentTestFilepath?.();
+		if (testFilepath === module.file) {
+			const globalNamespace = this.vm?.context || globalThis;
+			Object.defineProperty(meta, "vitest", { get: () => globalNamespace.__vitest_index__ });
+		}
+		const filename = meta.filename, dirname = meta.dirname, require = this.createRequire(filename), argumentsList = [
+			ssrModuleExportsKey,
+			ssrImportMetaKey,
+			ssrImportKey,
+			ssrDynamicImportKey,
+			ssrExportAllKey,
+			"__vite_ssr_exportName__",
+			"__filename",
+			"__dirname",
+			"module",
+			"exports",
+			"require"
+		];
+		if (this.compiledFunctionArgumentsNames) argumentsList.push(...this.compiledFunctionArgumentsNames);
+		// add 'use strict' since ESM enables it by default
+		const codeDefinition = `'use strict';async (${argumentsList.join(",")})=>{{`, wrappedCode = `${codeDefinition}${code}\n}}`, options = {
+			filename: module.id,
+			lineOffset: 0,
+			columnOffset: -codeDefinition.length
+		}, finishModuleExecutionInfo = this.debug.startCalculateModuleExecutionInfo(options.filename, codeDefinition.length);
+		try {
+			const initModule = this.vm ? vm.runInContext(wrappedCode, this.vm.context, options) : vm.runInThisContext(wrappedCode, options), dynamicRequest = async (dep, options) => {
+				return dep = String(dep), dep[0] === "#" ? context[ssrDynamicImportKey](wrapId(dep), options) : context[ssrDynamicImportKey](dep, options);
+			};
+			await initModule(
+				context[ssrModuleExportsKey],
+				context[ssrImportMetaKey],
+				context[ssrImportKey],
+				dynamicRequest,
+				context[ssrExportAllKey],
+				// vite 7 support, remove when vite 7+ is supported
+				context.__vite_ssr_exportName__ || ((name, getter) => Object.defineProperty(exportsObject, name, {
+					enumerable: true,
+					configurable: true,
+					get: getter
+				})),
+				filename,
+				dirname,
+				moduleProxy,
+				cjsExports,
+				require,
+				...this.compiledFunctionArgumentsValues
+			);
+		} finally {
+			// moduleExecutionInfo needs to use Node filename instead of the normalized one
+			// because we rely on this behaviour in coverage-v8, for example
+			this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
+		}
+	}
+	createRequire(filename) {
+		return filename.startsWith("\0") || !isAbsolute(filename) ? () => ({}) : this.vm ? this.vm.externalModulesExecutor.createRequire(filename) : createRequire(filename);
+	}
+	shouldInterop(path, mod) {
+		// never interop ESM modules
+		// TODO: should also skip for `.js` with `type="module"`
+		return this.options.interopDefault === false ? false : !path.endsWith(".mjs") && "default" in mod;
+	}
+}
+function createImportMetaEnvProxy() {
+	// packages/vitest/src/node/plugins/index.ts:146
+	const booleanKeys = [
+		"DEV",
+		"PROD",
+		"SSR"
+	];
+	return new Proxy(process.env, {
+		get(_, key) {
+			return typeof key === "string" ? booleanKeys.includes(key) ? !!process.env[key] : process.env[key] : void 0;
+		},
+		set(_, key, value) {
+			if (typeof key !== "string") return true;
+			if (booleanKeys.includes(key)) process.env[key] = value ? "1" : "";
+			else process.env[key] = value;
+			return true;
+		}
+	});
+}
+function updateStyle(id, css) {
+	if (typeof document === "undefined") return;
+	const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
+	if (element) {
+		element.textContent = css;
+		return;
+	}
+	const head = document.querySelector("head"), style = document.createElement("style");
+	style.setAttribute("type", "text/css"), style.setAttribute("data-vite-dev-id", id), style.textContent = css, head?.appendChild(style);
+}
+function removeStyle(id) {
+	if (typeof document === "undefined") return;
+	const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
+	if (sheet) document.head.removeChild(sheet);
+}
+const defaultClientStub = {
+	injectQuery: (id) => id,
+	createHotContext: () => {
+		return {
+			accept: () => {},
+			prune: () => {},
+			dispose: () => {},
+			decline: () => {},
+			invalidate: () => {},
+			on: () => {},
+			send: () => {}
+		};
+	},
+	updateStyle: () => {},
+	removeStyle: () => {}
+};
+function getDefaultRequestStubs(context) {
+	if (!context) {
+		const clientStub = {
+			...defaultClientStub,
+			updateStyle,
+			removeStyle
+		};
+		return { "/@vite/client": clientStub };
+	}
+	const clientStub = vm.runInContext(`(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`, context)(defaultClientStub);
+	return { "/@vite/client": clientStub };
+}
+function exportAll(exports, sourceModule) {
+	if (exports !== sourceModule && !(isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)) {
+		for (const key in sourceModule) if (key !== "default" && !(key in exports)) try {
+			defineExport(exports, key, () => sourceModule[key]);
+		} catch {}
+	}
+}
+// keep consistency with Vite on how exports are defined
+function defineExport(exports, key, value) {
+	Object.defineProperty(exports, key, {
+		enumerable: true,
+		configurable: true,
+		get: value
+	});
+}
+function isPrimitive(v) {
+	const isObject = typeof v === "object" || typeof v === "function";
+	return !isObject || v == null;
+}
+function interopModule(mod) {
+	if (isPrimitive(mod)) return {
+		mod: { default: mod },
+		defaultExport: mod
+	};
+	let defaultExport = "default" in mod ? mod.default : mod;
+	if (!isPrimitive(defaultExport) && "__esModule" in defaultExport) {
+		if (mod = defaultExport, "default" in defaultExport) defaultExport = defaultExport.default;
+	}
+	return {
+		mod,
+		defaultExport
+	};
+}
+const VALID_ID_PREFIX = `/@id/`, NULL_BYTE_PLACEHOLDER = `__x00__`;
+function wrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+
+export { VitestModuleEvaluator, createImportMetaEnvProxy, getDefaultRequestStubs, isPrimitive, unwrapId, wrapId };

package/dist/module-runner.js

@@ -0,0 +1,15 @@
+export { VitestModuleEvaluator } from './module-evaluator.js';
+export { a as VITEST_VM_CONTEXT_SYMBOL, V as VitestModuleRunner, s as startVitestModuleRunner } from './chunks/startModuleRunner.p67gbNo9.js';
+export { g as getWorkerState } from './chunks/utils.D2R2NiOH.js';
+import 'node:module';
+import 'node:url';
+import 'node:vm';
+import 'pathe';
+import 'vite/module-runner';
+import 'node:fs';
+import '@vitest/utils';
+import './path.js';
+import 'node:path';
+import '@vitest/utils/error';
+import '@vitest/mocker';
+import './chunks/moduleTransport.I-bgQy0S.js';

package/dist/node.d.ts

@@ -1,43 +1,68 @@
-import { z as ResolvedConfig, y as UserConfig, v as VitestRunMode, H as VitestOptions, V as Vitest, A as ApiConfig, T as TestProject, J as TestSequencer, K as TestSpecification, L as Logger, M as TestModule, N as ModuleDiagnostic } from './chunks/reporters.d.BFLkQcL6.js';
-export { B as BaseCoverageOptions, F as BenchmarkUserOptions, ag as BrowserBuiltinProvider, ah as BrowserCommand, ai as BrowserCommandContext, q as BrowserConfigOptions, aj as BrowserInstanceOption, ak as BrowserModuleMocker, al as BrowserOrchestrator, am as BrowserProvider, an as BrowserProviderInitializationOptions, ao as BrowserProviderModule, ap as BrowserProviderOptions, p as BrowserScript, aq as BrowserServerState, ar as BrowserServerStateSession, r as BuiltinEnvironment, as as CDPSession, u as CSSModuleScopeStrategy, m as CoverageIstanbulOptions, l as CoverageOptions, h as CoverageProvider, i as CoverageProviderModule, j as CoverageReporter, c as CoverageV8Options, n as CustomProviderOptions, D as DepsOptimizationOptions, a0 as HTMLOptions, I as InlineConfig, a2 as JUnitOptions, a1 as JsonOptions, O as OnServerRestartHandler, Q as OnTestsRerunHandler, at as ParentProjectBrowser, P as Pool, t as PoolOptions, Y as ProcessPool, au as ProjectBrowser, E as ProjectConfig, a as ReportContext, aA as ReportedHookContext, o as Reporter, ax as ResolveSnapshotPathHandler, ay as ResolveSnapshotPathHandlerContext, av as ResolvedBrowserOptions, R as ResolvedCoverageOptions, aw as ResolvedProjectConfig, $ as SerializedTestProject, a3 as TaskOptions, a4 as TestCase, a5 as TestCollection, a6 as TestDiagnostic, a7 as TestModuleState, a8 as TestResult, a9 as TestResultFailed, aa as TestResultPassed, ab as TestResultSkipped, aB as TestRunEndReason, az as TestRunResult, af as TestSequencerConstructor, ac as TestState, ad as TestSuite, ae as TestSuiteState, w as TransformModePatterns, x as TypecheckConfig, U as UserWorkspaceConfig, s as VitestEnvironment, X as VitestPackageInstaller, g as WatcherTriggerPattern, Z as WorkspaceSpec, _ as getFilePoolName } from './chunks/reporters.d.BFLkQcL6.js';
 import * as vite from 'vite';
 import { InlineConfig, UserConfig as UserConfig$1, Plugin, ResolvedConfig as ResolvedConfig$1, LogLevel, LoggerOptions, Logger as Logger$1 } from 'vite';
 export { vite as Vite };
 export { esbuildVersion, isCSSRequest, isFileServingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from 'vite';
 import { IncomingMessage } from 'node:http';
-import { R as RuntimeRPC } from './chunks/worker.d.1GmBbd7G.js';
-export { T as TestExecutionType } from './chunks/worker.d.1GmBbd7G.js';
+import { h as ResolvedConfig, f as UserConfig, i as VitestRunMode, j as VitestOptions, V as Vitest, A as ApiConfig, k as TestSpecification, T as TestProject, P as Pool, l as TestSequencer, L as Logger } from './chunks/reporters.d.BUWjmRYq.js';
+export { al as BaseCoverageOptions, G as BenchmarkUserOptions, K as BrowserBuiltinProvider, N as BrowserCommand, Q as BrowserCommandContext, X as BrowserConfigOptions, Y as BrowserInstanceOption, Z as BrowserModuleMocker, _ as BrowserOrchestrator, $ as BrowserProvider, a0 as BrowserProviderOption, a1 as BrowserScript, a2 as BrowserServerState, a3 as BrowserServerStateSession, aa as BuiltinEnvironment, a4 as CDPSession, ab as CSSModuleScopeStrategy, am as CoverageIstanbulOptions, an as CoverageOptions, ao as CoverageProvider, ap as CoverageProviderModule, aq as CoverageReporter, c as CoverageV8Options, ar as CustomProviderOptions, ac as DepsOptimizationOptions, ad as EnvironmentOptions, H as HTMLOptions, I as InlineConfig, o as JUnitOptions, J as JsonOptions, M as ModuleDiagnostic, O as OnServerRestartHandler, m as OnTestsRerunHandler, a5 as ParentProjectBrowser, ae as PoolOptions, a6 as ProjectBrowser, af as ProjectConfig, b as ReportContext, at as ReportedHookContext, au as Reporter, ah as ResolveSnapshotPathHandler, ai as ResolveSnapshotPathHandlerContext, a7 as ResolvedBrowserOptions, R as ResolvedCoverageOptions, ag as ResolvedProjectConfig, S as SerializedTestProject, p as TaskOptions, q as TestCase, r as TestCollection, s as TestDiagnostic, t as TestModule, u as TestModuleState, v as TestResult, w as TestResultFailed, x as TestResultPassed, y as TestResultSkipped, av as TestRunEndReason, as as TestRunResult, F as TestSequencerConstructor, z as TestState, B as TestSuite, D as TestSuiteState, a8 as ToMatchScreenshotComparators, a9 as ToMatchScreenshotOptions, aj as TypecheckConfig, U as UserWorkspaceConfig, ak as VitestEnvironment, n as VitestPackageInstaller, W as WatcherTriggerPattern, E as experimental_getRunnerTask } from './chunks/reporters.d.BUWjmRYq.js';
+import { Awaitable } from '@vitest/utils';
+export { SerializedError } from '@vitest/utils';
+import { R as RuntimeRPC } from './chunks/worker.d.BDsXGkwh.js';
+export { T as TestExecutionType } from './chunks/worker.d.BDsXGkwh.js';
 import { Writable } from 'node:stream';
-export { V as VitestPluginContext } from './chunks/vite.d.CMLlLIFP.js';
-export { W as WorkerContext } from './chunks/worker.d.CKwWzBSj.js';
-export { C as TypeCheckCollectLineNumbers, a as TypeCheckCollectLines, c as TypeCheckContext, T as TypeCheckErrorInfo, R as TypeCheckRawErrorsMap, b as TypeCheckRootAndTarget } from './chunks/global.d.MAmajcmJ.js';
+export { V as VitestPluginContext } from './chunks/plugin.d.BMVSnsGV.js';
+export { W as WorkerContext } from './chunks/worker.d.BNcX_2mH.js';
 import { Debugger } from 'debug';
+import './chunks/global.d.BK3X7FW1.js';
 export { Task as RunnerTask, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
-export { f as EnvironmentOptions, H as HappyDOMOptions, J as JSDOMOptions } from './chunks/environment.d.cL3nLXbE.js';
-export { SerializedError } from '@vitest/utils';
-export { b as RuntimeConfig } from './chunks/config.d.D2ROskhv.js';
+export { b as RuntimeConfig } from './chunks/config.d.B_LthbQq.js';
 export { generateFileHash } from '@vitest/runner/utils';
-import 'node:console';
+import './chunks/environment.d.BsToaxti.js';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
+import './chunks/browser.d.yFAklsD1.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
-import 'vite-node';
-import 'chai';
-import './chunks/benchmark.d.BwvBVTda.js';
+import '@vitest/expect';
+import 'vitest/optional-types.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
 import 'tinybench';
-import './chunks/coverage.d.S9RMNXIe.js';
-import 'vite-node/client';
+import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
+import 'node:console';
+import 'vite/module-runner';
 import 'node:worker_threads';
-import '@vitest/expect';
-import 'vitest/optional-types.js';
-import '@vitest/snapshot/environment';
+
+type RawErrsMap = Map<string, TscErrorInfo[]>;
+interface TscErrorInfo {
+	filePath: string;
+	errCode: number;
+	errMsg: string;
+	line: number;
+	column: number;
+}
+interface CollectLineNumbers {
+	target: number;
+	next: number;
+	prev?: number;
+}
+type CollectLines = { [key in keyof CollectLineNumbers] : string };
+interface RootAndTarget {
+	root: string;
+	targetAbsPath: string;
+}
+type Context = RootAndTarget & {
+	rawErrsMap: RawErrsMap;
+	openedDirs: Set<string>;
+	lastActivePath?: string;
+};
 
 declare function isValidApiRequest(config: ResolvedConfig, req: IncomingMessage): boolean;
 
+declare function escapeTestName(label: string, dynamic: boolean): string;
+
 interface CliOptions extends UserConfig {
 	/**
 	* Override the watch mode
@@ -62,7 +87,7 @@ interface CliOptions extends UserConfig {
 	* @experimental
 	*/
 	configLoader?: InlineConfig extends {
-		configLoader?: infer T
+		configLoader?: infer T;
 	} ? T : never;
 }
 /**
@@ -76,11 +101,11 @@ interface CliParseOptions {
 	allowUnknownOptions?: boolean;
 }
 declare function parseCLI(argv: string | string[], config?: CliParseOptions): {
-	filter: string[]
-	options: CliOptions
+	filter: string[];
+	options: CliOptions;
 };
 
-declare function resolveApiServerConfig<Options extends ApiConfig & UserConfig>(options: Options, defaultPort: number): ApiConfig | undefined;
+declare function resolveApiServerConfig<Options extends ApiConfig & Omit<UserConfig, "expect">>(options: Options, defaultPort: number): ApiConfig | undefined;
 
 declare function createVitest(mode: VitestRunMode, options: CliOptions, viteOverrides?: UserConfig$1, vitestOptions?: VitestOptions): Promise<Vitest>;
 
@@ -93,22 +118,26 @@ declare class GitNotFoundError extends Error {
 	constructor();
 }
 
-/** @deprecated use `TestProject` instead */
-type GlobalSetupContext = TestProject;
-
 declare function VitestPlugin(options?: UserConfig, vitest?: Vitest): Promise<Plugin[]>;
 
-// this is only exported as a public function and not used inside vitest
 declare function resolveConfig(options?: UserConfig, viteOverrides?: UserConfig$1): Promise<{
-	vitestConfig: ResolvedConfig
-	viteConfig: ResolvedConfig$1
+	vitestConfig: ResolvedConfig;
+	viteConfig: ResolvedConfig$1;
 }>;
 
 declare function resolveFsAllow(projectRoot: string, rootConfigFile: string | false | undefined): string[];
 
+type RunWithFiles = (files: TestSpecification[], invalidates?: string[]) => Awaitable<void>;
+interface ProcessPool {
+	name: string;
+	runTests: RunWithFiles;
+	collectTests: RunWithFiles;
+	close?: () => Awaitable<void>;
+}
+declare function getFilePoolName(project: TestProject): Pool;
+
 interface MethodsOptions {
 	cacheFs?: boolean;
-	// do not report files
 	collect?: boolean;
 }
 declare function createMethodsRPC(project: TestProject, options?: MethodsOptions): RuntimeRPC;
@@ -116,18 +145,13 @@ declare function createMethodsRPC(project: TestProject, options?: MethodsOptions
 declare class BaseSequencer implements TestSequencer {
 	protected ctx: Vitest;
 	constructor(ctx: Vitest);
-	// async so it can be extended by other sequelizers
 	shard(files: TestSpecification[]): Promise<TestSpecification[]>;
-	// async so it can be extended by other sequelizers
 	sort(files: TestSpecification[]): Promise<TestSpecification[]>;
+	private calculateShardRange;
 }
 
 declare function registerConsoleShortcuts(ctx: Vitest, stdin: NodeJS.ReadStream | undefined, stdout: NodeJS.WriteStream | Writable): () => void;
 
-// This is copy-pasted and needs to be synced from time to time. Ideally, Vite's `createLogger` should accept a custom `console`
-// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/logger.ts?rgh-link-date=2024-10-16T23%3A29%3A19Z
-// When Vitest supports only Vite 6 and above, we can use Vite's `createLogger({ console })`
-// https://github.com/vitejs/vite/pull/18379
 declare function createViteLogger(console: Logger, level?: LogLevel, options?: LoggerOptions): Logger$1;
 
 declare const rootDir: string;
@@ -137,22 +161,9 @@ declare function createDebugger(namespace: `vitest:${string}`): Debugger | undef
 
 declare const version: string;
 
-/** @deprecated use `createViteServer` instead */
-declare const createServer: typeof vite.createServer;
 declare const createViteServer: typeof vite.createServer;
 
-/**
-* @deprecated Use `TestModule` instead
-*/
-declare const TestFile: typeof TestModule;
-
-/**
-* @deprecated Use `ModuleDiagnostic` instead
-*/
-type FileDiagnostic = ModuleDiagnostic;
-
-// rolldownVersion is exported only by rolldown-vite
 declare const rolldownVersion: string | undefined;
 
-export { ApiConfig, BaseSequencer, GitNotFoundError, ModuleDiagnostic, ResolvedConfig, TestFile, TestModule, TestProject, TestSequencer, TestSpecification, FilesNotFoundError as TestsNotFoundError, UserConfig, Vitest, VitestOptions, VitestPlugin, VitestRunMode, TestProject as WorkspaceProject, createDebugger, createMethodsRPC, createServer, createViteLogger, createViteServer, createVitest, distDir, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rolldownVersion, rootDir, startVitest, version };
-export type { CliParseOptions, FileDiagnostic, GlobalSetupContext };
+export { ApiConfig, BaseSequencer, GitNotFoundError, Pool, ResolvedConfig, TestProject, TestSequencer, TestSpecification, UserConfig as TestUserConfig, FilesNotFoundError as TestsNotFoundError, Vitest, VitestOptions, VitestPlugin, VitestRunMode, createDebugger, createMethodsRPC, createViteLogger, createViteServer, createVitest, distDir, escapeTestName, getFilePoolName, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rolldownVersion, rootDir, startVitest, version };
+export type { CliParseOptions, ProcessPool, CollectLineNumbers as TypeCheckCollectLineNumbers, CollectLines as TypeCheckCollectLines, Context as TypeCheckContext, TscErrorInfo as TypeCheckErrorInfo, RawErrsMap as TypeCheckRawErrorsMap, RootAndTarget as TypeCheckRootAndTarget };

package/dist/node.js

@@ -1,36 +1,33 @@
 import * as vite from 'vite';
 import { resolveConfig as resolveConfig$1, mergeConfig } from 'vite';
 export { esbuildVersion, isCSSRequest, isFileServingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from 'vite';
-import { V as Vitest, a as VitestPlugin, T as TestModule } from './chunks/cli-api.BkDphVBG.js';
-export { G as GitNotFoundError, F as TestsNotFoundError, b as VitestPackageInstaller, e as createViteLogger, c as createVitest, i as isValidApiRequest, d as registerConsoleShortcuts, r as resolveFsAllow, s as startVitest } from './chunks/cli-api.BkDphVBG.js';
-export { p as parseCLI } from './chunks/cac.Cb-PYCCB.js';
-import { r as resolveConfig$2 } from './chunks/coverage.DL5VHqXY.js';
-export { b as BaseSequencer, c as createMethodsRPC, g as getFilePoolName, a as resolveApiServerConfig } from './chunks/coverage.DL5VHqXY.js';
+import { V as Vitest, a as VitestPlugin } from './chunks/cli-api.BJJXh9BV.js';
+export { G as GitNotFoundError, F as TestsNotFoundError, b as VitestPackageInstaller, h as createDebugger, g as createViteLogger, c as createVitest, e as escapeTestName, d as experimental_getRunnerTask, i as isValidApiRequest, f as registerConsoleShortcuts, r as resolveFsAllow, s as startVitest } from './chunks/cli-api.BJJXh9BV.js';
+export { p as parseCLI } from './chunks/cac.DCxo_nSu.js';
+import { r as resolveConfig$2 } from './chunks/coverage.BCU-r2QL.js';
+export { b as BaseSequencer, c as createMethodsRPC, g as getFilePoolName, a as resolveApiServerConfig } from './chunks/coverage.BCU-r2QL.js';
 import { slash, deepClone } from '@vitest/utils';
 import { f as findUp } from './chunks/index.X0nbfr6-.js';
 import { resolve } from 'pathe';
-import { c as configFiles } from './chunks/constants.DnKduX2e.js';
+import { c as configFiles } from './chunks/constants.D_Q9UYh-.js';
 export { distDir, rootDir } from './path.js';
-import createDebug from 'debug';
 export { generateFileHash } from '@vitest/runner/utils';
 import 'node:fs';
-import './chunks/coverage.DVF1vEu8.js';
+import './chunks/coverage.D_JHT54q.js';
 import 'node:path';
+import 'node:os';
 import '@vitest/snapshot/manager';
-import 'vite-node/client';
-import 'vite-node/server';
-import './chunks/index.B521nVV-.js';
-import './chunks/index.VByaPkjc.js';
+import './chunks/index.Bgo3tNWt.js';
+import './chunks/index.BIP7prJq.js';
+import 'node:fs/promises';
+import './chunks/typechecker.DB-fIMaH.js';
 import 'node:perf_hooks';
 import '@vitest/utils/source-map';
+import 'tinyexec';
 import 'tinyrainbow';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
-import './chunks/typechecker.DRKU1-1g.js';
-import 'node:os';
-import 'tinyexec';
 import 'node:util';
-import 'node:fs/promises';
 import 'node:console';
 import 'node:stream';
 import 'node:module';
@@ -46,14 +43,18 @@ import 'zlib';
 import 'buffer';
 import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import 'node:crypto';
+import 'debug';
+import '#module-evaluator';
+import 'vite/module-runner';
 import 'node:url';
 import 'picomatch';
 import 'tinyglobby';
-import 'vite-node/utils';
-import '@vitest/mocker/node';
-import './chunks/defaults.B7q_naMc.js';
 import 'magic-string';
-import './chunks/index.BCWujgDG.js';
+import '@vitest/mocker/node';
+import './chunks/defaults.CXFFjsi8.js';
+import './chunks/resolver.Bx6lE0iq.js';
+import 'es-module-lexer';
+import './chunks/index.BjKEiSn0.js';
 import 'node:assert';
 import '@vitest/utils/error';
 import 'node:readline';
@@ -67,39 +68,22 @@ import 'readline';
 
 // this is only exported as a public function and not used inside vitest
 async function resolveConfig(options = {}, viteOverrides = {}) {
-	const root = slash(resolve(options.root || process.cwd()));
-	const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
+	const root = slash(resolve(options.root || process.cwd())), configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
 	options.config = configPath;
-	const vitest = new Vitest("test", deepClone(options));
-	const config = await resolveConfig$1(mergeConfig({
+	const vitest = new Vitest("test", deepClone(options)), config = await resolveConfig$1(mergeConfig({
 		configFile: configPath,
 		mode: options.mode || "test",
 		plugins: [await VitestPlugin(options, vitest)]
-	}, mergeConfig(viteOverrides, { root: options.root })), "serve");
-	// Reflect just to avoid type error
-	const updatedOptions = Reflect.get(config, "_vitest");
-	const vitestConfig = resolveConfig$2(vitest, updatedOptions, config);
-	await vitest.close();
-	return {
+	}, mergeConfig(viteOverrides, { root: options.root })), "serve"), updatedOptions = Reflect.get(config, "_vitest"), vitestConfig = resolveConfig$2(vitest, updatedOptions, config);
+	return await vitest.close(), {
 		viteConfig: config,
 		vitestConfig
 	};
 }
 
-function createDebugger(namespace) {
-	const debug = createDebug(namespace);
-	if (debug.enabled) return debug;
-}
-
 const version = Vitest.version;
-/** @deprecated use `createViteServer` instead */
-const createServer = vite.createServer;
 const createViteServer = vite.createServer;
-/**
-* @deprecated Use `TestModule` instead
-*/
-const TestFile = TestModule;
 // rolldownVersion is exported only by rolldown-vite
 const rolldownVersion = vite.rolldownVersion;
 
-export { TestFile, VitestPlugin, createDebugger, createServer, createViteServer, resolveConfig, rolldownVersion, version };
+export { VitestPlugin, createViteServer, resolveConfig, rolldownVersion, version };

package/dist/reporters.d.ts

@@ -1,25 +1,24 @@
-export { aQ as BaseReporter, aC as BasicReporter, aR as BenchmarkBuiltinReporters, aD as BenchmarkReporter, aE as BenchmarkReportsMap, aS as BuiltinReporterOptions, aT as BuiltinReporters, aF as DefaultReporter, aG as DotReporter, aH as GithubActionsReporter, aI as HangingProcessReporter, aK as JUnitReporter, aU as JsonAssertionResult, aJ as JsonReporter, aV as JsonTestResult, aW as JsonTestResults, aA as ReportedHookContext, o as Reporter, aL as ReportersMap, aM as TapFlatReporter, aN as TapReporter, aB as TestRunEndReason, aO as VerboseBenchmarkReporter, aP as VerboseReporter } from './chunks/reporters.d.BFLkQcL6.js';
+export { aJ as BaseReporter, aK as BenchmarkBuiltinReporters, aw as BenchmarkReporter, ax as BenchmarkReportsMap, aL as BuiltinReporterOptions, aM as BuiltinReporters, ay as DefaultReporter, az as DotReporter, aA as GithubActionsReporter, aB as HangingProcessReporter, aD as JUnitReporter, aN as JsonAssertionResult, aC as JsonReporter, aO as JsonTestResult, aP as JsonTestResults, at as ReportedHookContext, au as Reporter, aE as ReportersMap, aF as TapFlatReporter, aG as TapReporter, av as TestRunEndReason, aH as VerboseBenchmarkReporter, aI as VerboseReporter } from './chunks/reporters.d.BUWjmRYq.js';
 import '@vitest/runner';
-import './chunks/environment.d.cL3nLXbE.js';
-import 'vitest/optional-types.js';
 import '@vitest/utils';
+import './chunks/environment.d.BsToaxti.js';
 import 'node:stream';
 import 'vite';
-import 'node:console';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
-import './chunks/worker.d.1GmBbd7G.js';
-import 'vite-node';
-import './chunks/config.d.D2ROskhv.js';
+import './chunks/browser.d.yFAklsD1.js';
+import './chunks/worker.d.BDsXGkwh.js';
+import 'vite/module-runner';
+import './chunks/config.d.B_LthbQq.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
-import '@vitest/snapshot/environment';
 import '@vitest/utils/diff';
-import 'chai';
-import './chunks/benchmark.d.BwvBVTda.js';
+import '@vitest/expect';
+import 'vitest/optional-types.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';
 import 'tinybench';
-import './chunks/coverage.d.S9RMNXIe.js';
-import 'vite-node/client';
+import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
+import 'node:console';