vitest 3.1.0-beta.1 → 3.1.0

package/dist/chunks/inspector.DbDkSkFn.js

@@ -0,0 +1,54 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+const __require = createRequire(import.meta.url);
+let inspector;
+let 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;
+	if (isEnabled) {
+		inspector = __require("node:inspector");
+		const isOpen = inspector.url() !== undefined;
+		if (!isOpen) {
+			inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger);
+			if (config.inspectBrk) {
+				const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
+				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();
+		}
+	};
+}
+function closeInspector(config) {
+	const keepOpen = shouldKeepOpen(config);
+	if (inspector && !keepOpen) {
+		inspector.close();
+		session?.disconnect();
+	}
+}
+function shouldKeepOpen(config) {
+	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;
+	return config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);
+}
+
+export { closeInspector as c, setupInspect as s };

package/dist/chunks/node.IqGoMrm4.js

@@ -0,0 +1,15 @@
+import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
+import { g as getWorkerState } from './utils.CtocqOoE.js';
+import '@vitest/utils';
+
+class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
+	getHeader() {
+		return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
+	}
+	resolvePath(filepath) {
+		const rpc = getWorkerState().rpc;
+		return rpc.resolveSnapshotPath(filepath);
+	}
+}
+
+export { VitestNodeSnapshotEnvironment };

package/dist/chunks/{reporters.d.r7poTZjA.d.ts → reporters.d.CfRkRKN2.d.ts}

@@ -1,9 +1,10 @@
-import { Task, Suite, File, TaskMeta, TaskResultPack, SequenceSetupFiles, SequenceHooks, CancelReason } from '@vitest/runner';
+import { Task, TaskMeta, Suite, File, TaskResultPack, SequenceSetupFiles, SequenceHooks, CancelReason } from '@vitest/runner';
 import { b as Awaitable, U as UserConsoleLog, c as Arrayable$1, A as AfterSuiteRunMeta, f as EnvironmentOptions, P as ProvidedContext } from './environment.d.C8UItCbf.js';
 import { ParsedStack, TestError, SerializedError, ErrorWithDiff, Arrayable, Awaitable as Awaitable$1 } from '@vitest/utils';
 import { Writable } from 'node:stream';
 import { TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions, ViteDevServer, ModuleNode } from 'vite';
 import { Console } from 'node:console';
+import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.DevWltVl.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
@@ -93,6 +94,10 @@ declare class ReportedTaskImplementation {
 	* If the test is not finished yet or was skipped, it will return `true`.
 	*/
 	ok(): boolean;
+	/**
+	* Custom metadata that was attached to the test during its execution.
+	*/
+	meta(): TaskMeta;
 }
 declare class TestCase extends ReportedTaskImplementation {
 	#private;
@@ -126,10 +131,6 @@ declare class TestCase extends ReportedTaskImplementation {
 	*/
 	result(): TestResult;
 	/**
-	* Custom metadata that was attached to the test during its execution.
-	*/
-	meta(): TaskMeta;
-	/**
 	* Useful information about the test like duration, memory usage, etc.
 	* Diagnostic is only available after the test has finished.
 	*/
@@ -211,6 +212,10 @@ declare class TestSuite extends SuiteImplementation {
 	*/
 	ok: () => boolean;
 	/**
+	* The meta information attached to the suite during its collection or execution.
+	*/
+	meta: () => TaskMeta;
+	/**
 	* Checks the running state of the suite.
 	*/
 	state(): TestSuiteState;
@@ -238,6 +243,10 @@ declare class TestModule extends SuiteImplementation {
 	*/
 	ok: () => boolean;
 	/**
+	* The meta information attached to the module during its collection or execution.
+	*/
+	meta: () => TaskMeta;
+	/**
 	* Useful information about the module like duration, memory usage, etc.
 	* If the module was not executed yet, all diagnostic values will return `0`.
 	*/
@@ -357,6 +366,11 @@ interface ModuleDiagnostic {
 	* Accumulated duration of all tests and hooks in the module.
 	*/
 	readonly duration: number;
+	/**
+	* The amount of memory used by the test module in bytes.
+	* This value is only available if the test was executed with `logHeapUsage` flag.
+	*/
+	readonly heap: number | undefined;
 }
 
 type BuiltinPool = "browser" | "threads" | "forks" | "vmThreads" | "vmForks" | "typescript";
@@ -626,7 +640,7 @@ declare abstract class BaseReporter implements Reporter {
 	start: number;
 	end: number;
 	watchFilters?: string[];
-	failedUnwatchedFiles: Task[];
+	failedUnwatchedFiles: TestModule[];
 	isTTY: boolean;
 	ctx: Vitest;
 	renderSucceed: boolean;
@@ -643,12 +657,10 @@ declare abstract class BaseReporter implements Reporter {
 	onTestSuiteResult(testSuite: TestSuite): void;
 	onTestModuleEnd(testModule: TestModule): void;
 	private logFailedTask;
-	onTaskUpdate(packs: TaskResultPack[]): void;
-	/**
-	* Callback invoked with a single `Task` from `onTaskUpdate`
-	*/
-	protected printTask(task: Task): void;
-	protected printSuite(_task: Task): void;
+	protected printTestModule(testModule: TestModule): void;
+	protected printTestCase(moduleState: TestModuleState, test: TestCase): void;
+	private getModuleLog;
+	protected printTestSuite(_suite: TestSuite): void;
 	protected getTestName(test: Task, separator?: string): string;
 	protected formatShortError(error: ErrorWithDiff): string;
 	protected getTestIndentation(_test: Task): string;
@@ -915,7 +927,7 @@ declare class DotReporter extends BaseReporter {
 	private tests;
 	private finishedTests;
 	onInit(ctx: Vitest): void;
-	printTask(task: Task): void;
+	printTestModule(testModule: TestModule): void;
 	onWatcherRerun(files: string[], trigger?: string): void;
 	onFinished(files?: File[], errors?: unknown[]): void;
 	onTestModuleCollected(module: TestModule): void;
@@ -955,8 +967,9 @@ declare class TapFlatReporter extends TapReporter {
 declare class VerboseReporter extends DefaultReporter {
 	protected verbose: boolean;
 	renderSucceed: boolean;
-	printTask(task: Task): void;
-	protected printSuite(task: Task): void;
+	printTestModule(module: TestModule): void;
+	onTestCaseResult(test: TestCase): void;
+	protected printTestSuite(testSuite: TestSuite): void;
 	protected getTestName(test: Task): string;
 	protected getTestIndentation(test: Task): string;
 	protected formatShortError(): string;
@@ -980,7 +993,9 @@ declare class BenchmarkReporter extends DefaultReporter {
 	compare?: Parameters<typeof renderTable>[0]["compare"];
 	onInit(ctx: Vitest): Promise<void>;
 	onTaskUpdate(packs: TaskResultPack[]): void;
-	printTask(task: Task): void;
+	onTestSuiteResult(testSuite: TestSuite): void;
+	protected printTestModule(testModule: TestModule): void;
+	private printSuiteTable;
 	onFinished(files?: File[], errors?: unknown[]): Promise<void>;
 }
 
@@ -2238,7 +2253,7 @@ interface UserWorkspaceConfig extends UserConfig$1 {
 }
 type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
 type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
-type TestProjectConfiguration = string | (UserProjectConfigExport & {
+type TestProjectInlineConfiguration = (UserWorkspaceConfig & {
 	/**
 	* Relative path to the extendable config. All other options will be merged with this config.
 	* If `true`, the project will inherit all options from the root config.
@@ -2246,6 +2261,7 @@ type TestProjectConfiguration = string | (UserProjectConfigExport & {
 	*/
 	extends?: string | true
 });
+type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 /** @deprecated use `TestProjectConfiguration` instead */
 type WorkspaceProjectConfiguration = TestProjectConfiguration;
 
@@ -2259,8 +2275,14 @@ interface CDPSession {
 	once: (event: string, listener: (...args: unknown[]) => void) => void;
 	off: (event: string, listener: (...args: unknown[]) => void) => void;
 }
+interface BrowserModuleMocker {
+	register: (sessionId: string, module: MockedModule) => Promise<void>;
+	delete: (sessionId: string, url: string) => Promise<void>;
+	clear: (sessionId: string) => Promise<void>;
+}
 interface BrowserProvider {
 	name: string;
+	mocker?: BrowserModuleMocker;
 	/**
 	* @experimental opt-in into file parallelisation
 	*/
@@ -2610,7 +2632,6 @@ declare class TestProject {
 	private isInSourceTestCode;
 	private filterFiles;
 	private _parentBrowser?;
-	private _parent?;
 	/**
 	* Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
 	* If the resources are needed again, create a new project.
@@ -2636,7 +2657,7 @@ interface SerializedTestProject {
 	serializedConfig: SerializedConfig;
 	context: ProvidedContext;
 }
-interface InitializeProjectOptions extends UserWorkspaceConfig {
+interface InitializeProjectOptions extends TestProjectInlineConfiguration {
 	configFile: string | false;
 }
 
@@ -2825,6 +2846,12 @@ declare class Vitest {
 	/** @deprecated internal */
 	setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
 	/**
+	* Inject new test projects into the workspace.
+	* @param config Glob, config path or a custom config options.
+	* @returns An array of new test projects. Can be empty if the name was filtered out.
+	*/
+	private injectTestProject;
+	/**
 	* Provide a value to the test context. This value will be available to all tests with `inject`.
 	*/
 	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
@@ -3005,8 +3032,13 @@ declare class Vitest {
 	* vitest.onFilterWatchedSpecification(specification => testsToRun.includes(specification.moduleId))
 	*/
 	onFilterWatchedSpecification(fn: (specification: TestSpecification) => boolean): void;
+	/**
+	* Check if the project with a given name should be included.
+	*/
+	matchesProjectFilter(name: string): boolean;
 }
 type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
 type OnTestsRerunHandler = (testFiles: TestSpecification[]) => Promise<void> | void;
 
-export { type JUnitOptions as $, type ApiConfig as A, type BaseCoverageOptions as B, CoverageMap as C, type DepsOptimizationOptions as D, TestProject as E, type TestSequencer as F, TestSpecification as G, TestModule as H, type InlineConfig as I, type OnTestsRerunHandler as J, VitestPackageInstaller as K, Logger as L, type ModuleDiagnostic as M, type ProcessPool as N, type OnServerRestartHandler as O, type Pool as P, type WorkspaceSpec as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, type TestProjectConfiguration as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, getFilePoolName as X, type SerializedTestProject as Y, type HTMLOptions as Z, type JsonOptions$1 as _, type ReportContext as a, type TaskOptions as a0, TestCase as a1, TestCollection as a2, type TestDiagnostic as a3, type TestModuleState as a4, type TestResult as a5, type TestResultFailed as a6, type TestResultPassed as a7, type TestResultSkipped as a8, type TestState as a9, BenchmarkReportsMap as aA, DefaultReporter as aB, DotReporter as aC, GithubActionsReporter as aD, HangingProcessReporter as aE, JsonReporter as aF, JUnitReporter as aG, ReportersMap as aH, TapFlatReporter as aI, TapReporter as aJ, VerboseBenchmarkReporter as aK, VerboseReporter as aL, BaseReporter as aM, type BenchmarkBuiltinReporters as aN, type BuiltinReporterOptions as aO, type BuiltinReporters as aP, type JsonAssertionResult as aQ, type JsonTestResult as aR, type JsonTestResults as aS, TestSuite as aa, type TestSuiteState as ab, type TestSequencerConstructor as ac, type BrowserBuiltinProvider as ad, type BrowserCommand as ae, type BrowserCommandContext as af, type BrowserInstanceOption as ag, type BrowserOrchestrator as ah, type BrowserProvider as ai, type BrowserProviderInitializationOptions as aj, type BrowserProviderModule as ak, type BrowserProviderOptions as al, type BrowserServerState as am, type BrowserServerStateSession as an, type CDPSession as ao, type ParentProjectBrowser as ap, type ProjectBrowser as aq, type ResolvedBrowserOptions as ar, type ResolvedProjectConfig as as, type ResolveSnapshotPathHandler as at, type ResolveSnapshotPathHandlerContext as au, type TestRunResult as av, type ReportedHookContext as aw, type TestRunEndReason as ax, BasicReporter as ay, BenchmarkReporter as az, type CoverageV8Options as b, type UserProjectConfigFn as c, type UserProjectConfigExport as d, type CoverageProvider as e, type CoverageProviderModule as f, type CoverageReporter as g, type CoverageProviderName as h, type CoverageOptions as i, type CoverageIstanbulOptions as j, type CustomProviderOptions as k, type Reporter as l, type BrowserScript as m, type BrowserConfigOptions as n, type BuiltinEnvironment as o, type VitestEnvironment as p, type PoolOptions as q, type CSSModuleScopeStrategy as r, type VitestRunMode as s, type TransformModePatterns as t, type TypecheckConfig as u, type UserConfig as v, type ResolvedConfig as w, type ProjectConfig as x, type BenchmarkUserOptions as y, type VitestOptions as z };
+export { CoverageMap as C, TestSpecification as H, TestModule as J, Logger as L, VitestPackageInstaller as N, TestProject as T, Vitest as V, getFilePoolName as Y, TestCase as a2, TestCollection as a3, BasicReporter as aA, 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, TestSuite as ab };
+export type { JsonOptions$1 as $, ApiConfig as A, BaseCoverageOptions as B, DepsOptimizationOptions as D, BenchmarkUserOptions as E, VitestOptions as F, TestSequencer as G, InlineConfig as I, OnTestsRerunHandler as K, ModuleDiagnostic as M, OnServerRestartHandler as O, Pool as P, ProcessPool as Q, ResolvedCoverageOptions as R, SerializedTestSpecification as S, UserWorkspaceConfig as U, WorkspaceProjectConfiguration as W, WorkspaceSpec as X, SerializedTestProject as Z, HTMLOptions as _, ReportContext as a, JUnitOptions as a0, TaskOptions as a1, TestDiagnostic as a4, TestModuleState as a5, TestResult as a6, TestResultFailed as a7, TestResultPassed as a8, TestResultSkipped as a9, BenchmarkBuiltinReporters as aP, BuiltinReporterOptions as aQ, BuiltinReporters as aR, JsonAssertionResult as aS, JsonTestResult as aT, JsonTestResults as aU, TestState as aa, TestSuiteState as ac, TestSequencerConstructor as ad, BrowserBuiltinProvider as ae, BrowserCommand as af, BrowserCommandContext as ag, BrowserInstanceOption as ah, BrowserModuleMocker as ai, BrowserOrchestrator as aj, BrowserProvider as ak, BrowserProviderInitializationOptions as al, BrowserProviderModule as am, BrowserProviderOptions as an, BrowserServerState as ao, BrowserServerStateSession as ap, CDPSession as aq, ParentProjectBrowser as ar, ProjectBrowser as as, ResolvedBrowserOptions as at, ResolvedProjectConfig as au, ResolveSnapshotPathHandler as av, ResolveSnapshotPathHandlerContext as aw, TestRunResult as ax, ReportedHookContext as ay, TestRunEndReason as az, TestProjectConfiguration as b, CoverageV8Options as c, UserProjectConfigFn as d, UserProjectConfigExport as e, TestProjectInlineConfiguration as f, CoverageProvider as g, CoverageProviderModule as h, CoverageReporter as i, CoverageProviderName as j, CoverageOptions as k, CoverageIstanbulOptions as l, CustomProviderOptions as m, Reporter as n, BrowserScript as o, BrowserConfigOptions as p, BuiltinEnvironment as q, VitestEnvironment as r, PoolOptions as s, CSSModuleScopeStrategy as t, VitestRunMode as u, TransformModePatterns as v, TypecheckConfig as w, UserConfig as x, ResolvedConfig as y, ProjectConfig as z };

package/dist/chunks/rpc.DGgL5dw7.js

@@ -0,0 +1,92 @@
+import { getSafeTimers } from '@vitest/utils';
+import { c as createBirpc } from './index.68735LiX.js';
+import { g as getWorkerState } from './utils.CtocqOoE.js';
+
+const { get } = Reflect;
+function withSafeTimers(fn) {
+	const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
+	const currentSetTimeout = globalThis.setTimeout;
+	const currentClearTimeout = globalThis.clearTimeout;
+	const currentSetImmediate = globalThis.setImmediate;
+	const currentClearImmediate = globalThis.clearImmediate;
+	const currentNextTick = globalThis.process?.nextTick;
+	try {
+		globalThis.setTimeout = setTimeout;
+		globalThis.clearTimeout = clearTimeout;
+		globalThis.setImmediate = setImmediate;
+		globalThis.clearImmediate = clearImmediate;
+		if (globalThis.process) {
+			globalThis.process.nextTick = nextTick;
+		}
+		const result = fn();
+		return result;
+	} finally {
+		globalThis.setTimeout = currentSetTimeout;
+		globalThis.clearTimeout = currentClearTimeout;
+		globalThis.setImmediate = currentSetImmediate;
+		globalThis.clearImmediate = currentClearImmediate;
+		if (globalThis.process) {
+			nextTick(() => {
+				globalThis.process.nextTick = currentNextTick;
+			});
+		}
+	}
+}
+const promises = new Set();
+async function rpcDone() {
+	if (!promises.size) {
+		return;
+	}
+	const awaitable = Array.from(promises);
+	return Promise.all(awaitable);
+}
+function createRuntimeRpc(options) {
+	let setCancel = (_reason) => {};
+	const onCancel = new Promise((resolve) => {
+		setCancel = resolve;
+	});
+	const rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
+		eventNames: [
+			"onUserConsoleLog",
+			"onCollected",
+			"onCancel"
+		],
+		onTimeoutError(functionName, args) {
+			let message = `[vitest-worker]: Timeout calling "${functionName}"`;
+			if (functionName === "fetch" || functionName === "transform" || functionName === "resolveId") {
+				message += ` with "${JSON.stringify(args)}"`;
+			}
+			if (functionName === "onUnhandledError") {
+				message += ` with "${args[0]?.message || args[0]}"`;
+			}
+			throw new Error(message);
+		},
+		...options
+	}));
+	return {
+		rpc,
+		onCancel
+	};
+}
+function createSafeRpc(rpc) {
+	return new Proxy(rpc, { get(target, p, handler) {
+		const sendCall = get(target, p, handler);
+		const safeSendCall = (...args) => withSafeTimers(async () => {
+			const result = sendCall(...args);
+			promises.add(result);
+			try {
+				return await result;
+			} finally {
+				promises.delete(result);
+			}
+		});
+		safeSendCall.asEvent = sendCall.asEvent;
+		return safeSendCall;
+	} });
+}
+function rpc() {
+	const { rpc } = getWorkerState();
+	return rpc;
+}
+
+export { rpcDone as a, createRuntimeRpc as c, rpc as r };

package/dist/chunks/run-once.I7PpBOk1.js

@@ -0,0 +1,47 @@
+import { g as getWorkerState } from './utils.CtocqOoE.js';
+
+const filesCount = new Map();
+const cache = new Map();
+/**
+* This utils allows computational intensive tasks to only be ran once
+* across test reruns to improve the watch mode performance.
+*
+* Currently only works with `poolOptions.<pool>.isolate: false`
+*
+* @experimental
+*/
+function runOnce(fn, key) {
+	const filepath = getWorkerState().filepath || "__unknown_files__";
+	if (!key) {
+		filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
+		key = String(filesCount.get(filepath));
+	}
+	const id = `${filepath}:${key}`;
+	if (!cache.has(id)) {
+		cache.set(id, fn());
+	}
+	return cache.get(id);
+}
+/**
+* Get a boolean indicates whether the task is running in the first time.
+* Could only be `false` in watch mode.
+*
+* Currently only works with `isolate: false`
+*
+* @experimental
+*/
+function isFirstRun() {
+	let firstRun = false;
+	runOnce(() => {
+		firstRun = true;
+	}, "__vitest_first_run__");
+	return firstRun;
+}
+/**
+* @internal
+*/
+function resetRunOnceCounter() {
+	filesCount.clear();
+}
+
+export { runOnce as a, isFirstRun as i, resetRunOnceCounter as r };

package/dist/chunks/runBaseTests.CqmKSG99.js

@@ -0,0 +1,134 @@
+import { performance } from 'node:perf_hooks';
+import { startTests, collectTests } from '@vitest/runner';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.VfYQ6MXY.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.DEGDGBiA.js';
+import { a as globalExpect, v as vi } from './vi.B-PuvDzu.js';
+import { c as closeInspector } from './inspector.DbDkSkFn.js';
+import { createRequire } from 'node:module';
+import timers from 'node:timers';
+import timersPromises from 'node:timers/promises';
+import util from 'node:util';
+import { getSafeTimers } from '@vitest/utils';
+import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { V as VitestIndex } from './index.BDobFbcz.js';
+import { g as getWorkerState, r as resetModules } from './utils.CtocqOoE.js';
+import 'chai';
+import 'node:path';
+import '../path.js';
+import 'node:url';
+import './rpc.DGgL5dw7.js';
+import './index.68735LiX.js';
+import './coverage.0iPg4Wrz.js';
+import '@vitest/snapshot';
+import './run-once.I7PpBOk1.js';
+import '@vitest/expect';
+import '@vitest/runner/utils';
+import './_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/utils/error';
+import '@vitest/spy';
+import '@vitest/utils/source-map';
+import './date.CDOsz-HY.js';
+import './benchmark.BKUatJGy.js';
+import 'expect-type';
+
+let globalSetup = false;
+async function setupGlobalEnv(config, { environment }, executor) {
+	await setupCommonEnv(config);
+	Object.defineProperty(globalThis, "__vitest_index__", {
+		value: VitestIndex,
+		enumerable: false
+	});
+	const state = getWorkerState();
+	if (!state.config.snapshotOptions.snapshotEnvironment) {
+		state.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, executor);
+	}
+	if (globalSetup) {
+		return;
+	}
+	globalSetup = true;
+	if (environment.transformMode === "web") {
+		const _require = createRequire(import.meta.url);
+		_require.extensions[".css"] = resolveCss;
+		_require.extensions[".scss"] = resolveCss;
+		_require.extensions[".sass"] = resolveCss;
+		_require.extensions[".less"] = resolveCss;
+		KNOWN_ASSET_TYPES.forEach((type) => {
+			_require.extensions[`.${type}`] = resolveAsset;
+		});
+		process.env.SSR = "";
+	} else {
+		process.env.SSR = "1";
+	}
+	globalThis.__vitest_required__ = {
+		util,
+		timers,
+		timersPromises
+	};
+	installSourcemapsSupport({ getSourceMap: (source) => state.moduleCache.getSourceMap(source) });
+	if (!config.disableConsoleIntercept) {
+		await setupConsoleLogSpy();
+	}
+}
+function resolveCss(mod) {
+	mod.exports = "";
+}
+function resolveAsset(mod, url) {
+	mod.exports = url;
+}
+async function setupConsoleLogSpy() {
+	const { createCustomConsole } = await import('./console.D6t261w0.js');
+	globalThis.console = createCustomConsole();
+}
+async function withEnv({ environment }, options, fn) {
+	globalThis.__vitest_environment__ = environment.name;
+	globalExpect.setState({ environment: environment.name });
+	const env = await environment.setup(globalThis, options);
+	try {
+		await fn();
+	} finally {
+		const { setTimeout } = getSafeTimers();
+		await new Promise((resolve) => setTimeout(resolve));
+		await env.teardown(globalThis);
+	}
+}
+
+async function run(method, files, config, environment, executor) {
+	const workerState = getWorkerState();
+	const isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true);
+	const isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true);
+	const isolate = isIsolatedThreads || isIsolatedForks;
+	await setupGlobalEnv(config, environment, executor);
+	await startCoverageInsideWorker(config.coverage, executor, { isolate });
+	if (config.chaiConfig) {
+		setupChaiConfig(config.chaiConfig);
+	}
+	const runner = await resolveTestRunner(config, executor);
+	workerState.onCancel.then((reason) => {
+		closeInspector(config);
+		runner.onCancel?.(reason);
+	});
+	workerState.durations.prepare = performance.now() - workerState.durations.prepare;
+	workerState.durations.environment = performance.now();
+	await withEnv(environment, environment.options || config.environmentOptions || {}, async () => {
+		workerState.durations.environment = performance.now() - workerState.durations.environment;
+		for (const file of files) {
+			if (isolate) {
+				executor.mocker.reset();
+				resetModules(workerState.moduleCache, true);
+			}
+			workerState.filepath = file.filepath;
+			if (method === "run") {
+				await startTests([file], runner);
+			} else {
+				await collectTests([file], runner);
+			}
+			vi.resetConfig();
+			vi.restoreAllMocks();
+		}
+		await stopCoverageInsideWorker(config.coverage, executor, { isolate });
+	});
+	workerState.environmentTeardownRun = true;
+}
+
+export { run };

package/dist/chunks/setup-common.DEGDGBiA.js

@@ -0,0 +1,88 @@
+import { r as resolveCoverageProviderModule } from './coverage.0iPg4Wrz.js';
+import { addSerializer } from '@vitest/snapshot';
+import { setSafeTimers } from '@vitest/utils';
+import { r as resetRunOnceCounter } from './run-once.I7PpBOk1.js';
+
+async function startCoverageInsideWorker(options, loader, runtimeOptions) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) {
+		return coverageModule.startCoverage?.(runtimeOptions);
+	}
+	return null;
+}
+async function takeCoverageInsideWorker(options, loader) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) {
+		return coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo });
+	}
+	return null;
+}
+async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) {
+		return coverageModule.stopCoverage?.(runtimeOptions);
+	}
+	return null;
+}
+
+let globalSetup = false;
+async function setupCommonEnv(config) {
+	resetRunOnceCounter();
+	setupDefines(config.defines);
+	setupEnv(config.env);
+	if (globalSetup) {
+		return;
+	}
+	globalSetup = true;
+	setSafeTimers();
+	if (config.globals) {
+		(await import('./globals.DCbUWjip.js')).registerApiGlobally();
+	}
+}
+function setupDefines(defines) {
+	for (const key in defines) {
+		globalThis[key] = defines[key];
+	}
+}
+function setupEnv(env) {
+	if (typeof process === "undefined") {
+		return;
+	}
+	const { PROD, DEV,...restEnvs } = env;
+	process.env.PROD = PROD ? "1" : "";
+	process.env.DEV = DEV ? "1" : "";
+	for (const key in restEnvs) {
+		process.env[key] = env[key];
+	}
+}
+async function loadDiffConfig(config, executor) {
+	if (typeof config.diff === "object") {
+		return config.diff;
+	}
+	if (typeof config.diff !== "string") {
+		return;
+	}
+	const diffModule = await executor.executeId(config.diff);
+	if (diffModule && typeof diffModule.default === "object" && diffModule.default != null) {
+		return diffModule.default;
+	} else {
+		throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
+	}
+}
+async function loadSnapshotSerializers(config, executor) {
+	const files = config.snapshotSerializers;
+	const snapshotSerializers = await Promise.all(files.map(async (file) => {
+		const mo = await executor.executeId(file);
+		if (!mo || typeof mo.default !== "object" || mo.default === null) {
+			throw new Error(`invalid snapshot serializer file ${file}. Must export a default object`);
+		}
+		const config = mo.default;
+		if (typeof config.test !== "function" || typeof config.serialize !== "function" && typeof config.print !== "function") {
+			throw new TypeError(`invalid snapshot serializer in ${file}. Must have a 'test' method along with either a 'serialize' or 'print' method.`);
+		}
+		return config;
+	}));
+	snapshotSerializers.forEach((serializer) => addSerializer(serializer));
+}
+
+export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };