vitest 4.0.10 → 4.0.11

package/dist/chunks/{coverage.BUlIqJrL.js → coverage.CtyeYmKM.js}

@@ -7,10 +7,10 @@ import { glob } from 'tinyglobby';
 import c from 'tinyrainbow';
 import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.BOqNVLsY.js';
 import crypto from 'node:crypto';
+import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
 import { builtinModules, createRequire } from 'node:module';
 import process$1 from 'node:process';
 import fs$1 from 'node:fs/promises';
-import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
 import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
@@ -2792,6 +2792,12 @@ function resolveConfig$1(vitest, options, viteConfig) {
 	}
 	resolved.testTimeout ??= resolved.browser.enabled ? 3e4 : 5e3;
 	resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4;
+	resolved.experimental ??= {};
+	if (resolved.experimental.openTelemetry?.sdkPath) {
+		const sdkPath = resolve(resolved.root, resolved.experimental.openTelemetry.sdkPath);
+		resolved.experimental.openTelemetry.sdkPath = pathToFileURL$1(sdkPath).toString();
+	}
+	if (resolved.experimental.fsModuleCachePath) resolved.experimental.fsModuleCachePath = resolve(resolved.root, resolved.experimental.fsModuleCachePath);
 	return resolved;
 }
 function isBrowserEnabled(config) {

package/dist/chunks/{creator.DU9qFjsW.js → creator.DAmOKTvJ.js}

@@ -470,8 +470,8 @@ function getPossibleProvider(dependencies) {
 }
 function getProviderDocsLink(provider) {
 	switch (provider) {
-		case "playwright": return "https://vitest.dev/guide/browser/playwright";
-		case "webdriverio": return "https://vitest.dev/guide/browser/webdriverio";
+		case "playwright": return "https://vitest.dev/config/browser/playwright";
+		case "webdriverio": return "https://vitest.dev/config/browser/webdriverio";
 	}
 }
 function sort(choices, value) {
@@ -514,7 +514,7 @@ async function generateFrameworkConfigFile(options) {
 		`      provider: ${options.provider}(),`,
 		options.provider !== "preview" && `      // ${getProviderDocsLink(options.provider)}`,
 		`      instances: [`,
-		...options.browsers.map((browser) => `      { browser: '${browser}' },`),
+		...options.browsers.map((browser) => `        { browser: '${browser}' },`),
 		`      ],`,
 		`    },`,
 		`  },`,

package/dist/chunks/{global.d.BQDgW9Pr.d.ts → global.d.uY4Q0M5z.d.ts}

@@ -2,7 +2,7 @@ import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
 import { Plugin } from '@vitest/pretty-format';
 import { SnapshotState } from '@vitest/snapshot';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
-import { U as UserConsoleLog } from './worker.d.ZGohxCEd.js';
+import { U as UserConsoleLog } from './worker.d.B_PZTrCQ.js';
 
 interface SnapshotMatcher<T> {
 	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;

package/dist/chunks/{globals.NLOzC_A5.js → globals.C0izxiX3.js}

@@ -1,5 +1,5 @@
 import { g as globalApis } from './constants.D_Q9UYh-.js';
-import { i as index } from './index.DZ-mI_Nm.js';
+import { i as index } from './index.DBx1AtPJ.js';
 import './vi.BiaV1qII.js';
 import '@vitest/expect';
 import '@vitest/runner';

package/dist/chunks/{index.B8lJfb0J.js → index.CMvpbrsJ.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.BYek7GgP.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.DWDW6mLz.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils/helpers';
 

package/dist/chunks/{index.Dua7TZg_.js → index.CQwQ_SLL.js}

@@ -1,8 +1,8 @@
 import { chai } from '@vitest/expect';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.BOzbXE3x.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.DGHc_BUK.js';
 import { r as rpc } from './rpc.BytlcPfC.js';
 import { g as getWorkerState } from './utils.DvEY5TfP.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.BPErLMrw.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.DqQZzsWf.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
@@ -24,7 +24,7 @@ async function getTestRunnerConstructor(config, moduleRunner) {
 	if (!mod.default && typeof mod.default !== "function") throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
 	return mod.default;
 }
-async function resolveTestRunner(config, moduleRunner) {
+async function resolveTestRunner(config, moduleRunner, traces) {
 	const testRunner = new (await (getTestRunnerConstructor(config, moduleRunner)))(config);
 	// inject private executor to every runner
 	Object.defineProperty(testRunner, "moduleRunner", {
@@ -34,6 +34,7 @@ async function resolveTestRunner(config, moduleRunner) {
 	});
 	if (!testRunner.config) testRunner.config = config;
 	if (!testRunner.importFile) throw new Error("Runner must implement \"importFile\" method.");
+	if ("__setTraces" in testRunner) testRunner.__setTraces(traces);
 	const [diffOptions] = await Promise.all([loadDiffConfig(config, moduleRunner), loadSnapshotSerializers(config, moduleRunner)]);
 	testRunner.config.diffOptions = diffOptions;
 	// patch some methods, so custom runners don't need to call RPC
@@ -46,9 +47,20 @@ async function resolveTestRunner(config, moduleRunner) {
 	// patch some methods, so custom runners don't need to call RPC
 	const originalOnTestAnnotate = testRunner.onTestAnnotate;
 	testRunner.onTestAnnotate = async (test, annotation) => {
-		const p = rpc().onTaskAnnotate(test.id, annotation);
+		const p = rpc().onTaskArtifactRecord(test.id, {
+			type: "internal:annotation",
+			location: annotation.location,
+			annotation
+		});
 		const overriddenResult = await originalOnTestAnnotate?.call(testRunner, test, annotation);
 		const vitestResult = await p;
+		return overriddenResult || vitestResult.annotation;
+	};
+	const originalOnTestArtifactRecord = testRunner.onTestArtifactRecord;
+	testRunner.onTestArtifactRecord = async (test, artifact) => {
+		const p = rpc().onTaskArtifactRecord(test.id, artifact);
+		const overriddenResult = await originalOnTestArtifactRecord?.call(testRunner, test, artifact);
+		const vitestResult = await p;
 		return overriddenResult || vitestResult;
 	};
 	const originalOnCollectStart = testRunner.onCollectStart;

package/dist/chunks/{index.DZ-mI_Nm.js → index.DBx1AtPJ.js}

@@ -2,7 +2,7 @@ import { b as assert, c as createExpect, g as globalExpect, i as inject, s as sh
 import { b as bench } from './benchmark.B3N2zMcH.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { expectTypeOf } from 'expect-type';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
 import { chai } from '@vitest/expect';
 
 const assertType = function assertType() {};
@@ -26,6 +26,7 @@ var index = /*#__PURE__*/Object.freeze({
   it: it,
   onTestFailed: onTestFailed,
   onTestFinished: onTestFinished,
+  recordArtifact: recordArtifact,
   should: should,
   suite: suite,
   test: test,

package/dist/chunks/{index.BYek7GgP.js → index.DWDW6mLz.js}

@@ -327,6 +327,13 @@ function convertTasksToEvents(file, onTask) {
 							{ annotation }
 						]);
 					});
+					task.artifacts.forEach((artifact) => {
+						events.push([
+							task.id,
+							"test-artifact",
+							{ artifact }
+						]);
+					});
 					events.push([
 						task.id,
 						"test-finished",
@@ -2456,6 +2463,7 @@ async function collectTests(ctx, filepath) {
 			end: definition.end,
 			start: definition.start,
 			annotations: [],
+			artifacts: [],
 			meta: { typecheck: true }
 		};
 		definition.task = task;
@@ -3499,7 +3507,8 @@ class JUnitReporter {
 					context: null,
 					suite: null,
 					file: null,
-					annotations: []
+					annotations: [],
+					artifacts: []
 				});
 			}
 			return {

package/dist/chunks/{init-forks.BZSlxfwV.js → init-forks.DIuGPyId.js}

@@ -1,4 +1,4 @@
-import { i as init } from './init.Cz2kTB9a.js';
+import { i as init } from './init.B3IeC_yW.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them
@@ -16,13 +16,13 @@ function workerInit(options) {
 		on: (cb) => processOn("message", cb),
 		off: (cb) => processOff("message", cb),
 		teardown: () => processRemoveAllListeners("message"),
-		runTests: (state) => executeTests("run", state),
-		collectTests: (state) => executeTests("collect", state),
+		runTests: (state, traces) => executeTests("run", state, traces),
+		collectTests: (state, traces) => executeTests("collect", state, traces),
 		setup: options.setup
 	});
-	async function executeTests(method, state) {
+	async function executeTests(method, state, traces) {
 		try {
-			await runTests(method, state);
+			await runTests(method, state, traces);
 		} finally {
 			process.exit = processExit;
 		}

package/dist/chunks/{init-threads.CwE2n-Bv.js → init-threads.jC_8JdoN.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.Cz2kTB9a.js';
+import { i as init } from './init.B3IeC_yW.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {
@@ -9,8 +9,8 @@ function workerInit(options) {
 		on: (callback) => parentPort.on("message", callback),
 		off: (callback) => parentPort.off("message", callback),
 		teardown: () => parentPort.removeAllListeners("message"),
-		runTests: async (state) => runTests("run", state),
-		collectTests: async (state) => runTests("collect", state),
+		runTests: async (state, traces) => runTests("run", state, traces),
+		collectTests: async (state, traces) => runTests("collect", state, traces),
 		setup: options.setup
 	});
 }

package/dist/chunks/{init.Cz2kTB9a.js → init.B3IeC_yW.js}

@@ -3,9 +3,10 @@ import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
 import { ModuleRunner } from 'vite/module-runner';
-import { b as VitestTransport } from './startModuleRunner.DLjmA_wU.js';
+import { b as VitestTransport } from './startModuleRunner.DaBMy1JT.js';
 import { e as environments } from './index.QWbK7rHY.js';
 import { serializeError } from '@vitest/utils/error';
+import { T as Traces } from './traces.BVPrsYso.js';
 import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BytlcPfC.js';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { s as setupInspect } from './inspector.CvyFGlXm.js';
@@ -16,7 +17,7 @@ function isBuiltinEnvironment(env) {
 }
 const isWindows = process.platform === "win32";
 const _loaders = /* @__PURE__ */ new Map();
-async function createEnvironmentLoader(root, rpc) {
+function createEnvironmentLoader(root, rpc) {
 	const cachedLoader = _loaders.get(root);
 	if (!cachedLoader || cachedLoader.isClosed()) {
 		_loaders.delete(root);
@@ -42,15 +43,14 @@ async function createEnvironmentLoader(root, rpc) {
 			})
 		});
 		_loaders.set(root, moduleRunner);
-		await moduleRunner.import("/@vite/env");
 	}
 	return _loaders.get(root);
 }
-async function loadEnvironment(name, root, rpc) {
+async function loadEnvironment(name, root, rpc, traces) {
 	if (isBuiltinEnvironment(name)) return { environment: environments[name] };
-	const loader = await createEnvironmentLoader(root, rpc);
-	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__"))?.id ?? resolve(root, name);
-	const pkg = await loader.import(packageId);
+	const loader = createEnvironmentLoader(root, rpc);
+	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await traces.$("vitest.runtime.environment.resolve", () => rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__")))?.id ?? resolve(root, name);
+	const pkg = await traces.$("vitest.runtime.environment.import", () => loader.import(packageId));
 	if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
 	const environment = pkg.default;
 	if (environment.transformMode != null && environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web", received "${environment.transformMode}".`);
@@ -67,7 +67,7 @@ async function loadEnvironment(name, root, rpc) {
 
 const resolvingModules = /* @__PURE__ */ new Set();
 const globalListeners = /* @__PURE__ */ new Set();
-async function execute(method, ctx, worker) {
+async function execute(method, ctx, worker, traces) {
 	const prepareStart = performance.now();
 	const cleanups = [setupInspect(ctx)];
 	// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
@@ -101,17 +101,17 @@ async function execute(method, ctx, worker) {
 		};
 		const methodName = method === "collect" ? "collectTests" : "runTests";
 		if (!worker[methodName] || typeof worker[methodName] !== "function") throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
-		await worker[methodName](state);
+		await worker[methodName](state, traces);
 	} finally {
 		await rpcDone().catch(() => {});
 		await Promise.all(cleanups.map((fn) => fn())).catch(() => {});
 	}
 }
-function run(ctx, worker) {
-	return execute("run", ctx, worker);
+function run(ctx, worker, traces) {
+	return execute("run", ctx, worker, traces);
 }
-function collect(ctx, worker) {
-	return execute("collect", ctx, worker);
+function collect(ctx, worker, traces) {
+	return execute("collect", ctx, worker, traces);
 }
 async function teardown() {
 	await Promise.all([...globalListeners].map((l) => l()));
@@ -142,6 +142,7 @@ function createImportMetaEnvProxy() {
 const __vitest_worker_response__ = true;
 const memoryUsage = process.memoryUsage.bind(process);
 let reportMemory = false;
+let traces;
 /** @experimental */
 function init(worker) {
 	worker.on(onMessage);
@@ -158,16 +159,26 @@ function init(worker) {
 		switch (message.type) {
 			case "start": {
 				reportMemory = message.options.reportMemory;
+				const tracesStart = performance.now();
+				traces ??= await new Traces({
+					enabled: message.traces.enabled,
+					sdkPath: message.traces.sdkPath
+				}).waitInit();
+				const tracesEnd = performance.now();
 				const { environment, config, pool } = message.context;
+				const context = traces.getContextFromCarrier(message.traces.otelCarrier);
+				// record telemetry as part of "start"
+				traces.startSpan("vitest.runtime.traces", { startTime: tracesStart }, context).end(tracesEnd);
 				try {
 					setupContext = {
 						environment,
 						config,
 						pool,
 						rpc: createRuntimeRpc(worker),
-						projectName: config.name || ""
+						projectName: config.name || "",
+						traces
 					};
-					workerTeardown = await worker.setup?.(setupContext);
+					workerTeardown = await traces.$("vitest.runtime.setup", { context }, () => worker.setup?.(setupContext));
 					send({
 						type: "started",
 						__vitest_worker_response__
@@ -204,10 +215,17 @@ function init(worker) {
 				}
 				isRunning = true;
 				try {
-					runPromise = run({
+					const tracesContext = traces.getContextFromCarrier(message.otelCarrier);
+					runPromise = traces.$("vitest.runtime.run", {
+						context: tracesContext,
+						attributes: {
+							"vitest.worker.specifications": traces.isEnabled() ? getFilesWithLocations(message.context.files) : [],
+							"vitest.worker.id": message.context.workerId
+						}
+					}, () => run({
 						...setupContext,
 						...message.context
-					}, worker).catch((error) => serializeError(error));
+					}, worker, traces).catch((error) => serializeError(error)));
 					send({
 						type: "testfileFinished",
 						__vitest_worker_response__,
@@ -242,10 +260,17 @@ function init(worker) {
 				}
 				isRunning = true;
 				try {
-					runPromise = collect({
+					const tracesContext = traces.getContextFromCarrier(message.otelCarrier);
+					runPromise = traces.$("vitest.runtime.collect", {
+						context: tracesContext,
+						attributes: {
+							"vitest.worker.specifications": traces.isEnabled() ? getFilesWithLocations(message.context.files) : [],
+							"vitest.worker.id": message.context.workerId
+						}
+					}, () => collect({
 						...setupContext,
 						...message.context
-					}, worker).catch((error) => serializeError(error));
+					}, worker, traces).catch((error) => serializeError(error)));
 					send({
 						type: "testfileFinished",
 						__vitest_worker_response__,
@@ -260,8 +285,13 @@ function init(worker) {
 			case "stop":
 				await runPromise;
 				try {
-					const error = await teardown().catch((error) => serializeError(error));
-					await workerTeardown?.();
+					const context = traces.getContextFromCarrier(message.otelCarrier);
+					const error = await traces.$("vitest.runtime.teardown", { context }, async () => {
+						const error = await teardown().catch((error) => serializeError(error));
+						await workerTeardown?.();
+						return error;
+					});
+					await traces.finish();
 					send({
 						type: "stopped",
 						error,
@@ -279,5 +309,13 @@ function init(worker) {
 		}
 	}
 }
+function getFilesWithLocations(files) {
+	return files.flatMap((file) => {
+		if (!file.testLocations) return file.filepath;
+		return file.testLocations.map((location) => {
+			return `${file}:${location}`;
+		});
+	});
+}
 
 export { init as i, loadEnvironment as l };

package/dist/chunks/{moduleRunner.d.BxT-OjLR.d.ts → moduleRunner.d.B5SW5pMI.d.ts}

@@ -2,7 +2,8 @@ import * as _vitest_spy from '@vitest/spy';
 import vm from 'node:vm';
 import * as viteModuleRunner from 'vite/module-runner';
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, EvaluatedModules } from 'vite/module-runner';
-import { R as RuntimeRPC, e as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.ZGohxCEd.js';
+import { R as RuntimeRPC, e as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.B_PZTrCQ.js';
+import { T as Traces } from './traces.d.B8ukBJqA.js';
 import { MockedModule, MockedModuleType } from '@vitest/mocker';
 import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './mocker.d.BE_2ls6u.js';
 
@@ -77,6 +78,7 @@ interface VitestModuleEvaluatorOptions {
 	getCurrentTestFilepath?: () => string | undefined;
 	compiledFunctionArgumentsNames?: string[];
 	compiledFunctionArgumentsValues?: unknown[];
+	traces?: Traces;
 }
 declare class VitestModuleEvaluator implements ModuleEvaluator {
 	private options;
@@ -87,10 +89,12 @@ declare class VitestModuleEvaluator implements ModuleEvaluator {
 	private compiledFunctionArgumentsValues;
 	private primitives;
 	private debug;
+	private _otel;
 	constructor(vmOptions?: VitestVmOptions | undefined, options?: VitestModuleEvaluatorOptions);
 	private convertIdToImportUrl;
 	runExternalModule(id: string): Promise<any>;
 	runInlinedModule(context: ModuleRunnerContext, code: string, module: Readonly<EvaluatedModuleNode>): Promise<any>;
+	private _runInlinedModule;
 	private createRequire;
 	private shouldInterop;
 }
@@ -113,6 +117,7 @@ interface MockContext {
 }
 interface VitestMockerOptions {
 	context?: vm.Context;
+	traces: Traces;
 	spyModule?: typeof _vitest_spy;
 	root: string;
 	moduleDirectories: string[];
@@ -132,6 +137,7 @@ declare class VitestMocker {
 	private filterPublicKeys;
 	private registries;
 	private mockContext;
+	private _otel;
 	constructor(moduleRunner: VitestModuleRunner, options: VitestMockerOptions);
 	private get root();
 	private get evaluatedModules();
@@ -176,6 +182,7 @@ declare class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	private vitestOptions;
 	mocker: VitestMocker;
 	moduleExecutionInfo: ModuleExecutionInfo;
+	private _otel;
 	constructor(vitestOptions: VitestModuleRunnerOptions);
 	import(rawId: string): Promise<any>;
 	fetchModule(url: string, importer?: string): Promise<EvaluatedModuleNode>;
@@ -188,6 +195,7 @@ interface VitestModuleRunnerOptions {
 	getWorkerState: () => WorkerGlobalState;
 	mocker?: VitestMocker;
 	vm?: VitestVmOptions;
+	traces?: Traces;
 	spyModule?: typeof _vitest_spy;
 	createImportMeta?: CreateImportMeta;
 }

package/dist/chunks/plugin.d.N8khPRFb.d.ts

@@ -0,0 +1,38 @@
+import { DevEnvironment } from 'vite';
+import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.DgZLBdyd.js';
+
+/**
+* Generate a unique cache identifier.
+*
+* Return `false` to disable caching of the file.
+* @experimental
+*/
+interface CacheKeyIdGenerator {
+	(context: CacheKeyIdGeneratorContext): string | undefined | null | false;
+}
+/**
+* @experimental
+*/
+interface CacheKeyIdGeneratorContext {
+	environment: DevEnvironment;
+	id: string;
+	sourceCode: string;
+}
+
+interface VitestPluginContext {
+	vitest: Vitest;
+	project: TestProject;
+	injectTestProjects: (config: TestProjectConfiguration | TestProjectConfiguration[]) => Promise<TestProject[]>;
+	/**
+	* Define a generator that will be applied before hashing the cache key.
+	*
+	* Use this to make sure Vitest generates correct hash. It is a good idea
+	* to define this function if your plugin can be registered with different options.
+	*
+	* This is called only if `experimental.fsModuleCache` is defined.
+	* @experimental
+	*/
+	experimental_defineCacheKeyGenerator: (callback: CacheKeyIdGenerator) => void;
+}
+
+export type { CacheKeyIdGenerator as C, VitestPluginContext as V, CacheKeyIdGeneratorContext as a };