vitest 0.21.0 → 0.22.1

package/dist/{global-644546f7.d.ts → global-fe52f84b.d.ts}

@@ -1,4 +1,5 @@
-import { ViteDevServer, TransformResult, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
+import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
+import { MessagePort } from 'worker_threads';
 import { Stats } from 'fs';
 
 /**
@@ -237,9 +238,17 @@ interface ViteHotContext {
 }
 declare class ModuleCacheMap extends Map<string, ModuleCache$1> {
     normalizePath(fsPath: string): string;
-    set(fsPath: string, mod: Partial<ModuleCache$1>): this;
-    get(fsPath: string): ModuleCache$1 | undefined;
+    /**
+     * Assign partial data to the map
+     */
+    update(fsPath: string, mod: Partial<ModuleCache$1>): this;
+    set(fsPath: string, mod: ModuleCache$1): this;
+    get(fsPath: string): ModuleCache$1;
     delete(fsPath: string): boolean;
+    /**
+     * Invalidate modules that dependent on the given modules, up to the main entry
+     */
+    invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
 }
 declare class ViteNodeRunner {
     options: ViteNodeRunnerOptions;
@@ -297,17 +306,21 @@ interface FetchResult {
 }
 declare type HotContext = Omit<ViteHotContext, 'acceptDeps' | 'decline'>;
 declare type FetchFunction = (id: string) => Promise<FetchResult>;
-declare type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+declare type ResolveIdFunction$1 = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 declare type CreateHotContextFunction = (runner: ViteNodeRunner, url: string) => HotContext;
 interface ModuleCache$1 {
     promise?: Promise<any>;
     exports?: any;
     code?: string;
+    /**
+     * Module ids that imports this module
+     */
+    importers?: Set<string>;
 }
 interface ViteNodeRunnerOptions {
     root: string;
     fetchModule: FetchFunction;
-    resolveId?: ResolveIdFunction;
+    resolveId?: ResolveIdFunction$1;
     createHotContext?: CreateHotContextFunction;
     base?: string;
     moduleCache?: ModuleCacheMap;
@@ -363,8 +376,8 @@ declare class Debugger {
     clearDump(): Promise<void>;
     encodeId(id: string): string;
     recordExternalize(id: string, path: string): Promise<void>;
-    dumpFile(id: string, result: TransformResult | null): Promise<void>;
-    loadDump(id: string): Promise<TransformResult | null>;
+    dumpFile(id: string, result: TransformResult$1 | null): Promise<void>;
+    loadDump(id: string): Promise<TransformResult$1 | null>;
     writeInfo(): Promise<void>;
 }
 
@@ -374,6 +387,7 @@ declare class ViteNodeServer {
     private fetchPromiseMap;
     private transformPromiseMap;
     fetchCache: Map<string, {
+        duration?: number | undefined;
         timestamp: number;
         result: FetchResult;
     }>;
@@ -383,7 +397,7 @@ declare class ViteNodeServer {
     shouldExternalize(id: string): Promise<string | false>;
     resolveId(id: string, importer?: string): Promise<ViteNodeResolveId | null>;
     fetchModule(id: string): Promise<FetchResult>;
-    transformRequest(id: string): Promise<TransformResult | null | undefined>;
+    transformRequest(id: string): Promise<TransformResult$1 | null | undefined>;
     getTransformMode(id: string): "web" | "ssr";
     private _fetchModule;
     private _transformRequest;
@@ -515,6 +529,7 @@ declare class Vitest {
     snapshot: SnapshotManager;
     cache: VitestCache;
     reporters: Reporter[];
+    coverageProvider: CoverageProvider | null | undefined;
     logger: Logger;
     pool: WorkerPool | undefined;
     vitenode: ViteNodeServer;
@@ -528,6 +543,7 @@ declare class Vitest {
     constructor();
     private _onRestartListeners;
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
+    initCoverageProvider(): Promise<CoverageProvider | null | undefined>;
     getSerializableConfig(): ResolvedConfig;
     start(filters?: string[]): Promise<void>;
     private getTestDependencies;
@@ -547,13 +563,15 @@ declare class Vitest {
     private handleFileChanged;
     close(): Promise<void>;
     exit(force?: boolean): Promise<void>;
-    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType<Reporter[T]>): Promise<void>;
+    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
     globTestFiles(filters?: string[]): Promise<string[]>;
     isTargetFile(id: string, source?: string): Promise<boolean>;
     isInSourceTestFile(code: string): boolean;
-    onServerRestarted(fn: () => void): void;
+    onServerRestart(fn: OnServerRestartHandler): void;
 }
 
+declare type MockMap = Map<string, Record<string, string | null | (() => unknown)>>;
+
 interface TestSequencer {
     /**
      * Slicing tests into shards. Will be run before `sort`.
@@ -587,7 +605,7 @@ declare abstract class BaseReporter implements Reporter {
     onWatcherRerun(files: string[], trigger?: string): Promise<void>;
     onUserConsoleLog(log: UserConsoleLog): void;
     shouldLog(log: UserConsoleLog): boolean;
-    onServerRestart(): void;
+    onServerRestart(reason?: string): void;
     reportSummary(files: File[]): Promise<void>;
     private printTaskErrors;
     registerUnhandledRejection(): void;
@@ -690,10 +708,215 @@ declare const ReportersMap: {
 };
 declare type BuiltinReporters = keyof typeof ReportersMap;
 
+interface RollupError extends RollupLogProps {
+	parserError?: Error;
+	stack?: string;
+	watchFiles?: string[];
+}
+
+interface RollupWarning extends RollupLogProps {
+	chunkName?: string;
+	cycle?: string[];
+	exportName?: string;
+	exporter?: string;
+	guess?: string;
+	importer?: string;
+	missing?: string;
+	modules?: string[];
+	names?: string[];
+	reexporter?: string;
+	source?: string;
+	sources?: string[];
+}
+
+interface RollupLogProps {
+	code?: string;
+	frame?: string;
+	hook?: string;
+	id?: string;
+	loc?: {
+		column: number;
+		file?: string;
+		line: number;
+	};
+	message: string;
+	name?: string;
+	plugin?: string;
+	pluginCode?: string;
+	pos?: number;
+	url?: string;
+}
+
+interface ExistingRawSourceMap {
+	file?: string;
+	mappings: string;
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+}
+
+interface SourceMap {
+	file: string;
+	mappings: string;
+	names: string[];
+	sources: string[];
+	sourcesContent: string[];
+	version: number;
+	toString(): string;
+	toUrl(): string;
+}
+
+type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' };
+
+type PartialNull<T> = {
+	[P in keyof T]: T[P] | null;
+};
+
+interface ModuleOptions {
+	meta: CustomPluginOptions;
+	moduleSideEffects: boolean | 'no-treeshake';
+	syntheticNamedExports: boolean | string;
+}
+
+interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
+	ast?: AcornNode;
+	code: string;
+	map?: SourceMapInput;
+}
+
+interface PluginCache {
+	delete(id: string): boolean;
+	get<T = any>(id: string): T;
+	has(id: string): boolean;
+	set<T = any>(id: string, value: T): void;
+}
+
+interface MinimalPluginContext {
+	meta: PluginContextMeta;
+}
+
+interface EmittedAsset {
+	fileName?: string;
+	name?: string;
+	source?: string | Uint8Array;
+	type: 'asset';
+}
+
+interface EmittedChunk {
+	fileName?: string;
+	id: string;
+	implicitlyLoadedAfterOneOf?: string[];
+	importer?: string;
+	name?: string;
+	preserveSignature?: PreserveEntrySignaturesOption;
+	type: 'chunk';
+}
+
+type EmittedFile = EmittedAsset | EmittedChunk;
+
+type EmitAsset = (name: string, source?: string | Uint8Array) => string;
+
+type EmitChunk = (id: string, options?: { name?: string }) => string;
+
+type EmitFile = (emittedFile: EmittedFile) => string;
+
+interface ModuleInfo extends ModuleOptions {
+	ast: AcornNode | null;
+	code: string | null;
+	dynamicImporters: readonly string[];
+	dynamicallyImportedIdResolutions: readonly ResolvedId[];
+	dynamicallyImportedIds: readonly string[];
+	hasDefaultExport: boolean | null;
+	/** @deprecated Use `moduleSideEffects` instead */
+	hasModuleSideEffects: boolean | 'no-treeshake';
+	id: string;
+	implicitlyLoadedAfterOneOf: readonly string[];
+	implicitlyLoadedBefore: readonly string[];
+	importedIdResolutions: readonly ResolvedId[];
+	importedIds: readonly string[];
+	importers: readonly string[];
+	isEntry: boolean;
+	isExternal: boolean;
+	isIncluded: boolean | null;
+}
+
+type GetModuleInfo = (moduleId: string) => ModuleInfo | null;
+
+interface CustomPluginOptions {
+	[plugin: string]: any;
+}
+
+interface PluginContext extends MinimalPluginContext {
+	addWatchFile: (id: string) => void;
+	cache: PluginCache;
+	/** @deprecated Use `this.emitFile` instead */
+	emitAsset: EmitAsset;
+	/** @deprecated Use `this.emitFile` instead */
+	emitChunk: EmitChunk;
+	emitFile: EmitFile;
+	error: (err: RollupError | string, pos?: number | { column: number; line: number }) => never;
+	/** @deprecated Use `this.getFileName` instead */
+	getAssetFileName: (assetReferenceId: string) => string;
+	/** @deprecated Use `this.getFileName` instead */
+	getChunkFileName: (chunkReferenceId: string) => string;
+	getFileName: (fileReferenceId: string) => string;
+	getModuleIds: () => IterableIterator<string>;
+	getModuleInfo: GetModuleInfo;
+	getWatchFiles: () => string[];
+	/** @deprecated Use `this.resolve` instead */
+	isExternal: IsExternal;
+	load: (
+		options: { id: string; resolveDependencies?: boolean } & Partial<PartialNull<ModuleOptions>>
+	) => Promise<ModuleInfo>;
+	/** @deprecated Use `this.getModuleIds` instead */
+	moduleIds: IterableIterator<string>;
+	parse: (input: string, options?: any) => AcornNode;
+	resolve: (
+		source: string,
+		importer?: string,
+		options?: { custom?: CustomPluginOptions; isEntry?: boolean; skipSelf?: boolean }
+	) => Promise<ResolvedId | null>;
+	/** @deprecated Use `this.resolve` instead */
+	resolveId: (source: string, importer?: string) => Promise<string | null>;
+	setAssetSource: (assetReferenceId: string, source: string | Uint8Array) => void;
+	warn: (warning: RollupWarning | string, pos?: number | { column: number; line: number }) => void;
+}
+
+interface PluginContextMeta {
+	rollupVersion: string;
+	watchMode: boolean;
+}
+
+interface ResolvedId extends ModuleOptions {
+	external: boolean | 'absolute';
+	id: string;
+}
+
+type IsExternal = (
+	source: string,
+	importer: string | undefined,
+	isResolved: boolean
+) => boolean;
+
+interface TransformPluginContext extends PluginContext {
+	getCombinedSourcemap: () => SourceMap;
+}
+
+type TransformResult = string | null | void | Partial<SourceDescription>;
+type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
+
+interface AcornNode {
+	end: number;
+	start: number;
+	type: string;
+}
+
 declare type Awaitable<T> = T | PromiseLike<T>;
 declare type Nullable<T> = T | null | undefined;
 declare type Arrayable<T> = T | Array<T>;
-declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+declare type ArgumentsType$1<T> = T extends (...args: infer U) => any ? U : never;
 declare type MergeInsertions<T> = T extends object ? {
     [K in keyof T]: MergeInsertions<T[K]>;
 } : T;
@@ -754,150 +977,20 @@ interface ModuleGraphData {
     externalized: string[];
     inlined: string[];
 }
+declare type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
 
-declare type CoverageReporter = 'clover' | 'cobertura' | 'html-spa' | 'html' | 'json-summary' | 'json' | 'lcov' | 'lcovonly' | 'none' | 'teamcity' | 'text-lcov' | 'text-summary' | 'text';
-interface C8Options {
+declare type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+declare type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
+declare type PromisifyFn<T> = ReturnType$1<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType$1<T>>>;
+declare type BirpcFn<T> = PromisifyFn<T> & {
     /**
-     * Enable coverage, pass `--coverage` to enable
-     *
-     * @default false
-     */
-    enabled?: boolean;
-    /**
-     * Directory to write coverage report to
+     * Send event without asking for response
      */
-    reportsDirectory?: string;
-    /**
-     * Clean coverage before running tests
-     *
-     * @default true
-     */
-    clean?: boolean;
-    /**
-     * Clean coverage report on watch rerun
-     *
-     * @default false
-     */
-    cleanOnRerun?: boolean;
-    /**
-     * Check thresholds per file
-     *
-     * @default false
-     */
-    perFile?: boolean;
-    /**
-     * Allow files from outside of your cwd.
-     *
-     * @default false
-     */
-    allowExternal?: any;
-    /**
-     * Reporters
-     *
-     * @default 'text'
-     */
-    reporter?: Arrayable<CoverageReporter>;
-    /**
-     * Exclude coverage under /node_modules/
-     *
-     * @default true
-     */
-    excludeNodeModules?: boolean;
-    exclude?: string[];
-    include?: string[];
-    skipFull?: boolean;
-    extension?: string | string[];
-    all?: boolean;
-    src?: string[];
-    100?: boolean;
-    lines?: number;
-    functions?: number;
-    branches?: number;
-    statements?: number;
-}
-interface ResolvedC8Options extends Required<C8Options> {
-    tempDirectory: string;
-}
-
-interface JSDOMOptions {
-    /**
-     * The html content for the test.
-     *
-     * @default '<!DOCTYPE html>'
-     */
-    html?: string | Buffer | ArrayBufferLike;
-    /**
-     * referrer just affects the value read from document.referrer.
-     * It defaults to no referrer (which reflects as the empty string).
-     */
-    referrer?: string;
-    /**
-     * userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
-     *
-     * @default `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
-     */
-    userAgent?: string;
-    /**
-     * url sets the value returned by window.location, document.URL, and document.documentURI,
-     * and affects things like resolution of relative URLs within the document
-     * and the same-origin restrictions and referrer used while fetching subresources.
-     *
-     * @default 'http://localhost:3000'.
-     */
-    url?: string;
-    /**
-     * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
-     * Values that are not "text/html" or an XML mime type will throw.
-     *
-     * @default 'text/html'.
-     */
-    contentType?: string;
-    /**
-     * The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.
-     * Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set
-     * to 5,000,000 code units per origin, as inspired by the HTML specification.
-     *
-     * @default 5_000_000
-     */
-    storageQuota?: number;
-    /**
-     * Enable console?
-     *
-     * @default false
-     */
-    console?: boolean;
-    /**
-     * jsdom does not have the capability to render visual content, and will act like a headless browser by default.
-     * It provides hints to web pages through APIs such as document.hidden that their content is not visible.
-     *
-     * When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
-     * content.
-     *
-     * @default true
-     */
-    pretendToBeVisual?: boolean;
-    /**
-     * `includeNodeLocations` preserves the location info produced by the HTML parser,
-     * allowing you to retrieve it with the nodeLocation() method (described below).
-     *
-     * It defaults to false to give the best performance,
-     * and cannot be used with an XML content type since our XML parser does not support location info.
-     *
-     * @default false
-     */
-    includeNodeLocations?: boolean | undefined;
-    /**
-     * @default 'dangerously'
-     */
-    runScripts?: 'dangerously' | 'outside-only';
-    /**
-     * Enable CookieJar
-     *
-     * @default false
-     */
-    cookieJar?: boolean;
-    resources?: 'usable' | any;
-}
+    asEvent(...args: ArgumentsType<T>): void;
+};
+declare type BirpcReturn<RemoteFunctions> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+};
 
 declare type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
     (...args: Args): R;
@@ -977,6 +1070,7 @@ declare type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent
     timeout?: number
 ], void, {
     each: TestEachFunction;
+    <T extends ExtraContext>(name: string, fn?: TestFunction<T>, timeout?: number): void;
 }>;
 declare type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
     each: TestEachFunction;
@@ -985,22 +1079,23 @@ declare type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
 };
 declare type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'shuffle', [
     name: string,
-    factory?: SuiteFactory
+    factory?: SuiteFactory<ExtraContext>
 ], SuiteCollector<ExtraContext>, {
     each: TestEachFunction;
+    <T extends ExtraContext>(name: string, factory?: SuiteFactory<T>): SuiteCollector<T>;
 }>;
-declare type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI & {
+declare type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI<ExtraContext> & {
     each: SuiteEachFunction;
     skipIf(condition: any): ChainableSuiteAPI<ExtraContext>;
     runIf(condition: any): ChainableSuiteAPI<ExtraContext>;
 };
 declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
 declare type HookCleanupCallback = (() => Awaitable<unknown>) | void;
-interface SuiteHooks {
+interface SuiteHooks<ExtraContext = {}> {
     beforeAll: HookListener<[Suite | File], HookCleanupCallback>[];
     afterAll: HookListener<[Suite | File]>[];
-    beforeEach: HookListener<[TestContext, Suite], HookCleanupCallback>[];
-    afterEach: HookListener<[TestContext, Suite]>[];
+    beforeEach: HookListener<[TestContext & ExtraContext, Suite], HookCleanupCallback>[];
+    afterEach: HookListener<[TestContext & ExtraContext, Suite]>[];
 }
 interface SuiteCollector<ExtraContext = {}> {
     readonly name: string;
@@ -1010,9 +1105,9 @@ interface SuiteCollector<ExtraContext = {}> {
     tasks: (Suite | Test | SuiteCollector<ExtraContext>)[];
     collect: (file?: File) => Promise<Suite>;
     clear: () => void;
-    on: <T extends keyof SuiteHooks>(name: T, ...fn: SuiteHooks[T]) => void;
+    on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
 }
-declare type SuiteFactory = (test: (name: string, fn: TestFunction) => void) => Awaitable<void>;
+declare type SuiteFactory<ExtraContext = {}> = (test: (name: string, fn: TestFunction<ExtraContext>) => void) => Awaitable<void>;
 interface RuntimeContext {
     tasks: (SuiteCollector | Test)[];
     currentSuite: SuiteCollector | null;
@@ -1032,19 +1127,6 @@ interface TestContext {
     expect: Vi.ExpectStatic;
 }
 
-interface Reporter {
-    onInit?(ctx: Vitest): void;
-    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
-    onCollected?: (files?: File[]) => Awaitable<void>;
-    onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
-    onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
-    onTestRemoved?: (trigger?: string) => Awaitable<void>;
-    onWatcherStart?: () => Awaitable<void>;
-    onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
-    onServerRestart?: () => Awaitable<void>;
-    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
-}
-
 declare type SnapshotData = Record<string, string>;
 declare type SnapshotUpdateState = 'all' | 'new' | 'none';
 interface SnapshotStateOptions {
@@ -1092,6 +1174,259 @@ interface SnapshotSummary {
     updated: number;
 }
 
+interface WorkerContext {
+    workerId: number;
+    port: MessagePort;
+    config: ResolvedConfig;
+    files: string[];
+    invalidates?: string[];
+}
+declare type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+interface AfterSuiteRunMeta {
+    coverage?: unknown;
+}
+interface WorkerRPC {
+    fetch: FetchFunction;
+    resolveId: ResolveIdFunction;
+    getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
+    onFinished: (files: File[], errors?: unknown[]) => void;
+    onWorkerExit: (code?: number) => void;
+    onPathsCollected: (paths: string[]) => void;
+    onUserConsoleLog: (log: UserConsoleLog) => void;
+    onUnhandledRejection: (err: unknown) => void;
+    onCollected: (files: File[]) => void;
+    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+    onTaskUpdate: (pack: TaskResultPack[]) => void;
+    snapshotSaved: (snapshot: SnapshotResult) => void;
+    resolveSnapshotPath: (testPath: string) => string;
+}
+interface WorkerGlobalState {
+    ctx: WorkerContext;
+    config: ResolvedConfig;
+    rpc: BirpcReturn<WorkerRPC>;
+    current?: Test;
+    filepath?: string;
+    moduleCache: ModuleCacheMap;
+    browserHashMap?: Map<string, string>;
+    mockMap: MockMap;
+}
+
+interface CoverageProvider {
+    name: string;
+    initialize(ctx: Vitest): Promise<void> | void;
+    resolveOptions(): ResolvedCoverageOptions;
+    clean(clean?: boolean): void | Promise<void>;
+    onBeforeFilesRun?(): void | Promise<void>;
+    onAfterSuiteRun(meta: AfterSuiteRunMeta): void | Promise<void>;
+    reportCoverage(): void | Promise<void>;
+    onFileTransform?(sourceCode: string, id: string, pluginCtx: TransformPluginContext): TransformResult | Promise<TransformResult>;
+}
+interface CoverageProviderModule {
+    /**
+     * Factory for creating a new coverage provider
+     */
+    getProvider(): CoverageProvider | Promise<CoverageProvider>;
+    /**
+     * Executed on after each run in the worker thread. Possible to return a payload passed to the provider
+     */
+    takeCoverage?(): unknown | Promise<unknown>;
+}
+declare type CoverageReporter = 'clover' | 'cobertura' | 'html-spa' | 'html' | 'json-summary' | 'json' | 'lcov' | 'lcovonly' | 'none' | 'teamcity' | 'text-lcov' | 'text-summary' | 'text';
+declare type CoverageOptions = BaseCoverageOptions & {
+    provider?: null | CoverageProviderModule;
+} | CoverageC8Options & {
+    provider?: 'c8';
+} | CoverageIstanbulOptions & {
+    provider?: 'istanbul';
+};
+declare type ResolvedCoverageOptions = {
+    tempDirectory: string;
+} & Required<CoverageOptions>;
+interface BaseCoverageOptions {
+    /**
+     * Enable coverage, pass `--coverage` to enable
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Clean coverage before running tests
+     *
+     * @default true
+     */
+    clean?: boolean;
+    /**
+     * Clean coverage report on watch rerun
+     *
+     * @default false
+     */
+    cleanOnRerun?: boolean;
+    /**
+     * Directory to write coverage report to
+     */
+    reportsDirectory?: string;
+    /**
+     * Reporters
+     *
+     * @default 'text'
+     */
+    reporter?: Arrayable<CoverageReporter>;
+    /**
+     * List of files excluded from coverage as glob patterns
+     */
+    exclude?: string[];
+    /**
+     * Do not show files with 100% statement, branch, and function coverage
+     */
+    skipFull?: boolean;
+    /**
+     * Check thresholds per file
+     *
+     * @default false
+     */
+    perFile?: boolean;
+    /**
+     * Threshold for lines
+     */
+    lines?: number;
+    /**
+     * Threshold for functions
+     */
+    functions?: number;
+    /**
+     * Threshold for branches
+     */
+    branches?: number;
+    /**
+     * Threshold for statements
+     */
+    statements?: number;
+    /**
+     * Extensions for files to be included in coverage
+     */
+    extension?: string | string[];
+}
+interface CoverageIstanbulOptions extends BaseCoverageOptions {
+    ignoreClassMethods?: string[];
+    watermarks?: {
+        statements?: [number, number];
+        functions?: [number, number];
+        branches?: [number, number];
+        lines?: [number, number];
+    };
+}
+interface CoverageC8Options extends BaseCoverageOptions {
+    /**
+     * Allow files from outside of your cwd.
+     *
+     * @default false
+     */
+    allowExternal?: any;
+    /**
+     * Exclude coverage under /node_modules/
+     *
+     * @default true
+     */
+    excludeNodeModules?: boolean;
+    include?: string[];
+    all?: boolean;
+    src?: string[];
+    100?: boolean;
+}
+
+interface JSDOMOptions {
+    /**
+     * The html content for the test.
+     *
+     * @default '<!DOCTYPE html>'
+     */
+    html?: string | Buffer | ArrayBufferLike;
+    /**
+     * referrer just affects the value read from document.referrer.
+     * It defaults to no referrer (which reflects as the empty string).
+     */
+    referrer?: string;
+    /**
+     * userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
+     *
+     * @default `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
+     */
+    userAgent?: string;
+    /**
+     * url sets the value returned by window.location, document.URL, and document.documentURI,
+     * and affects things like resolution of relative URLs within the document
+     * and the same-origin restrictions and referrer used while fetching subresources.
+     *
+     * @default 'http://localhost:3000'.
+     */
+    url?: string;
+    /**
+     * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
+     * Values that are not "text/html" or an XML mime type will throw.
+     *
+     * @default 'text/html'.
+     */
+    contentType?: string;
+    /**
+     * The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.
+     * Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set
+     * to 5,000,000 code units per origin, as inspired by the HTML specification.
+     *
+     * @default 5_000_000
+     */
+    storageQuota?: number;
+    /**
+     * Enable console?
+     *
+     * @default false
+     */
+    console?: boolean;
+    /**
+     * jsdom does not have the capability to render visual content, and will act like a headless browser by default.
+     * It provides hints to web pages through APIs such as document.hidden that their content is not visible.
+     *
+     * When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
+     * content.
+     *
+     * @default true
+     */
+    pretendToBeVisual?: boolean;
+    /**
+     * `includeNodeLocations` preserves the location info produced by the HTML parser,
+     * allowing you to retrieve it with the nodeLocation() method (described below).
+     *
+     * It defaults to false to give the best performance,
+     * and cannot be used with an XML content type since our XML parser does not support location info.
+     *
+     * @default false
+     */
+    includeNodeLocations?: boolean | undefined;
+    /**
+     * @default 'dangerously'
+     */
+    runScripts?: 'dangerously' | 'outside-only';
+    /**
+     * Enable CookieJar
+     *
+     * @default false
+     */
+    cookieJar?: boolean;
+    resources?: 'usable' | any;
+}
+
+interface Reporter {
+    onInit?(ctx: Vitest): void;
+    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+    onCollected?: (files?: File[]) => Awaitable<void>;
+    onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
+    onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
+    onTestRemoved?: (trigger?: string) => Awaitable<void>;
+    onWatcherStart?: () => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
+    onServerRestart?: (reason?: string) => Awaitable<void>;
+    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
+}
+
 declare type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 declare type ApiConfig = Pick<CommonServerOptions, 'port' | 'strictPort' | 'host'>;
 
@@ -1291,7 +1626,7 @@ interface InlineConfig {
     /**
      * Coverage options
      */
-    coverage?: C8Options;
+    coverage?: CoverageOptions;
     /**
      * run test names with the specified pattern
      */
@@ -1378,7 +1713,7 @@ interface InlineConfig {
      */
     allowOnly?: boolean;
     /**
-     * Show heap usage after each test. Usefull for debugging memory leaks.
+     * Show heap usage after each test. Useful for debugging memory leaks.
      */
     logHeapUsage?: boolean;
     /**
@@ -1495,7 +1830,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     filters?: string[];
     testNamePattern?: RegExp;
     related?: string[];
-    coverage: ResolvedC8Options;
+    coverage: ResolvedCoverageOptions;
     snapshotOptions: SnapshotStateOptions;
     reporters: (Reporter | BuiltinReporters)[];
     defines: Record<string, any>;
@@ -1774,4 +2109,4 @@ declare global {
     }
 }
 
-export { CoverageReporter as $, ApiConfig as A, BuiltinEnvironment as B, ArgumentsType as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, MergeInsertions as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, DeepMerge as K, MutableArray as L, ModuleGraphData as M, Nullable as N, Constructable as O, ModuleCache as P, EnvironmentReturn as Q, ResolvedConfig as R, Suite as S, TaskResultPack as T, UserConfig as U, Vitest as V, Environment as W, UserConsoleLog as X, Position as Y, ParsedStack as Z, ErrorWithDiff as _, File as a, C8Options as a0, ResolvedC8Options as a1, ViteNodeResolveId as a2, FetchFunction as a3, RawSourceMap as a4, ModuleCacheMap as a5, ViteNodeRunnerOptions as a6, ViteNodeRunner as a7, TestSequencer as a8, startVitest as a9, TestSequencerConstructor as aa, Reporter as b, RunMode as c, TaskState as d, TaskBase as e, TaskResult as f, Test as g, Task as h, TestFunction as i, TestAPI as j, SuiteAPI as k, HookCleanupCallback as l, SuiteHooks as m, SuiteCollector as n, SuiteFactory as o, RuntimeContext as p, TestContext as q, SnapshotData as r, SnapshotUpdateState as s, SnapshotStateOptions as t, SnapshotMatchOptions as u, SnapshotResult as v, UncheckedSnapshot as w, SnapshotSummary as x, Awaitable as y, Arrayable as z };
+export { Environment as $, ApiConfig as A, BuiltinEnvironment as B, WorkerRPC as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, WorkerGlobalState as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, Awaitable as K, Arrayable as L, ModuleGraphData as M, Nullable as N, ArgumentsType$1 as O, MergeInsertions as P, DeepMerge as Q, ResolvedConfig as R, Suite as S, TaskResultPack as T, UserConfig as U, Vitest as V, WorkerContext as W, MutableArray as X, Constructable as Y, ModuleCache as Z, EnvironmentReturn as _, File as a, UserConsoleLog as a0, Position as a1, ParsedStack as a2, ErrorWithDiff as a3, OnServerRestartHandler as a4, CoverageProvider as a5, CoverageProviderModule as a6, CoverageReporter as a7, CoverageOptions as a8, ResolvedCoverageOptions as a9, BaseCoverageOptions as aa, CoverageIstanbulOptions as ab, CoverageC8Options as ac, ModuleCacheMap as ad, ViteNodeRunnerOptions as ae, MockMap as af, ViteNodeRunner as ag, TestSequencer as ah, startVitest as ai, TestSequencerConstructor as aj, Reporter as b, RunMode as c, TaskState as d, TaskBase as e, TaskResult as f, Test as g, Task as h, TestFunction as i, TestAPI as j, SuiteAPI as k, HookCleanupCallback as l, SuiteHooks as m, SuiteCollector as n, SuiteFactory as o, RuntimeContext as p, TestContext as q, SnapshotData as r, SnapshotUpdateState as s, SnapshotStateOptions as t, SnapshotMatchOptions as u, SnapshotResult as v, UncheckedSnapshot as w, SnapshotSummary as x, ResolveIdFunction as y, AfterSuiteRunMeta as z };