vitest 3.0.9 → 3.1.0-beta.2

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.CqBhtcTq.d.ts → reporters.d.5g6jXhoW.d.ts}

@@ -639,6 +639,10 @@ declare abstract class BaseReporter implements Reporter {
 	error(...messages: any): void;
 	relative(path: string): string;
 	onFinished(files?: File[], errors?: unknown[]): void;
+	onTestCaseResult(testCase: TestCase): void;
+	onTestSuiteResult(testSuite: TestSuite): void;
+	onTestModuleEnd(testModule: TestModule): void;
+	private logFailedTask;
 	onTaskUpdate(packs: TaskResultPack[]): void;
 	/**
 	* Callback invoked with a single `Task` from `onTaskUpdate`
@@ -648,12 +652,12 @@ declare abstract class BaseReporter implements Reporter {
 	protected getTestName(test: Task, separator?: string): string;
 	protected formatShortError(error: ErrorWithDiff): string;
 	protected getTestIndentation(_test: Task): string;
-	private getDurationPrefix;
+	protected getDurationPrefix(task: Task): string;
 	onWatcherStart(files?: File[], errors?: unknown[]): void;
 	onWatcherRerun(files: string[], trigger?: string): void;
-	onUserConsoleLog(log: UserConsoleLog): void;
+	onUserConsoleLog(log: UserConsoleLog, taskState?: TestResult["state"]): void;
 	onTestRemoved(trigger?: string): void;
-	shouldLog(log: UserConsoleLog): boolean;
+	shouldLog(log: UserConsoleLog, taskState?: TestResult["state"]): boolean;
 	onServerRestart(reason?: string): void;
 	reportSummary(files: File[], errors: unknown[]): void;
 	reportTestSummary(files: File[], errors: unknown[]): void;
@@ -917,7 +921,7 @@ declare class DotReporter extends BaseReporter {
 	onTestModuleCollected(module: TestModule): void;
 	onTestCaseReady(test: TestCase): void;
 	onTestCaseResult(test: TestCase): void;
-	onTestModuleEnd(): void;
+	onTestModuleEnd(testModule: TestModule): void;
 	private createSummary;
 }
 
@@ -1726,9 +1730,11 @@ interface InlineConfig {
 	/**
 	* Silent mode
 	*
+	* Use `'passed-only'` to see logs from failing tests only.
+	*
 	* @default false
 	*/
-	silent?: boolean;
+	silent?: boolean | "passed-only";
 	/**
 	* Hide logs for skipped tests
 	*
@@ -2232,7 +2238,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.
@@ -2240,6 +2246,7 @@ type TestProjectConfiguration = string | (UserProjectConfigExport & {
 	*/
 	extends?: string | true
 });
+type TestProjectConfiguration = string | TestProjectInlineConfiguration | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
 /** @deprecated use `TestProjectConfiguration` instead */
 type WorkspaceProjectConfiguration = TestProjectConfiguration;
 
@@ -2630,7 +2637,7 @@ interface SerializedTestProject {
 	serializedConfig: SerializedConfig;
 	context: ProvidedContext;
 }
-interface InitializeProjectOptions extends UserWorkspaceConfig {
+interface InitializeProjectOptions extends TestProjectInlineConfiguration {
 	configFile: string | false;
 }
 
@@ -2819,6 +2826,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;
@@ -2999,8 +3012,12 @@ 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 { type JsonOptions$1 as $, type ApiConfig as A, type BaseCoverageOptions as B, CoverageMap as C, type DepsOptimizationOptions as D, type BenchmarkUserOptions as E, type VitestOptions as F, type TestSequencer as G, TestSpecification as H, type InlineConfig as I, TestModule as J, type OnTestsRerunHandler as K, Logger as L, type ModuleDiagnostic as M, VitestPackageInstaller as N, type OnServerRestartHandler as O, type Pool as P, type ProcessPool as Q, type ResolvedCoverageOptions as R, type SerializedTestSpecification as S, TestProject as T, type UserWorkspaceConfig as U, Vitest as V, type WorkspaceProjectConfiguration as W, type WorkspaceSpec as X, getFilePoolName as Y, type SerializedTestProject as Z, type HTMLOptions as _, type ReportContext as a, type JUnitOptions as a0, type TaskOptions as a1, TestCase as a2, TestCollection as a3, type TestDiagnostic as a4, type TestModuleState as a5, type TestResult as a6, type TestResultFailed as a7, type TestResultPassed as a8, type TestResultSkipped as a9, 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, type BenchmarkBuiltinReporters as aO, type BuiltinReporterOptions as aP, type BuiltinReporters as aQ, type JsonAssertionResult as aR, type JsonTestResult as aS, type JsonTestResults as aT, type TestState as aa, TestSuite as ab, type TestSuiteState as ac, type TestSequencerConstructor as ad, type BrowserBuiltinProvider as ae, type BrowserCommand as af, type BrowserCommandContext as ag, type BrowserInstanceOption as ah, type BrowserOrchestrator as ai, type BrowserProvider as aj, type BrowserProviderInitializationOptions as ak, type BrowserProviderModule as al, type BrowserProviderOptions as am, type BrowserServerState as an, type BrowserServerStateSession as ao, type CDPSession as ap, type ParentProjectBrowser as aq, type ProjectBrowser as ar, type ResolvedBrowserOptions as as, type ResolvedProjectConfig as at, type ResolveSnapshotPathHandler as au, type ResolveSnapshotPathHandlerContext as av, type TestRunResult as aw, type ReportedHookContext as ax, type TestRunEndReason as ay, BasicReporter as az, type TestProjectConfiguration as b, type CoverageV8Options as c, type UserProjectConfigFn as d, type UserProjectConfigExport as e, type TestProjectInlineConfiguration as f, type CoverageProvider as g, type CoverageProviderModule as h, type CoverageReporter as i, type CoverageProviderName as j, type CoverageOptions as k, type CoverageIstanbulOptions as l, type CustomProviderOptions as m, type Reporter as n, type BrowserScript as o, type BrowserConfigOptions as p, type BuiltinEnvironment as q, type VitestEnvironment as r, type PoolOptions as s, type CSSModuleScopeStrategy as t, type VitestRunMode as u, type TransformModePatterns as v, type TypecheckConfig as w, type UserConfig as x, type ResolvedConfig as y, type 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 };