vitest 3.0.8 → 3.0.9

package/dist/browser.d.ts

@@ -1,42 +1,31 @@
-import { b as CoverageModuleLoader, c as CoverageProvider } from './chunks/reporters.66aFHiyX.js';
-import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.BCv-fVdT.js';
+import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.d.DevWltVl.js';
+import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.S9RMNXIe.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
 import { VitestExecutor } from './execute.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
 import * as spy from '@vitest/spy';
 export { spy as SpyModule };
-import './chunks/environment.d8YfPkTm.js';
-import '@vitest/utils';
-import 'node:stream';
-import 'vite';
-import '@vitest/utils/source-map';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
-import 'vite-node';
-import 'chai';
-import './chunks/benchmark.CFFwLv-O.js';
-import '@vitest/runner/utils';
-import 'tinybench';
-import '@vitest/snapshot/manager';
-import 'node:fs';
 import '@vitest/snapshot/environment';
 import 'vite-node/client';
-import './chunks/worker.BmVno_ab.js';
+import 'vite-node';
+import './chunks/worker.d.C58isfFm.js';
+import './chunks/environment.d.C8UItCbf.js';
 import 'node:vm';
 import '@vitest/mocker';
-import './chunks/mocker.cRtM890J.js';
+import './chunks/mocker.d.BE_2ls6u.js';
 
-declare function getCoverageProvider(options: SerializedCoverageConfig | undefined, loader: CoverageModuleLoader): Promise<CoverageProvider | null>;
-declare function startCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: CoverageModuleLoader, runtimeOptions: {
-    isolate: boolean;
+declare function startCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
+	isolate: boolean
 }): Promise<unknown>;
-declare function takeCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: CoverageModuleLoader): Promise<unknown>;
-declare function stopCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: CoverageModuleLoader, runtimeOptions: {
-    isolate: boolean;
+declare function takeCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader): Promise<unknown>;
+declare function stopCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
+	isolate: boolean
 }): Promise<unknown>;
 
 declare function setupCommonEnv(config: SerializedConfig): Promise<void>;
 declare function loadDiffConfig(config: SerializedConfig, executor: VitestExecutor): Promise<SerializedDiffOptions | undefined>;
 declare function loadSnapshotSerializers(config: SerializedConfig, executor: VitestExecutor): Promise<void>;
 
-export { getCoverageProvider, loadDiffConfig, loadSnapshotSerializers, setupCommonEnv, startCoverageInsideWorker, stopCoverageInsideWorker, takeCoverageInsideWorker };
+export { loadDiffConfig, loadSnapshotSerializers, setupCommonEnv, startCoverageInsideWorker, stopCoverageInsideWorker, takeCoverageInsideWorker };

package/dist/browser.js

@@ -1,8 +1,8 @@
-export { g as getCoverageProvider, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/coverage.DnNIv-kJ.js';
-export { l as loadDiffConfig, a as loadSnapshotSerializers, s as setupCommonEnv } from './chunks/setup-common.Uaw6Zgv9.js';
+export { l as loadDiffConfig, b as loadSnapshotSerializers, c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/setup-common.CPvtqi8q.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
 import * as spy from '@vitest/spy';
 export { spy as SpyModule };
+import './chunks/coverage.A3sS5-Wm.js';
 import '@vitest/snapshot';
 import '@vitest/utils';
 import './chunks/run-once.2ogXb3JV.js';

package/dist/chunks/{base.XvKTsMeK.js → base.DV59CbtV.js}

@@ -28,7 +28,7 @@ async function runBaseTests(method, state) {
   ));
   const [executor, { run }] = await Promise.all([
     startViteNode({ state, requestStubs: getDefaultRequestStubs() }),
-    import('./runBaseTests.DnaAUBKD.js')
+    import('./runBaseTests.BVrL_ow3.js')
   ]);
   const fileSpecs = ctx.files.map(
     (f) => typeof f === "string" ? { filepath: f, testLocations: void 0 } : f

package/dist/chunks/{benchmark.Cdu9hjj4.js → benchmark.DL72EVN-.js}

@@ -34,7 +34,7 @@ function createBenchmark(fn) {
   return benchmark;
 }
 function formatName(name) {
-  return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
+  return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
 }
 
 export { getBenchOptions as a, bench as b, getBenchFn as g };

package/dist/chunks/{benchmark.CFFwLv-O.d.ts → benchmark.d.BwvBVTda.d.ts}

@@ -3,22 +3,22 @@ import { ChainableFunction } from '@vitest/runner/utils';
 import { TaskResult, Bench, Options } from 'tinybench';
 
 interface Benchmark extends Test {
-    meta: {
-        benchmark: true;
-        result?: TaskResult;
-    };
+	meta: {
+		benchmark: true
+		result?: TaskResult
+	};
 }
 interface BenchmarkResult extends TaskResult {
-    name: string;
-    rank: number;
-    sampleCount: number;
-    median: number;
+	name: string;
+	rank: number;
+	sampleCount: number;
+	median: number;
 }
 type BenchFunction = (this: Bench) => Promise<void> | void;
-type ChainableBenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', (name: string | Function, fn?: BenchFunction, options?: Options) => void>;
+type ChainableBenchmarkAPI = ChainableFunction<"skip" | "only" | "todo", (name: string | Function, fn?: BenchFunction, options?: Options) => void>;
 type BenchmarkAPI = ChainableBenchmarkAPI & {
-    skipIf: (condition: any) => ChainableBenchmarkAPI;
-    runIf: (condition: any) => ChainableBenchmarkAPI;
+	skipIf: (condition: any) => ChainableBenchmarkAPI
+	runIf: (condition: any) => ChainableBenchmarkAPI
 };
 
 export type { BenchmarkResult as B, BenchFunction as a, Benchmark as b, BenchmarkAPI as c };

package/dist/chunks/{cac.VN5q-TPC.js → cac.CeVHgzve.js}

@@ -2,7 +2,7 @@ import { toArray } from '@vitest/utils';
 import { EventEmitter } from 'events';
 import { normalize } from 'pathe';
 import c from 'tinyrainbow';
-import { d as defaultPort, a as defaultBrowserPort } from './constants.fzPh7AOq.js';
+import { a as defaultPort, d as defaultBrowserPort } from './constants.DTYd6dNH.js';
 
 function toArr(any) {
 	return any == null ? [] : Array.isArray(any) ? any : [any];
@@ -618,7 +618,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "3.0.8";
+var version = "3.0.9";
 
 const apiConfig = (port) => ({
   port: {
@@ -1591,7 +1591,7 @@ async function start(mode, cliFilters, options) {
   } catch {
   }
   try {
-    const { startVitest } = await import('./cli-api.Dis64jtY.js').then(function (n) { return n.f; });
+    const { startVitest } = await import('./cli-api.Ckwz_xSb.js').then(function (n) { return n.f; });
     const ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
     if (!ctx.shouldKeepServer()) {
       await ctx.exit();
@@ -1613,7 +1613,7 @@ async function init(project) {
     console.error(new Error('Only the "browser" project is supported. Use "vitest init browser" to create a new project.'));
     process.exit(1);
   }
-  const { create } = await import('./creator.2CFRE1Yx.js');
+  const { create } = await import('./creator.BsBnpTzI.js');
   await create();
 }
 async function collect(mode, cliFilters, options) {
@@ -1622,7 +1622,7 @@ async function collect(mode, cliFilters, options) {
   } catch {
   }
   try {
-    const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.Dis64jtY.js').then(function (n) { return n.f; });
+    const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.Ckwz_xSb.js').then(function (n) { return n.f; });
     const ctx = await prepareVitest(mode, {
       ...normalizeCliOptions(cliFilters, options),
       watch: false,

package/dist/chunks/{cli-api.Dis64jtY.js → cli-api.Ckwz_xSb.js}

@@ -1,19 +1,19 @@
 import { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { relative, extname, normalize, dirname, resolve, join, basename, isAbsolute } from 'pathe';
-import { g as getCoverageProvider, C as CoverageProviderMap } from './coverage.DnNIv-kJ.js';
+import { C as CoverageProviderMap } from './coverage.A3sS5-Wm.js';
 import p, { resolve as resolve$1 } from 'node:path';
 import { noop, isPrimitive, createDefer, highlight, toArray, deepMerge, nanoid, slash, deepClone, notNullish } from '@vitest/utils';
 import { f as findUp, p as prompt } from './index.DBIGubLC.js';
 import * as vite from 'vite';
 import { searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
-import { A as API_PATH, c as configFiles, a as defaultBrowserPort, w as workspacesFiles, d as defaultPort } from './constants.fzPh7AOq.js';
+import { A as API_PATH, c as configFiles, d as defaultBrowserPort, w as workspacesFiles, a as defaultPort } from './constants.DTYd6dNH.js';
 import { generateFileHash, createFileTask, limitConcurrency, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.VN5q-TPC.js';
+import { v as version$1 } from './cac.CeVHgzve.js';
 import { c as createBirpc } from './index.68735LiX.js';
-import { p as parse, s as stringify, g as printError, h as generateCodeFrame, b as BenchmarkReportsMap, R as ReportersMap, i as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.B7vJpkTD.js';
+import { p as parse, s as stringify, g as printError, h as generateCodeFrame, b as BenchmarkReportsMap, R as ReportersMap, i as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.B8tIoLPT.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -28,19 +28,21 @@ import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import crypto from 'node:crypto';
 import { distDir, rootDir } from '../path.js';
-import { R as RandomSequencer, i as isPackageExists, h as hash, V as VitestCache, e as configDefaults, g as getFilePoolName, f as isBrowserEnabled, m as mm, a as resolveConfig, j as groupBy, w as wildcardPatternToRegExp, k as createPool, b as resolveApiServerConfig, s as stdout } from './resolveConfig.L1_HR0_0.js';
-import { i as isTTY, b as isWindows, c as convertTasksToEvents } from './typechecker.cZ0LjdSi.js';
+import { R as RandomSequencer, i as isPackageExists, h as hash, V as VitestCache, g as getFilePoolName, d as isBrowserEnabled, m as mm, r as resolveConfig, e as groupBy, w as wildcardPatternToRegExp, f as getCoverageProvider, j as createPool, a as resolveApiServerConfig, s as stdout } from './coverage.gV8doR2Y.js';
+import { c as convertTasksToEvents } from './typechecker.BlF3eHsb.js';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
 import { a as formatProjectName, w as withLabel, d as divider } from './utils.bLM2atbD.js';
 import { createRequire } from 'node:module';
 import url from 'node:url';
+import { i as isTTY, a as isWindows } from './env.D4Lgay0q.js';
 import { rm } from 'node:fs/promises';
 import nodeos__default, { tmpdir } from 'node:os';
 import require$$0$4, { posix } from 'path';
 import require$$0$5 from 'fs';
 import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
 import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
+import { c as configDefaults } from './defaults.C2Ndd9wx.js';
 import MagicString from 'magic-string';
 import assert$1 from 'node:assert';
 import { serializeError } from '@vitest/utils/error';
@@ -9067,7 +9069,10 @@ function serializeConfig(config, coreConfig, viteConfig) {
         screenshotFailures: browser.screenshotFailures,
         locators: {
           testIdAttribute: browser.locators.testIdAttribute
-        }
+        },
+        providerOptions: browser.provider === "playwright" ? {
+          actionTimeout: browser.providerOptions?.context?.actionTimeout
+        } : {}
       };
     })(config.browser),
     standalone: config.standalone,
@@ -12107,7 +12112,7 @@ async function resolveBrowserWorkspace(vitest, names, resolvedProjects) {
     }
     if (project.config.browser.providerOptions) {
       vitest.logger.warn(
-        withLabel("yellow", "Vitest", `"providerOptions"${originalName ? ` in "${originalName}" project` : ""} is ignored because it's overriden by the configs. To hide this warning, remove the "providerOptions" property from the browser configuration.`)
+        withLabel("yellow", "Vitest", `"providerOptions"${originalName ? ` in "${originalName}" project` : ""} is ignored because it's overridden by the configs. To hide this warning, remove the "providerOptions" property from the browser configuration.`)
       );
     }
     filteredInstances.forEach((config, index) => {

package/dist/chunks/config.d.DevWltVl.d.ts

@@ -0,0 +1,218 @@
+import { PrettyFormatOptions } from '@vitest/pretty-format';
+import { SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import { SnapshotUpdateState } from '@vitest/snapshot';
+import { SnapshotEnvironment } from '@vitest/snapshot/environment';
+import { SerializedDiffOptions } from '@vitest/utils/diff';
+
+/**
+ * Names of clock methods that may be faked by install.
+ */
+type FakeMethod =
+    | "setTimeout"
+    | "clearTimeout"
+    | "setImmediate"
+    | "clearImmediate"
+    | "setInterval"
+    | "clearInterval"
+    | "Date"
+    | "nextTick"
+    | "hrtime"
+    | "requestAnimationFrame"
+    | "cancelAnimationFrame"
+    | "requestIdleCallback"
+    | "cancelIdleCallback"
+    | "performance"
+    | "queueMicrotask";
+
+interface FakeTimerInstallOpts {
+    /**
+     * Installs fake timers with the specified unix epoch (default: 0)
+     */
+    now?: number | Date | undefined;
+
+    /**
+     * An array with names of global methods and APIs to fake.
+     * For instance, `vi.useFakeTimer({ toFake: ['setTimeout', 'performance'] })` will fake only `setTimeout()` and `performance.now()`
+     * @default everything available globally except `nextTick`
+     */
+    toFake?: FakeMethod[] | undefined;
+
+    /**
+     * The maximum number of timers that will be run when calling runAll()
+     * @default 10000
+     */
+    loopLimit?: number | undefined;
+
+    /**
+     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
+     * 20ms for every 20ms change in the real system time) (default: false)
+     */
+    shouldAdvanceTime?: boolean | undefined;
+
+    /**
+     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
+     * in the real system time (default: 20)
+     */
+    advanceTimeDelta?: number | undefined;
+
+    /**
+     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers.
+     * @default true
+     */
+    shouldClearNativeTimers?: boolean | undefined;
+
+    /**
+     * Don't throw error when asked to fake timers that are not present.
+     * @default false
+     */
+    ignoreMissingTimers?: boolean | undefined;
+}
+
+/**
+* Config that tests have access to.
+*/
+interface SerializedConfig {
+	name: string | undefined;
+	globals: boolean;
+	base: string | undefined;
+	snapshotEnvironment?: string;
+	disableConsoleIntercept: boolean | undefined;
+	runner: string | undefined;
+	isolate: boolean;
+	mode: "test" | "benchmark";
+	bail: number | undefined;
+	environmentOptions?: Record<string, any>;
+	root: string;
+	setupFiles: string[];
+	passWithNoTests: boolean;
+	testNamePattern: RegExp | undefined;
+	allowOnly: boolean;
+	testTimeout: number;
+	hookTimeout: number;
+	clearMocks: boolean;
+	mockReset: boolean;
+	restoreMocks: boolean;
+	unstubGlobals: boolean;
+	unstubEnvs: boolean;
+	fakeTimers: FakeTimerInstallOpts;
+	maxConcurrency: number;
+	defines: Record<string, any>;
+	expect: {
+		requireAssertions?: boolean
+		poll?: {
+			timeout?: number
+			interval?: number
+		}
+	};
+	printConsoleTrace: boolean | undefined;
+	sequence: {
+		shuffle?: boolean
+		concurrent?: boolean
+		seed: number
+		hooks: SequenceHooks
+		setupFiles: SequenceSetupFiles
+	};
+	poolOptions: {
+		forks: {
+			singleFork: boolean
+			isolate: boolean
+		}
+		threads: {
+			singleThread: boolean
+			isolate: boolean
+		}
+		vmThreads: {
+			singleThread: boolean
+		}
+		vmForks: {
+			singleFork: boolean
+		}
+	};
+	deps: {
+		web: {
+			transformAssets?: boolean
+			transformCss?: boolean
+			transformGlobPattern?: RegExp | RegExp[]
+		}
+		optimizer: {
+			web: {
+				enabled: boolean
+			}
+			ssr: {
+				enabled: boolean
+			}
+		}
+		interopDefault: boolean | undefined
+		moduleDirectories: string[] | undefined
+	};
+	snapshotOptions: {
+		updateSnapshot: SnapshotUpdateState
+		expand: boolean | undefined
+		snapshotFormat: PrettyFormatOptions | undefined
+		/**
+		* only exists for tests, not available in the main process
+		*/
+		snapshotEnvironment: SnapshotEnvironment
+	};
+	pool: string;
+	snapshotSerializers: string[];
+	chaiConfig: {
+		includeStack?: boolean
+		showDiff?: boolean
+		truncateThreshold?: number
+	} | undefined;
+	diff: string | SerializedDiffOptions | undefined;
+	retry: number;
+	includeTaskLocation: boolean | undefined;
+	inspect: boolean | string | undefined;
+	inspectBrk: boolean | string | undefined;
+	inspector: {
+		enabled?: boolean
+		port?: number
+		host?: string
+		waitForDebugger?: boolean
+	};
+	watch: boolean;
+	env: Record<string, any>;
+	browser: {
+		name: string
+		headless: boolean
+		isolate: boolean
+		fileParallelism: boolean
+		ui: boolean
+		viewport: {
+			width: number
+			height: number
+		}
+		locators: {
+			testIdAttribute: string
+		}
+		screenshotFailures: boolean
+		providerOptions: {
+			actionTimeout?: number
+		}
+	};
+	standalone: boolean;
+	logHeapUsage: boolean | undefined;
+	coverage: SerializedCoverageConfig;
+	benchmark?: {
+		includeSamples: boolean
+	};
+}
+interface SerializedCoverageConfig {
+	provider: "istanbul" | "v8" | "custom" | undefined;
+	reportsDirectory: string;
+	htmlReporter: {
+		subdir: string | undefined
+	} | undefined;
+	enabled: boolean;
+	customProviderModule: string | undefined;
+}
+type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookTimeout" | "clearMocks" | "mockReset" | "restoreMocks" | "fakeTimers" | "maxConcurrency" | "expect" | "printConsoleTrace"> & {
+	sequence?: {
+		hooks?: SequenceHooks
+	}
+};
+type RuntimeOptions = Partial<RuntimeConfig>;
+
+export type { FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedCoverageConfig as S, SerializedConfig as a, RuntimeConfig as b };

package/dist/chunks/{constants.fzPh7AOq.js → constants.DTYd6dNH.js}

@@ -43,4 +43,4 @@ const globalApis = [
   "onTestFailed"
 ];
 
-export { API_PATH as A, defaultBrowserPort as a, defaultInspectPort as b, configFiles as c, defaultPort as d, extraInlineDeps as e, globalApis as g, workspacesFiles as w };
+export { API_PATH as A, defaultPort as a, defaultInspectPort as b, configFiles as c, defaultBrowserPort as d, extraInlineDeps as e, globalApis as g, workspacesFiles as w };

package/dist/chunks/{coverage.DnNIv-kJ.js → coverage.A3sS5-Wm.js}

@@ -36,33 +36,5 @@ async function resolveCoverageProviderModule(options, loader) {
   }
   return customProviderModule.default;
 }
-async function getCoverageProvider(options, loader) {
-  const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule) {
-    return coverageModule.getProvider();
-  }
-  return null;
-}
-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;
-}
 
-export { CoverageProviderMap as C, stopCoverageInsideWorker as a, getCoverageProvider as g, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };
+export { CoverageProviderMap as C, resolveCoverageProviderModule as r };

package/dist/chunks/coverage.d.S9RMNXIe.d.ts

@@ -0,0 +1,35 @@
+import { ModuleExecutionInfo } from 'vite-node/client';
+
+interface RuntimeCoverageModuleLoader {
+	executeId: (id: string) => Promise<{
+		default: RuntimeCoverageProviderModule
+	}>;
+	isBrowser?: boolean;
+	moduleExecutionInfo?: ModuleExecutionInfo;
+}
+interface RuntimeCoverageProviderModule {
+	/**
+	* Factory for creating a new coverage provider
+	*/
+	getProvider: () => any;
+	/**
+	* Executed before tests are run in the worker thread.
+	*/
+	startCoverage?: (runtimeOptions: {
+		isolate: boolean
+	}) => unknown | Promise<unknown>;
+	/**
+	* Executed on after each run in the worker thread. Possible to return a payload passed to the provider
+	*/
+	takeCoverage?: (runtimeOptions?: {
+		moduleExecutionInfo?: ModuleExecutionInfo
+	}) => unknown | Promise<unknown>;
+	/**
+	* Executed after all tests have been run in the worker thread.
+	*/
+	stopCoverage?: (runtimeOptions: {
+		isolate: boolean
+	}) => unknown | Promise<unknown>;
+}
+
+export type { RuntimeCoverageModuleLoader as R, RuntimeCoverageProviderModule as a };