vitest 4.0.0-beta.8 → 4.0.0

package/dist/node.d.ts

@@ -3,28 +3,27 @@ import { InlineConfig, UserConfig as UserConfig$1, Plugin, ResolvedConfig as Res
 export { vite as Vite };
 export { esbuildVersion, isCSSRequest, isFileServingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from 'vite';
 import { IncomingMessage } from 'node:http';
-import { h as ResolvedConfig, f as UserConfig, i as VitestRunMode, j as VitestOptions, V as Vitest, A as ApiConfig, k as TestSpecification, T as TestProject, P as Pool, l as TestSequencer, L as Logger } from './chunks/reporters.d.37tJQ2uV.js';
-export { an as BaseCoverageOptions, G as BenchmarkUserOptions, K as BrowserBuiltinProvider, N as BrowserCommand, Q as BrowserCommandContext, X as BrowserConfigOptions, Y as BrowserInstanceOption, Z as BrowserModuleMocker, _ as BrowserOrchestrator, $ as BrowserProvider, a0 as BrowserProviderInitializationOptions, a1 as BrowserProviderModule, a2 as BrowserProviderOptions, a3 as BrowserScript, a4 as BrowserServerState, a5 as BrowserServerStateSession, ac as BuiltinEnvironment, a6 as CDPSession, ad as CSSModuleScopeStrategy, ao as CoverageIstanbulOptions, ap as CoverageOptions, aq as CoverageProvider, ar as CoverageProviderModule, as as CoverageReporter, c as CoverageV8Options, at as CustomProviderOptions, ae as DepsOptimizationOptions, af as EnvironmentOptions, H as HTMLOptions, I as InlineConfig, o as JUnitOptions, J as JsonOptions, M as ModuleDiagnostic, O as OnServerRestartHandler, m as OnTestsRerunHandler, a7 as ParentProjectBrowser, ag as PoolOptions, a8 as ProjectBrowser, ah as ProjectConfig, b as ReportContext, av as ReportedHookContext, aw as Reporter, aj as ResolveSnapshotPathHandler, ak as ResolveSnapshotPathHandlerContext, a9 as ResolvedBrowserOptions, R as ResolvedCoverageOptions, ai as ResolvedProjectConfig, S as SerializedTestProject, p as TaskOptions, q as TestCase, r as TestCollection, s as TestDiagnostic, t as TestModule, u as TestModuleState, v as TestResult, w as TestResultFailed, x as TestResultPassed, y as TestResultSkipped, ax as TestRunEndReason, au as TestRunResult, F as TestSequencerConstructor, z as TestState, B as TestSuite, D as TestSuiteState, aa as ToMatchScreenshotComparators, ab as ToMatchScreenshotOptions, al as TypecheckConfig, U as UserWorkspaceConfig, am as VitestEnvironment, n as VitestPackageInstaller, W as WatcherTriggerPattern, E as experimental_getRunnerTask } from './chunks/reporters.d.37tJQ2uV.js';
+import { h as ResolvedConfig, f as UserConfig, i as VitestRunMode, j as VitestOptions, V as Vitest, A as ApiConfig, k as TestSpecification, T as TestProject, P as PoolWorker, l as PoolOptions, m as WorkerRequest, n as TestSequencer, L as Logger } from './chunks/reporters.d.BMKt7f6I.js';
+export { at as BaseCoverageOptions, Y as BenchmarkUserOptions, Z as BrowserBuiltinProvider, $ as BrowserCommand, a0 as BrowserCommandContext, a1 as BrowserConfigOptions, a2 as BrowserInstanceOption, a3 as BrowserModuleMocker, a4 as BrowserOrchestrator, a5 as BrowserProvider, a6 as BrowserProviderOption, a7 as BrowserScript, a8 as BrowserServerFactory, a9 as BrowserServerOptions, aa as BrowserServerState, ab as BrowserServerStateSession, ai as BuiltinEnvironment, ac as CDPSession, aj as CSSModuleScopeStrategy, au as CoverageIstanbulOptions, av as CoverageOptions, aw as CoverageProvider, ax as CoverageProviderModule, ay as CoverageReporter, c as CoverageV8Options, az as CustomProviderOptions, ak as DepsOptimizationOptions, al as EnvironmentOptions, H as HTMLOptions, I as InlineConfig, t as JUnitOptions, J as JsonOptions, M as ModuleDiagnostic, O as OnServerRestartHandler, o as OnTestsRerunHandler, ad as ParentProjectBrowser, am as Pool, q as PoolRunnerInitializer, r as PoolTask, ae as ProjectBrowser, an as ProjectConfig, b as ReportContext, aB as ReportedHookContext, aC as Reporter, ap as ResolveSnapshotPathHandler, aq as ResolveSnapshotPathHandlerContext, af as ResolvedBrowserOptions, R as ResolvedCoverageOptions, ao as ResolvedProjectConfig, S as SerializedTestProject, u as TaskOptions, v as TestCase, w as TestCollection, x as TestDiagnostic, y as TestModule, z as TestModuleState, B as TestResult, D as TestResultFailed, E as TestResultPassed, F as TestResultSkipped, aD as TestRunEndReason, aA as TestRunResult, X as TestSequencerConstructor, G as TestState, K as TestSuite, N as TestSuiteState, ag as ToMatchScreenshotComparators, ah as ToMatchScreenshotOptions, ar as TypecheckConfig, U as UserWorkspaceConfig, as as VitestEnvironment, p as VitestPackageInstaller, W as WatcherTriggerPattern, s as WorkerResponse, _ as _BrowserNames, Q as experimental_getRunnerTask } from './chunks/reporters.d.BMKt7f6I.js';
 import { Awaitable } from '@vitest/utils';
 export { SerializedError } from '@vitest/utils';
-import { R as RuntimeRPC } from './chunks/worker.d.DYlqbejz.js';
-export { T as TestExecutionType } from './chunks/worker.d.DYlqbejz.js';
+import { R as RuntimeRPC, C as ContextRPC } from './chunks/worker.d.BFk-vvBU.js';
+export { T as TestExecutionType } from './chunks/worker.d.BFk-vvBU.js';
 import { Writable } from 'node:stream';
-export { V as VitestPluginContext } from './chunks/plugin.d.CHe6slQs.js';
-export { W as WorkerContext } from './chunks/worker.d.BKu8cnnX.js';
+export { V as VitestPluginContext } from './chunks/plugin.d.DQU1R5px.js';
 import { Debugger } from 'debug';
-import './chunks/global.d.K6uBQHzY.js';
+import './chunks/global.d.BgJSTpgQ.js';
 export { Task as RunnerTask, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
-export { b as RuntimeConfig } from './chunks/config.d._GBBbReY.js';
+export { b as RuntimeConfig } from './chunks/config.d.u2CUDWwS.js';
 export { generateFileHash } from '@vitest/runner/utils';
-import './chunks/environment.d.2fYMoz3o.js';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
-import './chunks/browser.d.DOMmqJQx.js';
+import 'vitest/browser';
+import './chunks/browser.d.B9iJzZyn.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
-import 'chai';
+import '@vitest/expect';
 import 'vitest/optional-types.js';
 import './chunks/benchmark.d.DAaHLpsq.js';
 import 'tinybench';
@@ -33,8 +32,7 @@ import '@vitest/snapshot/manager';
 import 'node:fs';
 import 'node:console';
 import 'vite/module-runner';
-import 'node:worker_threads';
-import '@vitest/expect';
+import './chunks/environment.d.CrsxCzP1.js';
 
 type RawErrsMap = Map<string, TscErrorInfo[]>;
 interface TscErrorInfo {
@@ -121,7 +119,6 @@ declare class GitNotFoundError extends Error {
 
 declare function VitestPlugin(options?: UserConfig, vitest?: Vitest): Promise<Plugin[]>;
 
-// this is only exported as a public function and not used inside vitest
 declare function resolveConfig(options?: UserConfig, viteOverrides?: UserConfig$1): Promise<{
 	vitestConfig: ResolvedConfig;
 	viteConfig: ResolvedConfig$1;
@@ -129,39 +126,99 @@ declare function resolveConfig(options?: UserConfig, viteOverrides?: UserConfig$
 
 declare function resolveFsAllow(projectRoot: string, rootConfigFile: string | false | undefined): string[];
 
-type RunWithFiles = (files: TestSpecification[], invalidates?: string[]) => Awaitable<void>;
+type RunWithFiles = (files: TestSpecification[], invalidates?: string[]) => Promise<void>;
 interface ProcessPool {
 	name: string;
 	runTests: RunWithFiles;
 	collectTests: RunWithFiles;
 	close?: () => Awaitable<void>;
 }
-declare function getFilePoolName(project: TestProject): Pool;
+declare function getFilePoolName(project: TestProject): ResolvedConfig["pool"];
 
 interface MethodsOptions {
 	cacheFs?: boolean;
-	// do not report files
 	collect?: boolean;
 }
 declare function createMethodsRPC(project: TestProject, options?: MethodsOptions): RuntimeRPC;
 
+/** @experimental */
+declare class ForksPoolWorker implements PoolWorker {
+	readonly name: string;
+	readonly cacheFs: boolean;
+	protected readonly entrypoint: string;
+	protected execArgv: string[];
+	protected env: Partial<NodeJS.ProcessEnv>;
+	private _fork?;
+	constructor(options: PoolOptions);
+	on(event: string, callback: (arg: any) => void): void;
+	off(event: string, callback: (arg: any) => void): void;
+	send(message: WorkerRequest): void;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	deserialize(data: unknown): unknown;
+	private get fork();
+}
+
+/** @experimental */
+declare class ThreadsPoolWorker implements PoolWorker {
+	readonly name: string;
+	protected readonly entrypoint: string;
+	protected execArgv: string[];
+	protected env: Partial<NodeJS.ProcessEnv>;
+	private _thread?;
+	constructor(options: PoolOptions);
+	on(event: string, callback: (arg: any) => void): void;
+	off(event: string, callback: (arg: any) => void): void;
+	send(message: WorkerRequest): void;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	deserialize(data: unknown): unknown;
+	private get thread();
+}
+
+/** @experimental */
+declare class TypecheckPoolWorker implements PoolWorker {
+	readonly name: string;
+	private readonly project;
+	private _eventEmitter;
+	constructor(options: PoolOptions);
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	canReuse(): boolean;
+	send(message: WorkerRequest): void;
+	on(event: string, callback: (arg: any) => any): void;
+	off(event: string, callback: (arg: any) => any): void;
+	deserialize(data: unknown): unknown;
+}
+
+/** @experimental */
+declare class VmForksPoolWorker extends ForksPoolWorker {
+	readonly name = "vmForks";
+	readonly reportMemory: true;
+	protected readonly entrypoint: string;
+	constructor(options: PoolOptions);
+}
+
+/** @experimental */
+declare class VmThreadsPoolWorker extends ThreadsPoolWorker {
+	readonly name = "vmThreads";
+	readonly reportMemory: true;
+	protected readonly entrypoint: string;
+	constructor(options: PoolOptions);
+}
+
 declare class BaseSequencer implements TestSequencer {
 	protected ctx: Vitest;
 	constructor(ctx: Vitest);
-	// async so it can be extended by other sequelizers
 	shard(files: TestSpecification[]): Promise<TestSpecification[]>;
-	// async so it can be extended by other sequelizers
 	sort(files: TestSpecification[]): Promise<TestSpecification[]>;
-	// Calculate distributed shard range [start, end] distributed equally
 	private calculateShardRange;
 }
 
 declare function registerConsoleShortcuts(ctx: Vitest, stdin: NodeJS.ReadStream | undefined, stdout: NodeJS.WriteStream | Writable): () => void;
 
-// This is copy-pasted and needs to be synced from time to time. Ideally, Vite's `createLogger` should accept a custom `console`
-// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/logger.ts?rgh-link-date=2024-10-16T23%3A29%3A19Z
-// When Vitest supports only Vite 6 and above, we can use Vite's `createLogger({ console })`
-// https://github.com/vitejs/vite/pull/18379
+interface WorkerContext extends ContextRPC {}
+
 declare function createViteLogger(console: Logger, level?: LogLevel, options?: LoggerOptions): Logger$1;
 
 declare const rootDir: string;
@@ -173,8 +230,7 @@ declare const version: string;
 
 declare const createViteServer: typeof vite.createServer;
 
-// rolldownVersion is exported only by rolldown-vite
 declare const rolldownVersion: string | undefined;
 
-export { ApiConfig, BaseSequencer, GitNotFoundError, Pool, ResolvedConfig, TestProject, TestSequencer, TestSpecification, UserConfig as TestUserConfig, FilesNotFoundError as TestsNotFoundError, Vitest, VitestOptions, VitestPlugin, VitestRunMode, createDebugger, createMethodsRPC, createViteLogger, createViteServer, createVitest, distDir, escapeTestName, getFilePoolName, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rolldownVersion, rootDir, startVitest, version };
-export type { CliParseOptions, ProcessPool, CollectLineNumbers as TypeCheckCollectLineNumbers, CollectLines as TypeCheckCollectLines, Context as TypeCheckContext, TscErrorInfo as TypeCheckErrorInfo, RawErrsMap as TypeCheckRawErrorsMap, RootAndTarget as TypeCheckRootAndTarget };
+export { ApiConfig, BaseSequencer, ForksPoolWorker, GitNotFoundError, PoolOptions, PoolWorker, ResolvedConfig, TestProject, TestSequencer, TestSpecification, UserConfig as TestUserConfig, FilesNotFoundError as TestsNotFoundError, ThreadsPoolWorker, TypecheckPoolWorker, Vitest, VitestOptions, VitestPlugin, VitestRunMode, VmForksPoolWorker, VmThreadsPoolWorker, WorkerRequest, createDebugger, createMethodsRPC, createViteLogger, createViteServer, createVitest, distDir, escapeTestName, getFilePoolName, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rolldownVersion, rootDir, startVitest, version };
+export type { CliParseOptions, ProcessPool, CollectLineNumbers as TypeCheckCollectLineNumbers, CollectLines as TypeCheckCollectLines, Context as TypeCheckContext, TscErrorInfo as TypeCheckErrorInfo, RawErrsMap as TypeCheckRawErrorsMap, RootAndTarget as TypeCheckRootAndTarget, WorkerContext };

package/dist/node.js

@@ -1,13 +1,13 @@
 import * as vite from 'vite';
 import { resolveConfig as resolveConfig$1, mergeConfig } from 'vite';
 export { esbuildVersion, isCSSRequest, isFileServingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from 'vite';
-import { V as Vitest, a as VitestPlugin } from './chunks/cli-api.C-JHgQgp.js';
-export { G as GitNotFoundError, F as TestsNotFoundError, b as VitestPackageInstaller, h as createDebugger, g as createViteLogger, c as createVitest, e as escapeTestName, d as experimental_getRunnerTask, i as isValidApiRequest, f as registerConsoleShortcuts, r as resolveFsAllow, s as startVitest } from './chunks/cli-api.C-JHgQgp.js';
-export { p as parseCLI } from './chunks/cac.By1HvRIk.js';
-import { r as resolveConfig$2 } from './chunks/coverage.DarITf6U.js';
-export { b as BaseSequencer, c as createMethodsRPC, g as getFilePoolName, a as resolveApiServerConfig } from './chunks/coverage.DarITf6U.js';
-import { slash, deepClone } from '@vitest/utils';
-import { f as findUp } from './chunks/index.X0nbfr6-.js';
+import { V as Vitest, a as VitestPlugin } from './chunks/cli-api.PwHwIMss.js';
+export { f as ForksPoolWorker, G as GitNotFoundError, F as TestsNotFoundError, T as ThreadsPoolWorker, h as TypecheckPoolWorker, b as VitestPackageInstaller, j as VmForksPoolWorker, k as VmThreadsPoolWorker, o as createDebugger, d as createMethodsRPC, n as createViteLogger, c as createVitest, e as escapeTestName, l as experimental_getRunnerTask, g as getFilePoolName, i as isValidApiRequest, m as registerConsoleShortcuts, r as resolveFsAllow, s as startVitest } from './chunks/cli-api.PwHwIMss.js';
+export { p as parseCLI } from './chunks/cac.B99MQg-w.js';
+import { r as resolveConfig$2 } from './chunks/coverage.FU3w4IrQ.js';
+export { b as BaseSequencer, a as resolveApiServerConfig } from './chunks/coverage.FU3w4IrQ.js';
+import { slash, deepClone } from '@vitest/utils/helpers';
+import { a as any } from './chunks/index.Dc3xnDvT.js';
 import { resolve } from 'pathe';
 import { c as configFiles } from './chunks/constants.D_Q9UYh-.js';
 export { distDir, rootDir } from './path.js';
@@ -18,18 +18,19 @@ import 'node:path';
 import 'node:os';
 import '@vitest/snapshot/manager';
 import './chunks/index.Bgo3tNWt.js';
-import './chunks/index.AzwzFtyi.js';
+import './chunks/index.CcRZ6fUh.js';
 import 'node:fs/promises';
-import './chunks/typechecker.DSo_maXz.js';
 import 'node:perf_hooks';
 import '@vitest/utils/source-map';
-import 'tinyexec';
 import 'tinyrainbow';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
 import 'node:util';
 import 'node:console';
 import 'node:stream';
+import '@vitest/utils/display';
+import 'tinyexec';
+import '@vitest/utils/offset';
 import 'node:module';
 import 'events';
 import 'https';
@@ -46,29 +47,31 @@ import 'node:crypto';
 import 'debug';
 import '#module-evaluator';
 import 'vite/module-runner';
+import '@vitest/utils/highlight';
 import 'node:url';
+import 'node:tty';
+import 'node:events';
+import 'node:child_process';
+import 'node:v8';
+import 'node:worker_threads';
 import 'picomatch';
 import 'tinyglobby';
 import 'magic-string';
 import '@vitest/mocker/node';
-import './chunks/defaults.CXFFjsi8.js';
-import './chunks/resolver.Bx6lE0iq.js';
+import './chunks/defaults.BOqNVLsY.js';
+import '@vitest/utils/constants';
+import '@vitest/utils/resolver';
 import 'es-module-lexer';
-import './chunks/index.BuwjkI-q.js';
+import './chunks/index.BdSLhLDZ.js';
 import 'node:assert';
-import '@vitest/utils/error';
+import '@vitest/utils/serialize';
 import 'node:readline';
 import 'node:process';
-import 'node:v8';
-import 'node:tty';
-import 'node:events';
-import 'tinypool';
-import 'node:worker_threads';
 import 'readline';
 
 // this is only exported as a public function and not used inside vitest
 async function resolveConfig(options = {}, viteOverrides = {}) {
-	const root = slash(resolve(options.root || process.cwd())), configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
+	const root = slash(resolve(options.root || process.cwd())), configPath = options.config === false ? false : options.config ? resolve(root, options.config) : any(configFiles, { cwd: root });
 	options.config = configPath;
 	const vitest = new Vitest("test", deepClone(options)), config = await resolveConfig$1(mergeConfig({
 		configFile: configPath,

package/dist/reporters.d.ts

@@ -1,19 +1,20 @@
-export { aL as BaseReporter, aM as BenchmarkBuiltinReporters, ay as BenchmarkReporter, az as BenchmarkReportsMap, aN as BuiltinReporterOptions, aO as BuiltinReporters, aA as DefaultReporter, aB as DotReporter, aC as GithubActionsReporter, aD as HangingProcessReporter, aF as JUnitReporter, aP as JsonAssertionResult, aE as JsonReporter, aQ as JsonTestResult, aR as JsonTestResults, av as ReportedHookContext, aw as Reporter, aG as ReportersMap, aH as TapFlatReporter, aI as TapReporter, ax as TestRunEndReason, aJ as VerboseBenchmarkReporter, aK as VerboseReporter } from './chunks/reporters.d.37tJQ2uV.js';
+export { aR as BaseReporter, aS as BenchmarkBuiltinReporters, aE as BenchmarkReporter, aF as BenchmarkReportsMap, aT as BuiltinReporterOptions, aU as BuiltinReporters, aG as DefaultReporter, aH as DotReporter, aI as GithubActionsReporter, aJ as HangingProcessReporter, aL as JUnitReporter, aV as JsonAssertionResult, aK as JsonReporter, aW as JsonTestResult, aX as JsonTestResults, aB as ReportedHookContext, aC as Reporter, aM as ReportersMap, aN as TapFlatReporter, aO as TapReporter, aD as TestRunEndReason, aP as VerboseBenchmarkReporter, aQ as VerboseReporter } from './chunks/reporters.d.BMKt7f6I.js';
 import '@vitest/runner';
 import '@vitest/utils';
-import './chunks/environment.d.2fYMoz3o.js';
-import 'node:stream';
-import 'vite';
-import '@vitest/mocker';
-import '@vitest/utils/source-map';
-import './chunks/browser.d.DOMmqJQx.js';
-import './chunks/worker.d.DYlqbejz.js';
+import './chunks/worker.d.BFk-vvBU.js';
 import 'vite/module-runner';
-import './chunks/config.d._GBBbReY.js';
+import './chunks/config.d.u2CUDWwS.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
-import 'chai';
+import './chunks/environment.d.CrsxCzP1.js';
+import 'node:stream';
+import 'vite';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import 'vitest/browser';
+import './chunks/browser.d.B9iJzZyn.js';
+import '@vitest/expect';
 import 'vitest/optional-types.js';
 import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';

package/dist/reporters.js

@@ -1,23 +1,24 @@
-export { D as DefaultReporter, a as DotReporter, G as GithubActionsReporter, H as HangingProcessReporter, b as JUnitReporter, J as JsonReporter, R as ReportersMap, T as TapFlatReporter, c as TapReporter, V as VerboseReporter } from './chunks/index.AzwzFtyi.js';
-export { B as BenchmarkReporter, a as BenchmarkReportsMap, V as VerboseBenchmarkReporter } from './chunks/index.BuwjkI-q.js';
+export { D as DefaultReporter, a as DotReporter, G as GithubActionsReporter, H as HangingProcessReporter, b as JUnitReporter, J as JsonReporter, R as ReportersMap, T as TapFlatReporter, c as TapReporter, V as VerboseReporter } from './chunks/index.CcRZ6fUh.js';
+export { B as BenchmarkReporter, a as BenchmarkReportsMap, V as VerboseBenchmarkReporter } from './chunks/index.BdSLhLDZ.js';
 import 'node:fs';
 import 'node:fs/promises';
 import 'pathe';
-import './chunks/typechecker.DSo_maXz.js';
-import 'node:os';
 import 'node:perf_hooks';
-import '@vitest/utils/source-map';
-import 'tinyexec';
-import './path.js';
-import 'node:path';
-import 'node:url';
 import '@vitest/runner/utils';
-import '@vitest/utils';
-import 'vite';
+import '@vitest/utils/helpers';
+import '@vitest/utils/source-map';
 import 'tinyrainbow';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
 import 'node:util';
 import 'node:console';
 import 'node:stream';
+import '@vitest/utils/display';
+import 'node:os';
+import 'tinyexec';
+import './path.js';
+import 'node:path';
+import 'node:url';
+import 'vite';
+import '@vitest/utils/offset';
 import 'node:module';

package/dist/runners.d.ts

@@ -1,7 +1,7 @@
 import * as tinybench from 'tinybench';
 import { VitestRunner, VitestRunnerImportSource, Suite, File, Task, CancelReason, Test, TestContext, ImportDuration } from '@vitest/runner';
 export { VitestRunner } from '@vitest/runner';
-import { a as SerializedConfig } from './chunks/config.d._GBBbReY.js';
+import { S as SerializedConfig } from './chunks/config.d.u2CUDWwS.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';

package/dist/runners.js

@@ -1,221 +1,19 @@
-import { updateTask } from '@vitest/runner';
-import { createDefer, getSafeTimers } from '@vitest/utils';
-import { a as getBenchOptions, g as getBenchFn } from './chunks/benchmark.UW6Ezvxy.js';
-import { g as getWorkerState } from './chunks/utils.C7__0Iv5.js';
-import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
-import { getTests, getNames, getTestName } from '@vitest/runner/utils';
-import { processError } from '@vitest/utils/error';
-import { normalize } from 'pathe';
-import { g as getSnapshotClient, i as inject, c as createExpect, v as vi } from './chunks/vi.BfdOiD4j.js';
-import { r as rpc } from './chunks/rpc.RpPylpp0.js';
-import 'chai';
-import './chunks/_commonjsHelpers.BFTU3MAI.js';
+export { N as NodeBenchmarkRunner, V as VitestTestRunner } from './chunks/test.C3RPt8JR.js';
+import '@vitest/runner';
+import '@vitest/utils/helpers';
+import '@vitest/utils/timers';
+import './chunks/benchmark.DHKMYAts.js';
+import '@vitest/runner/utils';
+import './chunks/utils.CG9h5ccR.js';
+import '@vitest/expect';
+import '@vitest/utils/error';
+import 'pathe';
+import './chunks/vi.BZvkKVkM.js';
 import '@vitest/snapshot';
 import '@vitest/spy';
+import '@vitest/utils/offset';
 import '@vitest/utils/source-map';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import './chunks/date.-jtEtIeV.js';
+import './chunks/rpc.cD77ENhU.js';
 import './chunks/index.Bgo3tNWt.js';
-
-function createBenchmarkResult(name) {
-	return {
-		name,
-		rank: 0,
-		rme: 0,
-		samples: []
-	};
-}
-const benchmarkTasks = /* @__PURE__ */ new WeakMap();
-async function runBenchmarkSuite(suite, runner) {
-	const { Task, Bench } = await runner.importTinybench(), start = performance.now(), benchmarkGroup = [], benchmarkSuiteGroup = [];
-	for (const task of suite.tasks) {
-		if (task.mode !== "run" && task.mode !== "queued") continue;
-		if (task.meta?.benchmark) benchmarkGroup.push(task);
-		else if (task.type === "suite") benchmarkSuiteGroup.push(task);
-	}
-	// run sub suites sequentially
-	for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
-	if (benchmarkGroup.length) {
-		const defer = createDefer();
-		suite.result = {
-			state: "run",
-			startTime: start,
-			benchmark: createBenchmarkResult(suite.name)
-		}, updateTask$1("suite-prepare", suite);
-		const addBenchTaskListener = (task, benchmark) => {
-			task.addEventListener("complete", (e) => {
-				const task = e.task, taskRes = task.result, result = benchmark.result.benchmark;
-				benchmark.result.state = "pass", Object.assign(result, taskRes);
-				// compute extra stats and free raw samples as early as possible
-				const samples = result.samples;
-				if (result.sampleCount = samples.length, result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2, !runner.config.benchmark?.includeSamples) result.samples.length = 0;
-				updateTask$1("test-finished", benchmark);
-			}, { once: true }), task.addEventListener("error", (e) => {
-				const task = e.task;
-				defer.reject(benchmark ? task.result.error : e);
-			}, { once: true });
-		};
-		benchmarkGroup.forEach((benchmark) => {
-			const options = getBenchOptions(benchmark), benchmarkInstance = new Bench(options), benchmarkFn = getBenchFn(benchmark);
-			benchmark.result = {
-				state: "run",
-				startTime: start,
-				benchmark: createBenchmarkResult(benchmark.name)
-			};
-			const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
-			benchmarkTasks.set(benchmark, task), addBenchTaskListener(task, benchmark);
-		});
-		const { setTimeout } = getSafeTimers(), tasks = [];
-		for (const benchmark of benchmarkGroup) {
-			const task = benchmarkTasks.get(benchmark);
-			updateTask$1("test-prepare", benchmark), await task.warmup(), tasks.push([await new Promise((resolve) => setTimeout(async () => {
-				resolve(await task.run());
-			})), benchmark]);
-		}
-		suite.result.duration = performance.now() - start, suite.result.state = "pass", updateTask$1("suite-finished", suite), defer.resolve(null), await defer;
-	}
-	function updateTask$1(event, task) {
-		updateTask(event, task, runner);
-	}
-}
-class NodeBenchmarkRunner {
-	moduleRunner;
-	constructor(config) {
-		this.config = config;
-	}
-	async importTinybench() {
-		return await import('tinybench');
-	}
-	importFile(filepath, source) {
-		if (source === "setup") {
-			const moduleNode = getWorkerState().evaluatedModules.getModuleById(filepath);
-			if (moduleNode) getWorkerState().evaluatedModules.invalidateModule(moduleNode);
-		}
-		return this.moduleRunner.import(filepath);
-	}
-	async runSuite(suite) {
-		await runBenchmarkSuite(suite, this);
-	}
-	async runTask() {
-		throw new Error("`test()` and `it()` is only available in test mode.");
-	}
-}
-
-// import type { VitestExecutor } from '../execute'
-// worker context is shared between all tests
-const workerContext = Object.create(null);
-class VitestTestRunner {
-	snapshotClient = getSnapshotClient();
-	workerState = getWorkerState();
-	moduleRunner;
-	cancelRun = false;
-	assertionsErrors = /* @__PURE__ */ new WeakMap();
-	pool = this.workerState.ctx.pool;
-	constructor(config) {
-		this.config = config;
-	}
-	importFile(filepath, source) {
-		if (source === "setup") {
-			const moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);
-			if (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);
-		}
-		return this.moduleRunner.import(filepath);
-	}
-	onCollectStart(file) {
-		this.workerState.current = file;
-	}
-	onCleanupWorkerContext(listener) {
-		this.workerState.onCleanup(listener);
-	}
-	onAfterRunFiles() {
-		this.snapshotClient.clear(), this.workerState.current = void 0;
-	}
-	getWorkerContext() {
-		return workerContext;
-	}
-	async onAfterRunSuite(suite) {
-		if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
-		if (suite.mode !== "skip" && "filepath" in suite) {
-			// mark snapshots in skipped tests as not obsolete
-			for (const test of getTests(suite)) if (test.mode === "skip") {
-				const name = getNames(test).slice(1).join(" > ");
-				this.snapshotClient.skipTest(suite.file.filepath, name);
-			}
-			const result = await this.snapshotClient.finish(suite.file.filepath);
-			if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
-				let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
-				for (const key of result.uncheckedKeys) message += `· ${key}\n`;
-				suite.result.errors ??= [], suite.result.errors.push(processError(new Error(message))), suite.result.state = "fail";
-			}
-			await rpc().snapshotSaved(result);
-		}
-		this.workerState.current = suite.suite || suite.file;
-	}
-	onAfterRunTask(test) {
-		if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
-		this.workerState.current = test.suite || test.file;
-	}
-	cancel(_reason) {
-		this.cancelRun = true;
-	}
-	injectValue(key) {
-		// inject has a very limiting type controlled by ProvidedContext
-		// some tests override it which causes the build to fail
-		return inject(key);
-	}
-	async onBeforeRunTask(test) {
-		if (this.cancelRun) test.mode = "skip";
-		test.mode !== "run" && test.mode !== "queued" || (this.workerState.current = test);
-	}
-	async onBeforeRunSuite(suite) {
-		if (this.cancelRun) suite.mode = "skip";
-		// initialize snapshot state before running file suite
-		if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
-		this.workerState.current = suite;
-	}
-	onBeforeTryTask(test) {
-		clearModuleMocks(this.config), this.snapshotClient.clearTest(test.file.filepath, test.id), setState({
-			assertionCalls: 0,
-			isExpectingAssertions: false,
-			isExpectingAssertionsError: null,
-			expectedAssertionsNumber: null,
-			expectedAssertionsNumberErrorGen: null,
-			currentTestName: getTestName(test),
-			snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
-		}, globalThis[GLOBAL_EXPECT]);
-	}
-	onAfterTryTask(test) {
-		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
-		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
-		if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
-		if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
-	}
-	extendTaskContext(context) {
-		// create error during the test initialization so we have a nice stack trace
-		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
-		let _expect;
-		return Object.defineProperty(context, "expect", { get() {
-			if (!_expect) _expect = createExpect(context.task);
-			return _expect;
-		} }), Object.defineProperty(context, "_local", { get() {
-			return _expect != null;
-		} }), context;
-	}
-	getImportDurations() {
-		const entries = [...this.workerState.moduleExecutionInfo?.entries() ?? []];
-		return Object.fromEntries(entries.map(([filepath, { duration, selfTime }]) => [normalize(filepath), {
-			selfTime,
-			totalTime: duration
-		}]));
-	}
-}
-function clearModuleMocks(config) {
-	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
-	// since each function calls another, we can just call one
-	if (restoreMocks) vi.restoreAllMocks();
-	else if (mockReset) vi.resetAllMocks();
-	else if (clearMocks) vi.clearAllMocks();
-	if (unstubEnvs) vi.unstubAllEnvs();
-	if (unstubGlobals) vi.unstubAllGlobals();
-}
-
-export { NodeBenchmarkRunner, VitestTestRunner };

package/dist/snapshot.js

@@ -1,4 +1,4 @@
-export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment } from './chunks/node.BOqcT2jW.js';
+export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment } from './chunks/node.BwAWWjHZ.js';
 import '@vitest/snapshot/environment';
-import './chunks/utils.C7__0Iv5.js';
-import '@vitest/utils';
+import './chunks/utils.CG9h5ccR.js';
+import '@vitest/utils/timers';

package/dist/suite.js

@@ -1,5 +1,6 @@
-export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.UW6Ezvxy.js';
+export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.DHKMYAts.js';
 export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
 export { createChainable } from '@vitest/runner/utils';
-import '@vitest/utils';
-import './chunks/utils.C7__0Iv5.js';
+import '@vitest/utils/helpers';
+import './chunks/utils.CG9h5ccR.js';
+import '@vitest/utils/timers';

package/dist/worker.d.ts

@@ -0,0 +1,26 @@
+import { W as WorkerGlobalState, B as BirpcOptions, R as RuntimeRPC } from './chunks/worker.d.BFk-vvBU.js';
+import { Awaitable } from '@vitest/utils';
+import '@vitest/runner';
+import 'vite/module-runner';
+import './chunks/config.d.u2CUDWwS.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/utils/diff';
+import './chunks/environment.d.CrsxCzP1.js';
+
+/** @experimental */
+declare function runBaseTests(method: "run" | "collect", state: WorkerGlobalState): Promise<void>;
+
+type WorkerRpcOptions = Pick<BirpcOptions<RuntimeRPC>, "on" | "off" | "post" | "serialize" | "deserialize">;
+interface VitestWorker extends WorkerRpcOptions {
+	runTests: (state: WorkerGlobalState) => Awaitable<unknown>;
+	collectTests: (state: WorkerGlobalState) => Awaitable<unknown>;
+}
+
+interface Options extends VitestWorker {
+	teardown?: () => void;
+}
+/** @experimental */
+declare function init(worker: Options): void;
+
+export { init, runBaseTests };