vitest 0.29.8 → 0.30.0

package/dist/{types-94cfe4b4.d.ts → types-f03c83c4.d.ts}

@@ -1,17 +1,20 @@
 import { MatchersObject, MatcherState } from '@vitest/expect';
-import { UserConfig as UserConfig$1, TransformResult as TransformResult$1, ViteDevServer, CommonServerOptions, DepOptimizationConfig, AliasOptions } from 'vite';
+import { SnapshotResult, SnapshotStateOptions, SnapshotState } from '@vitest/snapshot';
+import { TransformResult as TransformResult$1, ViteDevServer, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions, DepOptimizationConfig } from 'vite';
 import * as _vitest_runner from '@vitest/runner';
-import { Task as Task$1, Test as Test$2, TaskCustom, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
+import { Task as Task$1, Test as Test$2, TaskCustom, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
 import { File, Test as Test$1, Suite, TaskResultPack, Task } from '@vitest/runner/types';
 import { ParsedStack, ErrorWithDiff, ChainableFunction } from '@vitest/runner/utils';
 import { Awaitable as Awaitable$1, Arrayable as Arrayable$1 } from '@vitest/utils';
 import { Task as Task$2, TaskResult, Bench, Options } from 'tinybench';
 import { ViteNodeRunner } from 'vite-node/client';
+import { SnapshotManager } from '@vitest/snapshot/manager';
 import { MessagePort } from 'node:worker_threads';
 import { RawSourceMap, FetchResult, ViteNodeResolveId, ModuleCacheMap } from 'vite-node';
 import { RawSourceMap as RawSourceMap$1 } from 'source-map';
-import { Stats } from 'node:fs';
 import { ViteNodeServer } from 'vite-node/server';
+import { Stats } from 'node:fs';
+import * as chai from 'chai';
 
 /**
  * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
@@ -66,7 +69,6 @@ interface PrettyFormatOptions {
     printFunctionName?: boolean;
     theme?: ThemeReceived;
 }
-declare type OptionsReceived = PrettyFormatOptions;
 declare type Config = {
     callToJSON: boolean;
     compareKeys: CompareKeys;
@@ -166,16 +168,6 @@ interface FakeTimerInstallOpts {
     shouldClearNativeTimers?: boolean | undefined;
 }
 
-declare class SnapshotManager {
-    options: SnapshotStateOptions;
-    summary: SnapshotSummary;
-    extension: string;
-    constructor(options: SnapshotStateOptions);
-    clear(): void;
-    add(result: SnapshotResult): void;
-    resolvePath(testPath: string): string;
-}
-
 interface ParsedFile extends File {
     start: number;
     end: number;
@@ -216,7 +208,7 @@ interface ErrorsCache {
 }
 type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>;
 declare class Typechecker {
-    protected ctx: Vitest;
+    protected ctx: WorkspaceProject;
     protected files: string[];
     private _onParseStart?;
     private _onParseEnd?;
@@ -226,7 +218,7 @@ declare class Typechecker {
     private tempConfigPath?;
     private allowJs?;
     private process;
-    constructor(ctx: Vitest, files: string[]);
+    constructor(ctx: WorkspaceProject, files: string[]);
     onParseStart(fn: Callback): void;
     onParseEnd(fn: Callback<[ErrorsCache]>): void;
     onWatcherRerun(fn: Callback): void;
@@ -252,13 +244,53 @@ declare class Typechecker {
     getTestPacks(): TaskResultPack[];
 }
 
+declare class VitestServer extends ViteNodeServer {
+    private _vitestPath?;
+    private getVitestPath;
+    protected processTransformResult(id: string, result: TransformResult$1): Promise<TransformResult$1>;
+}
+
+interface InitializeOptions {
+    server?: VitestServer;
+    runner?: ViteNodeRunner;
+}
+declare class WorkspaceProject {
+    path: string | number;
+    ctx: Vitest;
+    configOverride: Partial<ResolvedConfig> | undefined;
+    config: ResolvedConfig;
+    server: ViteDevServer;
+    vitenode: VitestServer;
+    runner: ViteNodeRunner;
+    browser: ViteDevServer;
+    typechecker?: Typechecker;
+    closingPromise: Promise<unknown> | undefined;
+    browserProvider: BrowserProvider | undefined;
+    constructor(path: string | number, ctx: Vitest);
+    getName(): string;
+    isCore(): boolean;
+    get reporters(): Reporter[];
+    globTestFiles(filters?: string[]): Promise<string[]>;
+    globAllTestFiles(config: ResolvedConfig, cwd: string): Promise<string[]>;
+    globFiles(include: string[], exclude: string[], cwd: string): Promise<string[]>;
+    filterFiles(testFiles: string[], filters?: string[]): string[];
+    initBrowserServer(options: UserConfig): Promise<void>;
+    setServer(options: UserConfig, server: ViteDevServer, params?: InitializeOptions): Promise<void>;
+    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
+    typecheck(filters?: string[]): Promise<void>;
+    isBrowserEnabled(): boolean | 0;
+    getSerializableConfig(): ResolvedConfig;
+    close(): Promise<unknown>;
+    initBrowserProvider(): Promise<void>;
+}
+
 interface BrowserProviderOptions {
     browser: string;
 }
 interface BrowserProvider {
     name: string;
     getSupportedBrowsers(): readonly string[];
-    initialize(ctx: Vitest, options: BrowserProviderOptions): Awaitable$1<void>;
+    initialize(ctx: WorkspaceProject, options: BrowserProviderOptions): Awaitable$1<void>;
     openPage(url: string): Awaitable$1<void>;
     close(): Awaitable$1<void>;
 }
@@ -298,7 +330,8 @@ interface ResolvedBrowserOptions extends BrowserConfigOptions {
     api: ApiConfig;
 }
 
-type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
+type WorkspaceSpec = [project: WorkspaceProject, testFile: string];
+type RunWithFiles = (files: WorkspaceSpec[], invalidates?: string[]) => Promise<void>;
 interface ProcessPool {
     runTests: RunWithFiles;
     close: () => Promise<void>;
@@ -309,7 +342,7 @@ interface CollectingPromise {
     resolve: () => void;
 }
 declare class StateManager {
-    filesMap: Map<string, File>;
+    filesMap: Map<string, File[]>;
     pathsSet: Set<string>;
     collectingPromise: CollectingPromise | undefined;
     browserTestPromises: Map<string, {
@@ -331,7 +364,7 @@ declare class StateManager {
     getFailedFilepaths(): string[];
     collectPaths(paths?: string[]): void;
     collectFiles(files?: File[]): void;
-    clearFiles(paths?: string[]): void;
+    clearFiles(project: WorkspaceProject, paths?: string[]): void;
     updateId(task: Task): void;
     updateTasks(packs: TaskResultPack[]): void;
     updateUserLog(log: UserConsoleLog): void;
@@ -371,12 +404,13 @@ interface SuiteResultCache {
 }
 declare class ResultsCache {
     private cache;
+    private workspacesKeyMap;
     private cachePath;
     private version;
     private root;
     getCachePath(): string | null;
     setConfig(root: string, config: ResolvedConfig['cache']): void;
-    getResults(fsPath: string): SuiteResultCache | undefined;
+    getResults(key: string): SuiteResultCache | undefined;
     readFromCache(): Promise<void>;
     updateResults(files: File[]): void;
     removeFromCache(filepath: string): void;
@@ -399,16 +433,17 @@ declare function startVitest(mode: VitestRunMode, cliFilters: string[], options:
 type FileStatsCache = Pick<Stats, 'size'>;
 declare class FilesStatsCache {
     cache: Map<string, FileStatsCache>;
-    getStats(fsPath: string): FileStatsCache | undefined;
-    updateStats(fsPath: string): Promise<void>;
+    getStats(key: string): FileStatsCache | undefined;
+    populateStats(root: string, specs: WorkspaceSpec[]): Promise<void>;
+    updateStats(fsPath: string, key: string): Promise<void>;
     removeStats(fsPath: string): void;
 }
 
 declare class VitestCache {
     results: ResultsCache;
     stats: FilesStatsCache;
-    getFileTestResults(id: string): SuiteResultCache | undefined;
-    getFileStats(id: string): {
+    getFileTestResults(key: string): SuiteResultCache | undefined;
+    getFileStats(key: string): {
         size: number;
     } | undefined;
     static resolveCacheDir(root: string, dir: string | undefined): string;
@@ -418,17 +453,10 @@ declare class VitestCache {
     }>;
 }
 
-declare class VitestServer extends ViteNodeServer {
-    private _vitestPath?;
-    private getVitestPath;
-    protected processTransformResult(result: TransformResult$1): Promise<TransformResult$1>;
-}
-
 declare class Vitest {
     readonly mode: VitestRunMode;
     config: ResolvedConfig;
-    configOverride: Partial<ResolvedConfig> | undefined;
-    browser: ViteDevServer;
+    configOverride: Partial<ResolvedConfig>;
     server: ViteDevServer;
     state: StateManager;
     snapshot: SnapshotManager;
@@ -438,7 +466,6 @@ declare class Vitest {
     browserProvider: BrowserProvider | undefined;
     logger: Logger;
     pool: ProcessPool | undefined;
-    typechecker: Typechecker | undefined;
     vitenode: VitestServer;
     invalidates: Set<string>;
     changedTests: Set<string>;
@@ -448,19 +475,24 @@ declare class Vitest {
     isFirstRun: boolean;
     restartsCount: number;
     runner: ViteNodeRunner;
+    private coreWorkspace;
+    projects: WorkspaceProject[];
+    private projectsTestFiles;
     constructor(mode: VitestRunMode);
     private _onRestartListeners;
     private _onSetServer;
-    initBrowserServer(options: UserConfig): Promise<void>;
-    setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
-    initCoverageProvider(): Promise<CoverageProvider | null | undefined>;
-    initBrowserProvider(): Promise<BrowserProvider>;
-    getSerializableConfig(): ResolvedConfig;
-    typecheck(filters?: string[]): Promise<void>;
+    setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
+    private createCoreWorkspace;
+    getCoreWorkspaceProject(): WorkspaceProject;
+    private resolveWorkspace;
+    private initCoverageProvider;
+    private initBrowserProviders;
+    typecheck(filters?: string[]): Promise<void[]>;
     start(filters?: string[]): Promise<void>;
     private getTestDependencies;
-    filterTestsBySource(tests: string[]): Promise<string[]>;
-    runFiles(paths: string[]): Promise<void>;
+    filterTestsBySource(specs: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
+    getProjectsByTestFile(file: string): WorkspaceSpec[];
+    runFiles(paths: WorkspaceSpec[]): Promise<void>;
     rerunFiles(files?: string[], trigger?: string): Promise<void>;
     changeNamePattern(pattern: string, files?: string[], trigger?: string): Promise<void>;
     changeFilenamePattern(pattern: string): Promise<void>;
@@ -468,6 +500,7 @@ declare class Vitest {
     updateSnapshot(files?: string[]): Promise<void>;
     private _rerunTimer;
     private scheduleRerun;
+    getModuleProjects(id: string): WorkspaceProject[];
     private unregisterWatcher;
     private registerWatcher;
     /**
@@ -481,13 +514,8 @@ declare class Vitest {
      */
     exit(force?: boolean): Promise<void>;
     report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
-    globFiles(include: string[], exclude: string[], cwd: string): Promise<string[]>;
-    private _allTestsCache;
-    globAllTestFiles(config: ResolvedConfig, cwd: string): Promise<string[]>;
-    filterFiles(testFiles: string[], filters?: string[]): string[];
-    globTestFiles(filters?: string[]): Promise<string[]>;
-    isTargetFile(id: string, source?: string): Promise<boolean>;
-    isBrowserEnabled(): boolean | 0;
+    globTestFiles(filters?: string[]): Promise<WorkspaceSpec[]>;
+    private isTargetFile;
     shouldKeepServer(): boolean;
     isInSourceTestFile(code: string): boolean;
     onServerRestart(fn: OnServerRestartHandler): void;
@@ -503,8 +531,8 @@ interface TestSequencer {
      * Slicing tests into shards. Will be run before `sort`.
      * Only run, if `shard` is defined.
      */
-    shard(files: string[]): Awaitable<string[]>;
-    sort(files: string[]): Awaitable<string[]>;
+    shard(files: WorkspaceSpec[]): Awaitable<WorkspaceSpec[]>;
+    sort(files: WorkspaceSpec[]): Awaitable<WorkspaceSpec[]>;
 }
 interface TestSequencerConstructor {
     new (ctx: Vitest): TestSequencer;
@@ -588,7 +616,7 @@ interface ListRendererOptions$1 {
     showHeap: boolean;
     mode: VitestRunMode;
 }
-declare const createListRenderer: (_tasks: Task[], options: ListRendererOptions$1) => {
+declare function createListRenderer(_tasks: Task[], options: ListRendererOptions$1): {
     start(): any;
     update(_tasks: Task[]): any;
     stop(): Promise<any>;
@@ -709,7 +737,7 @@ interface ListRendererOptions {
     logger: Logger;
     showHeap: boolean;
 }
-declare const createTableRenderer: (_tasks: Task[], options: ListRendererOptions) => {
+declare function createTableRenderer(_tasks: Task[], options: ListRendererOptions): {
     start(): any;
     update(_tasks: Task[]): any;
     stop(): Promise<any>;
@@ -748,42 +776,48 @@ declare const ReportersMap: {
 };
 type BuiltinReporters = keyof typeof ReportersMap;
 
-interface RollupError extends RollupLogProps {
-	parserError?: Error;
+declare function createExpect(test?: Test$2): Vi.ExpectStatic;
+declare const globalExpect: Vi.ExpectStatic;
+
+declare function setupChaiConfig(config: ChaiConfig): void;
+type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
+
+// utils
+type NullValue = null | undefined | void;
+
+type PartialNull<T> = {
+	[P in keyof T]: T[P] | null;
+};
+
+interface RollupError extends RollupLog {
+	name?: string;
 	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[];
-}
+type RollupWarning = RollupLog;
 
-interface RollupLogProps {
+interface RollupLog {
+	binding?: string;
+	cause?: unknown;
 	code?: string;
+	exporter?: string;
 	frame?: string;
 	hook?: string;
 	id?: string;
+	ids?: string[];
 	loc?: {
 		column: number;
 		file?: string;
 		line: number;
 	};
 	message: string;
-	name?: string;
+	names?: string[];
 	plugin?: string;
 	pluginCode?: string;
 	pos?: number;
+	reexporter?: string;
+	stack?: string;
 	url?: string;
 }
 
@@ -793,8 +827,9 @@ interface ExistingRawSourceMap {
 	names: string[];
 	sourceRoot?: string;
 	sources: string[];
-	sourcesContent?: string[];
+	sourcesContent?: (string | null)[];
 	version: number;
+	x_google_ignoreList?: number[];
 }
 
 interface SourceMap {
@@ -802,7 +837,7 @@ interface SourceMap {
 	mappings: string;
 	names: string[];
 	sources: string[];
-	sourcesContent: string[];
+	sourcesContent: (string | null)[];
 	version: number;
 	toString(): string;
 	toUrl(): string;
@@ -810,11 +845,8 @@ interface SourceMap {
 
 type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' };
 
-type PartialNull<T> = {
-	[P in keyof T]: T[P] | null;
-};
-
 interface ModuleOptions {
+	assertions: Record<string, string>;
 	meta: CustomPluginOptions;
 	moduleSideEffects: boolean | 'no-treeshake';
 	syntheticNamedExports: boolean | string;
@@ -840,6 +872,7 @@ interface MinimalPluginContext {
 interface EmittedAsset {
 	fileName?: string;
 	name?: string;
+	needsCodeReference?: boolean;
 	source?: string | Uint8Array;
 	type: 'asset';
 }
@@ -856,10 +889,6 @@ interface EmittedChunk {
 
 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 {
@@ -868,6 +897,8 @@ interface ModuleInfo extends ModuleOptions {
 	dynamicImporters: readonly string[];
 	dynamicallyImportedIdResolutions: readonly ResolvedId[];
 	dynamicallyImportedIds: readonly string[];
+	exportedBindings: Record<string, string[]> | null;
+	exports: string[] | null;
 	hasDefaultExport: boolean | null;
 	/** @deprecated Use `moduleSideEffects` instead */
 	hasModuleSideEffects: boolean | 'no-treeshake';
@@ -891,22 +922,12 @@ interface CustomPluginOptions {
 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;
+	error: (error: RollupError | string, pos?: number | { column: number; line: number }) => never;
 	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>;
@@ -916,10 +937,13 @@ interface PluginContext extends MinimalPluginContext {
 	resolve: (
 		source: string,
 		importer?: string,
-		options?: { custom?: CustomPluginOptions; isEntry?: boolean; skipSelf?: boolean }
+		options?: {
+			assertions?: Record<string, string>;
+			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;
 }
@@ -932,19 +956,14 @@ interface PluginContextMeta {
 interface ResolvedId extends ModuleOptions {
 	external: boolean | 'absolute';
 	id: string;
+	resolvedBy: 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 TransformResult = string | NullValue | Partial<SourceDescription>;
 type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
 
 interface AcornNode {
@@ -1047,53 +1066,6 @@ declare type BirpcReturn<RemoteFunctions> = {
     [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
 };
 
-type SnapshotData = Record<string, string>;
-type SnapshotUpdateState = 'all' | 'new' | 'none';
-interface SnapshotStateOptions {
-    updateSnapshot: SnapshotUpdateState;
-    expand?: boolean;
-    snapshotFormat?: OptionsReceived;
-    resolveSnapshotPath?: (path: string, extension: string) => string;
-}
-interface SnapshotMatchOptions {
-    testName: string;
-    received: unknown;
-    key?: string;
-    inlineSnapshot?: string;
-    isInline: boolean;
-    error?: Error;
-}
-interface SnapshotResult {
-    filepath: string;
-    added: number;
-    fileDeleted: boolean;
-    matched: number;
-    unchecked: number;
-    uncheckedKeys: Array<string>;
-    unmatched: number;
-    updated: number;
-}
-interface UncheckedSnapshot {
-    filePath: string;
-    keys: Array<string>;
-}
-interface SnapshotSummary {
-    added: number;
-    didUpdate: boolean;
-    failure: boolean;
-    filesAdded: number;
-    filesRemoved: number;
-    filesRemovedList: Array<string>;
-    filesUnmatched: number;
-    filesUpdated: number;
-    matched: number;
-    total: number;
-    unchecked: number;
-    uncheckedKeysByFile: Array<UncheckedSnapshot>;
-    unmatched: number;
-    updated: number;
-}
-
 interface RuntimeRPC {
     fetch: (id: string, environment: VitestEnvironment) => Promise<FetchResult>;
     resolveId: (id: string, importer: string | undefined, environment: VitestEnvironment) => Promise<ViteNodeResolveId | null>;
@@ -1137,6 +1109,10 @@ interface WorkerGlobalState {
     environmentTeardownRun?: boolean;
     moduleCache: ModuleCacheMap;
     mockMap: MockMap;
+    durations: {
+        environment: number;
+        prepare: number;
+    };
 }
 
 interface CoverageProvider {
@@ -1477,6 +1453,84 @@ interface EnvironmentOptions {
     [x: string]: unknown;
 }
 type VitestRunMode = 'test' | 'benchmark' | 'typecheck';
+interface SequenceOptions {
+    /**
+     * Class that handles sorting and sharding algorithm.
+     * If you only need to change sorting, you can extend
+     * your custom sequencer from `BaseSequencer` from `vitest/node`.
+     * @default BaseSequencer
+     */
+    sequencer?: TestSequencerConstructor;
+    /**
+     * Should tests run in random order.
+     * @default false
+     */
+    shuffle?: boolean;
+    /**
+     * Defines how setup files should be ordered
+     * - 'parallel' will run all setup files in parallel
+     * - 'list' will run all setup files in the order they are defined in the config file
+     * @default 'parallel'
+     */
+    setupFiles?: SequenceSetupFiles;
+    /**
+     * Seed for the random number generator.
+     * @default Date.now()
+     */
+    seed?: number;
+    /**
+     * Defines how hooks should be ordered
+     * - `stack` will order "after" hooks in reverse order, "before" hooks will run sequentially
+     * - `list` will order hooks in the order they are defined
+     * - `parallel` will run hooks in a single group in parallel
+     * @default 'parallel'
+     */
+    hooks?: SequenceHooks;
+}
+interface DepsOptions {
+    /**
+     * Enable dependency optimization. This can improve the performance of your tests.
+     */
+    experimentalOptimizer?: Omit<DepOptimizationConfig, 'disabled'> & {
+        enabled: boolean;
+    };
+    /**
+     * Externalize means that Vite will bypass the package to native Node.
+     *
+     * Externalized dependencies will not be applied Vite's transformers and resolvers.
+     * And does not support HMR on reload.
+     *
+     * Typically, packages under `node_modules` are externalized.
+     */
+    external?: (string | RegExp)[];
+    /**
+     * Vite will process inlined modules.
+     *
+     * This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
+     *
+     * If `true`, every dependency will be inlined
+     */
+    inline?: (string | RegExp)[] | true;
+    /**
+     * Interpret CJS module's default as named exports
+     *
+     * @default true
+     */
+    interopDefault?: boolean;
+    /**
+     * When a dependency is a valid ESM package, try to guess the cjs version based on the path.
+     * This will significantly improve the performance in huge repo, but might potentially
+     * cause some misalignment if a package have different logic in ESM and CJS mode.
+     *
+     * @default false
+     */
+    fallbackCJS?: boolean;
+    /**
+     * Use experimental Node loader to resolve imports inside node_modules using Vite resolve algorithm.
+     * @default false
+     */
+    registerNodeLoader?: boolean;
+}
 interface InlineConfig {
     /**
      * Name of the project. Will be used to display in the reporter.
@@ -1508,50 +1562,7 @@ interface InlineConfig {
     /**
      * Handling for dependencies inlining or externalizing
      */
-    deps?: {
-        /**
-         * Enable dependency optimization. This can improve the performance of your tests.
-         */
-        experimentalOptimizer?: Omit<DepOptimizationConfig, 'disabled'> & {
-            enabled: boolean;
-        };
-        /**
-         * Externalize means that Vite will bypass the package to native Node.
-         *
-         * Externalized dependencies will not be applied Vite's transformers and resolvers.
-         * And does not support HMR on reload.
-         *
-         * Typically, packages under `node_modules` are externalized.
-         */
-        external?: (string | RegExp)[];
-        /**
-         * Vite will process inlined modules.
-         *
-         * This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
-         *
-         * If `true`, every dependency will be inlined
-         */
-        inline?: (string | RegExp)[] | true;
-        /**
-         * Interpret CJS module's default as named exports
-         *
-         * @default true
-         */
-        interopDefault?: boolean;
-        /**
-         * When a dependency is a valid ESM package, try to guess the cjs version based on the path.
-         * This will significantly improve the performance in huge repo, but might potentially
-         * cause some misalignment if a package have different logic in ESM and CJS mode.
-         *
-         * @default false
-         */
-        fallbackCJS?: boolean;
-        /**
-         * Use experimental Node loader to resolve imports inside node_modules using Vite resolve algorithm.
-         * @default false
-         */
-        registerNodeLoader?: boolean;
-    };
+    deps?: DepsOptions;
     /**
      * Base directory to scan for the test files
      *
@@ -1630,29 +1641,6 @@ interface InlineConfig {
      * and/or paths to custom reporters.
      */
     reporters?: Arrayable<BuiltinReporters | 'html' | Reporter | Omit<string, BuiltinReporters>>;
-    /**
-     * Truncates lines in the output to the given length.
-     * @default stdout.columns || 80
-     */
-    outputTruncateLength?: number;
-    /**
-     * Maximum number of line to show in a single diff.
-     * @default 15
-     */
-    outputDiffLines?: number;
-    /**
-     * The maximum number of characters allowed in a single object before doing a diff.
-     * Vitest tries to stringify an object before doing a diff, but if the object is too large,
-     * it will reduce the depth of the object to fit within this limit.
-     * Because of this if object is too big or nested, you might not see the diff.
-     * @default 10000
-     */
-    outputDiffMaxSize?: number;
-    /**
-     * Maximum number of lines in a diff overall.
-     * @default 50
-     */
-    outputDiffMaxLines?: number;
     /**
      * Write test results to a file when the --reporter=json` or `--reporter=junit` option is also specified.
      * Also definable individually per reporter by using an object instead.
@@ -1888,40 +1876,7 @@ interface InlineConfig {
     /**
      * Options for configuring the order of running tests.
      */
-    sequence?: {
-        /**
-         * Class that handles sorting and sharding algorithm.
-         * If you only need to change sorting, you can extend
-         * your custom sequencer from `BaseSequencer` from `vitest/node`.
-         * @default BaseSequencer
-         */
-        sequencer?: TestSequencerConstructor;
-        /**
-         * Should tests run in random order.
-         * @default false
-         */
-        shuffle?: boolean;
-        /**
-         * Defines how setup files should be ordered
-         * - 'parallel' will run all setup files in parallel
-         * - 'list' will run all setup files in the order they are defined in the config file
-         * @default 'parallel'
-         */
-        setupFiles?: SequenceSetupFiles;
-        /**
-         * Seed for the random number generator.
-         * @default Date.now()
-         */
-        seed?: number;
-        /**
-         * Defines how hooks should be ordered
-         * - `stack` will order "after" hooks in reverse order, "before" hooks will run sequentially
-         * - `list` will order hooks in the order they are defined
-         * - `parallel` will run hooks in a single group in parallel
-         * @default 'parallel'
-         */
-        hooks?: SequenceHooks;
-    };
+    sequence?: SequenceOptions;
     /**
      * Specifies an `Object`, or an `Array` of `Object`,
      * which defines aliases used to replace values in `import` or `require` statements.
@@ -1958,6 +1913,11 @@ interface InlineConfig {
      * Requires `singleThread: true` OR `threads: false`.
      */
     inspectBrk?: boolean;
+    /**
+     * Modify default Chai config. Vitest uses Chai for `expect` and `assert` matches.
+     * https://github.com/chaijs/chai/blob/4.x.x/lib/chai/config.js
+    */
+    chaiConfig?: ChaiConfig;
 }
 interface TypecheckConfig {
     /**
@@ -2055,6 +2015,10 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     typecheck: TypecheckConfig;
     runner?: string;
 }
+type ProjectConfig = Omit<UserConfig, 'sequencer' | 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'maxThreads' | 'minThreads' | 'useAtomics' | 'teardownTimeout' | 'silent' | 'watchExclude' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'deps' | 'coverage'> & {
+    sequencer?: Omit<SequenceOptions, 'sequencer' | 'seed'>;
+    deps?: Omit<DepsOptions, 'registerNodeLoader'>;
+};
 type RuntimeConfig = Pick<UserConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency'> & {
     sequence?: {
         hooks?: SequenceHooks;
@@ -2071,56 +2035,6 @@ declare module 'vite' {
     }
 }
 
-/**
- * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-interface SnapshotReturnOptions {
-    actual: string;
-    count: number;
-    expected?: string;
-    key: string;
-    pass: boolean;
-}
-interface SaveStatus {
-    deleted: boolean;
-    saved: boolean;
-}
-declare class SnapshotState {
-    testFilePath: string;
-    snapshotPath: string;
-    private _counters;
-    private _dirty;
-    private _updateSnapshot;
-    private _snapshotData;
-    private _initialData;
-    private _inlineSnapshots;
-    private _uncheckedKeys;
-    private _snapshotFormat;
-    private _environment;
-    private _fileExists;
-    added: number;
-    expand: boolean;
-    matched: number;
-    unmatched: number;
-    updated: number;
-    private constructor();
-    static create(testFilePath: string, options: SnapshotStateOptions): Promise<SnapshotState>;
-    markSnapshotsAsCheckedForTest(testName: string): void;
-    private _inferInlineSnapshotStack;
-    private _addSnapshot;
-    clear(): void;
-    save(): Promise<SaveStatus>;
-    getUncheckedCount(): number;
-    getUncheckedKeys(): Array<string>;
-    removeUncheckedKeys(): void;
-    match({ testName, received, key, inlineSnapshot, isInline, error, }: SnapshotMatchOptions): SnapshotReturnOptions;
-    pack(): Promise<SnapshotResult>;
-}
-
 type Promisify<O> = {
     [K in keyof O]: O[K] extends (...args: infer A) => infer R ? O extends R ? Promisify<O[K]> : (...args: A) => Promise<R> : O[K];
 };
@@ -2134,6 +2048,10 @@ declare module '@vitest/runner' {
     interface TestContext {
         expect: Vi.ExpectStatic;
     }
+    interface File {
+        prepareDuration?: number;
+        environmentLoad?: number;
+    }
     interface TaskBase {
         logs?: UserConsoleLog[];
     }
@@ -2143,7 +2061,7 @@ declare module '@vitest/runner' {
 }
 declare global {
     namespace jest {
-        interface Matchers<R, T = {}> {
+        interface Matchers<_R, _T = {}> {
         }
     }
     namespace Vi {
@@ -2166,18 +2084,19 @@ declare global {
             stringMatching(expected: string | RegExp): any;
         }
         interface JestAssertion<T = any> extends jest.Matchers<void, T> {
-            toMatchSnapshot<U extends {
-                [P in keyof T]: any;
-            }>(snapshot: Partial<U>, message?: string): void;
-            toMatchSnapshot(message?: string): void;
             matchSnapshot<U extends {
                 [P in keyof T]: any;
             }>(snapshot: Partial<U>, message?: string): void;
             matchSnapshot(message?: string): void;
+            toMatchSnapshot<U extends {
+                [P in keyof T]: any;
+            }>(snapshot: Partial<U>, message?: string): void;
+            toMatchSnapshot(message?: string): void;
             toMatchInlineSnapshot<U extends {
                 [P in keyof T]: any;
             }>(properties: Partial<U>, snapshot?: string, message?: string): void;
             toMatchInlineSnapshot(snapshot?: string, message?: string): void;
+            toMatchFileSnapshot(filepath: string, message?: string): Promise<void>;
             toThrowErrorMatchingSnapshot(message?: string): void;
             toThrowErrorMatchingInlineSnapshot(snapshot?: string, message?: string): void;
             toEqual<E>(expected: E): void;
@@ -2263,4 +2182,4 @@ type Context = RootAndTarget & {
     lastActivePath?: string;
 };
 
-export { CoverageReporter as $, AfterSuiteRunMeta as A, BenchmarkAPI as B, CollectLineNumbers as C, Awaitable as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, Arrayable as G, ArgumentsType$1 as H, InlineConfig as I, JSDOMOptions as J, MutableArray as K, Constructable as L, MockFactoryWithHelper as M, Nullable as N, ModuleCache as O, EnvironmentReturn as P, Environment as Q, RuntimeConfig as R, SnapshotResult as S, TscErrorInfo as T, UserConsoleLog as U, VitestEnvironment as V, WorkerContext as W, OnServerRestartHandler as X, CoverageProvider as Y, ReportContext as Z, CoverageProviderModule as _, ResolvedConfig as a, CoverageOptions as a0, ResolvedCoverageOptions as a1, BaseCoverageOptions as a2, CoverageIstanbulOptions as a3, CoverageC8Options as a4, CustomProviderOptions as a5, BenchmarkUserOptions as a6, Benchmark as a7, BenchmarkResult as a8, BenchFunction as a9, MockFactory as aa, MockMap as ab, TestSequencer as ac, startVitest as ad, TestSequencerConstructor as ae, HtmlOptions as af, FileOptions as ag, CloverOptions as ah, CoberturaOptions as ai, HtmlSpaOptions as aj, LcovOptions as ak, LcovOnlyOptions as al, TeamcityOptions as am, TextOptions as an, ProjectOptions as ao, ModuleGraphData as b, Reporter as c, RawErrsMap as d, CollectLines as e, RootAndTarget as f, Context as g, BuiltinEnvironment as h, VitestPool as i, CSSModuleScopeStrategy as j, ApiConfig as k, VitestRunMode as l, TypecheckConfig as m, UserConfig as n, RuntimeRPC as o, ContextTestEnvironment as p, ContextRPC as q, Vitest as r, SnapshotData as s, SnapshotUpdateState as t, SnapshotStateOptions as u, SnapshotMatchOptions as v, UncheckedSnapshot as w, SnapshotSummary as x, ResolveIdFunction as y, WorkerGlobalState as z };
+export { ResolvedCoverageOptions as $, AfterSuiteRunMeta as A, BenchmarkAPI as B, ChaiConfig as C, ArgumentsType$1 as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, MutableArray as G, Constructable as H, InlineConfig as I, JSDOMOptions as J, ModuleCache as K, EnvironmentReturn as L, MockFactoryWithHelper as M, Nullable as N, Environment as O, ProjectConfig as P, OnServerRestartHandler as Q, RuntimeConfig as R, CoverageProvider as S, TscErrorInfo as T, UserConsoleLog as U, VitestEnvironment as V, WorkerContext as W, ReportContext as X, CoverageProviderModule as Y, CoverageReporter as Z, CoverageOptions as _, ResolvedConfig as a, BaseCoverageOptions as a0, CoverageIstanbulOptions as a1, CoverageC8Options as a2, CustomProviderOptions as a3, BenchmarkUserOptions as a4, Benchmark as a5, BenchmarkResult as a6, BenchFunction as a7, MockFactory as a8, MockMap as a9, TestSequencer as aa, WorkspaceSpec as ab, WorkspaceProject as ac, startVitest as ad, TestSequencerConstructor as ae, HtmlOptions as af, FileOptions as ag, CloverOptions as ah, CoberturaOptions as ai, HtmlSpaOptions as aj, LcovOptions as ak, LcovOnlyOptions as al, TeamcityOptions as am, TextOptions as an, ProjectOptions as ao, ModuleGraphData as b, Reporter as c, createExpect as d, RawErrsMap as e, CollectLineNumbers as f, globalExpect as g, CollectLines as h, RootAndTarget as i, Context as j, BuiltinEnvironment as k, VitestPool as l, CSSModuleScopeStrategy as m, ApiConfig as n, VitestRunMode as o, TypecheckConfig as p, UserConfig as q, RuntimeRPC as r, setupChaiConfig as s, ContextTestEnvironment as t, ContextRPC as u, Vitest as v, ResolveIdFunction as w, WorkerGlobalState as x, Awaitable as y, Arrayable as z };