vitest 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/{reporters-d10f25e1.d.ts → reporters-1678fe04.d.ts}

@@ -402,26 +402,29 @@ declare class TypeCheckError extends Error {
     name: string;
     constructor(message: string, stacks: ParsedStack[]);
 }
-interface ErrorsCache {
+interface TypecheckResults {
     files: File[];
     sourceErrors: TypeCheckError[];
+    time: number;
 }
 type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>;
 declare class Typechecker {
     protected ctx: WorkspaceProject;
-    protected files: string[];
     private _onParseStart?;
     private _onParseEnd?;
     private _onWatcherRerun?;
     private _result;
+    private _startTime;
     private _output;
     private _tests;
     private tempConfigPath?;
     private allowJs?;
     private process?;
-    constructor(ctx: WorkspaceProject, files: string[]);
+    protected files: string[];
+    constructor(ctx: WorkspaceProject);
+    setFiles(files: string[]): void;
     onParseStart(fn: Callback): void;
-    onParseEnd(fn: Callback<[ErrorsCache]>): void;
+    onParseEnd(fn: Callback<[TypecheckResults]>): void;
     onWatcherRerun(fn: Callback): void;
     protected collectFileTests(filepath: string): Promise<FileInformation | null>;
     protected getFiles(): string[];
@@ -430,6 +433,7 @@ declare class Typechecker {
     protected prepareResults(output: string): Promise<{
         files: File[];
         sourceErrors: TypeCheckError[];
+        time: number;
     }>;
     protected parseTscLikeOutput(output: string): Promise<Map<string, {
         error: TypeCheckError;
@@ -442,7 +446,7 @@ declare class Typechecker {
     getExitCode(): number | false;
     getOutput(): string;
     start(): Promise<void>;
-    getResult(): ErrorsCache;
+    getResult(): TypecheckResults;
     getTestFiles(): File[];
     getTestPacks(): TaskResultPack[];
 }
@@ -514,27 +518,30 @@ declare class WorkspaceProject {
     isInSourceTestFile(code: string): boolean;
     filterFiles(testFiles: string[], filters: string[] | undefined, dir: string): string[];
     initBrowserServer(configFile: string | undefined): Promise<void>;
+    static createBasicProject(ctx: Vitest): WorkspaceProject;
     static createCoreProject(ctx: Vitest): Promise<WorkspaceProject>;
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
     report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
-    typecheck(filters?: string[]): Promise<void>;
-    isBrowserEnabled(): boolean | 0;
+    isBrowserEnabled(): boolean;
     getSerializableConfig(): ResolvedConfig;
     close(): Promise<unknown>;
     initBrowserProvider(): Promise<void>;
 }
 
-interface BrowserProviderOptions {
+interface BrowserProviderInitializationOptions {
     browser: string;
+    options?: BrowserProviderOptions;
 }
 interface BrowserProvider {
     name: string;
     getSupportedBrowsers(): readonly string[];
-    initialize(ctx: WorkspaceProject, options: BrowserProviderOptions): Awaitable$1<void>;
+    initialize(ctx: WorkspaceProject, options: BrowserProviderInitializationOptions): Awaitable$1<void>;
     openPage(url: string): Awaitable$1<void>;
     catchError(cb: (error: Error) => Awaitable$1<void>): () => Awaitable$1<void>;
     close(): Awaitable$1<void>;
 }
+interface BrowserProviderOptions {
+}
 interface BrowserConfigOptions {
     /**
      * if running tests in the browser should be the default
@@ -547,11 +554,22 @@ interface BrowserConfigOptions {
      */
     name: string;
     /**
-     * browser provider
+     * Browser provider
      *
      * @default 'webdriverio'
      */
     provider?: 'webdriverio' | 'playwright' | (string & {});
+    /**
+     * Options that are passed down to a browser provider.
+     * To support type hinting, add one of the types to your tsconfig.json "compilerOptions.types" field:
+     *
+     * - for webdriverio: `@vitest/browser/providers/webdriverio`
+     * - for playwright: `@vitest/browser/providers/playwright`
+     *
+     * @example
+     * { playwright: { launch: { devtools: true } }
+     */
+    providerOptions?: BrowserProviderOptions;
     /**
      * enable headless mode
      *
@@ -759,16 +777,16 @@ declare class Vitest {
     };
     constructor(mode: VitestRunMode);
     private _onRestartListeners;
+    private _onClose;
     private _onSetServer;
     private _onCancelListeners;
     setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
     private createCoreProject;
-    getCoreWorkspaceProject(): WorkspaceProject | null;
+    getCoreWorkspaceProject(): WorkspaceProject;
     getProjectByTaskId(taskId: string): WorkspaceProject;
     private resolveWorkspace;
     private initCoverageProvider;
     private initBrowserProviders;
-    typecheck(filters?: string[]): Promise<void[]>;
     start(filters?: string[]): Promise<void>;
     private getTestDependencies;
     filterTestsBySource(specs: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
@@ -802,6 +820,7 @@ declare class Vitest {
     onServerRestart(fn: OnServerRestartHandler): void;
     onAfterSetServer(fn: OnServerRestartHandler): void;
     onCancel(fn: (reason: CancelReason) => void): void;
+    onClose(fn: () => void): void;
 }
 
 interface TestSequencer {
@@ -827,6 +846,7 @@ declare abstract class BaseReporter implements Reporter {
     private _lastRunTimer;
     private _lastRunCount;
     private _timeStart;
+    private _offUnhandledRejection?;
     constructor();
     get mode(): VitestRunMode;
     onInit(ctx: Vitest): void;
@@ -1175,6 +1195,7 @@ interface ResolvedTestEnvironment {
 }
 interface ContextRPC {
     config: ResolvedConfig;
+    projectName: string;
     files: string[];
     invalidates?: string[];
     environment: ContextTestEnvironment;
@@ -1187,6 +1208,8 @@ interface WorkerContext extends ContextRPC {
 type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 interface AfterSuiteRunMeta {
     coverage?: unknown;
+    transformMode: Environment['transformMode'];
+    projectName?: string;
 }
 type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
 interface WorkerGlobalState {
@@ -1549,7 +1572,7 @@ type BenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', [
     runIf(condition: any): BenchmarkAPI;
 };
 
-type Pool = 'browser' | 'threads' | 'forks' | 'vmThreads';
+type Pool = 'browser' | 'threads' | 'forks' | 'vmThreads' | 'typescript';
 interface PoolOptions {
     /**
      * Run tests in `node:worker_threads`.
@@ -1637,7 +1660,7 @@ interface EnvironmentOptions {
     happyDOM?: HappyDOMOptions;
     [x: string]: unknown;
 }
-type VitestRunMode = 'test' | 'benchmark' | 'typecheck';
+type VitestRunMode = 'test' | 'benchmark';
 interface SequenceOptions {
     /**
      * Class that handles sorting and sharding algorithm.
@@ -1774,12 +1797,6 @@ interface DepsOptions {
      * @deprecated Use `server.deps.fallbackCJS` instead.
      */
     fallbackCJS?: boolean;
-    /**
-     * Use experimental Node loader to resolve imports inside node_modules using Vite resolve algorithm.
-     * @default false
-     * @deprecated If you rely on aliases inside external packages, use `deps.optimizer.{web,ssr}.include` instead.
-     */
-    registerNodeLoader?: boolean;
     /**
      * A list of directories relative to the config file that should be treated as module directories.
      *
@@ -1873,7 +1890,7 @@ interface InlineConfig {
      *
      * @default 'threads'
      */
-    pool?: Omit<Pool, 'browser'>;
+    pool?: Exclude<Pool, 'browser'>;
     /**
      * Pool options
      */
@@ -1891,7 +1908,7 @@ interface InlineConfig {
      *   // ...
      * ]
      */
-    poolMatchGlobs?: [string, Omit<Pool, 'browser'>][];
+    poolMatchGlobs?: [string, Exclude<Pool, 'browser'>][];
     /**
      * Update snapshot
      *
@@ -2077,6 +2094,13 @@ interface InlineConfig {
      * Return `false` to ignore the log.
      */
     onConsoleLog?: (log: string, type: 'stdout' | 'stderr') => false | void;
+    /**
+     * Enable stack trace filtering. If absent, all stack trace frames
+     * will be shown.
+     *
+     * Return `false` to omit the frame.
+     */
+    onStackTrace?: (error: Error, frame: ParsedStack) => boolean | void;
     /**
      * Indicates if CSS files should be processed.
      *
@@ -2162,6 +2186,14 @@ interface InlineConfig {
     retry?: number;
 }
 interface TypecheckConfig {
+    /**
+     * Run typechecking tests alongisde regular tests.
+     */
+    enabled?: boolean;
+    /**
+     * When typechecking is enabled, only run typechecking tests.
+     */
+    only?: boolean;
     /**
      * What tools to use for type checking.
      */
@@ -2224,7 +2256,7 @@ interface UserConfig extends InlineConfig {
      */
     shard?: string;
 }
-interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'browser' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck' | 'runner' | 'poolOptions'> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'browser' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck' | 'runner' | 'poolOptions' | 'pool'> {
     mode: VitestRunMode;
     base?: string;
     config?: string;
@@ -2239,9 +2271,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     reporters: (Reporter | BuiltinReporters)[];
     defines: Record<string, any>;
     api?: ApiConfig;
-    benchmark?: Required<Omit<BenchmarkUserOptions, 'outputFile'>> & {
-        outputFile?: BenchmarkUserOptions['outputFile'];
-    };
+    benchmark?: Required<Omit<BenchmarkUserOptions, 'outputFile'>> & Pick<BenchmarkUserOptions, 'outputFile'>;
     shard?: {
         index: number;
         count: number;
@@ -2257,12 +2287,14 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
         concurrent?: boolean;
         seed: number;
     };
-    typecheck: TypecheckConfig;
+    typecheck: Omit<TypecheckConfig, 'enabled'> & {
+        enabled: boolean;
+    };
     runner?: string;
 }
-type ProjectConfig = Omit<UserConfig, 'sequencer' | 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'pool' | 'poolOptions' | 'teardownTimeout' | 'silent' | 'watchExclude' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'deps' | 'coverage'> & {
+type ProjectConfig = Omit<UserConfig, 'sequencer' | 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'pool' | 'poolOptions' | 'teardownTimeout' | 'silent' | 'watchExclude' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'onStackTrace' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'deps' | 'coverage'> & {
     sequencer?: Omit<SequenceOptions, 'sequencer' | 'seed'>;
-    deps?: Omit<DepsOptions, 'registerNodeLoader' | 'moduleDirectories'>;
+    deps?: Omit<DepsOptions, 'moduleDirectories'>;
 };
 type RuntimeConfig = Pick<UserConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency'> & {
     sequence?: {
@@ -2362,4 +2394,4 @@ type Context = RootAndTarget & {
     lastActivePath?: string;
 };
 
-export { type Nullable as $, type AfterSuiteRunMeta as A, type BaseCoverageOptions as B, type CoverageV8Options as C, type DepsOptimizationOptions as D, type Environment as E, type FakeTimerInstallOpts as F, type TypecheckConfig as G, type HappyDOMOptions as H, type InlineConfig as I, type JSDOMOptions as J, type RuntimeRPC as K, type RunnerRPC as L, type MockFactoryWithHelper as M, type ContextTestEnvironment as N, type ResolvedTestEnvironment as O, type ProjectConfig as P, type ContextRPC as Q, type ResolvedConfig as R, type WorkerContext as S, type TestSequencer as T, type UserConfig as U, type VitestRunMode as V, type WorkspaceSpec as W, type ResolveIdFunction as X, type WorkerRPC as Y, type WorkerGlobalState as Z, type Awaitable as _, type ResolvedCoverageOptions as a, type Arrayable as a0, type ArgumentsType$1 as a1, type MutableArray as a2, type Constructable as a3, type ModuleCache as a4, type EnvironmentReturn as a5, type VmEnvironmentReturn as a6, type OnServerRestartHandler as a7, type ReportContext as a8, type CoverageReporter as a9, type CoverageIstanbulOptions as aa, type CustomProviderOptions as ab, type BenchmarkUserOptions as ac, type Benchmark as ad, type BenchmarkResult as ae, type BenchFunction as af, type BenchmarkAPI as ag, type PendingSuiteMock as ah, type MockFactory as ai, type MockMap as aj, DefaultReporter as ak, BasicReporter as al, DotReporter as am, JsonReporter$1 as an, VerboseReporter as ao, TapReporter as ap, JUnitReporter as aq, TapFlatReporter as ar, HangingProcessReporter as as, BaseReporter as at, ReportersMap as au, type BuiltinReporters as av, BenchmarkReportsMap as aw, type BenchmarkBuiltinReporters as ax, Vitest as b, WorkspaceProject as c, type TestSequencerConstructor as d, type CoverageOptions as e, type CoverageProvider as f, type CoverageProviderModule as g, type RuntimeConfig as h, type UserConsoleLog as i, type ModuleGraphData as j, type Reporter as k, type RawErrsMap as l, type TscErrorInfo as m, type CollectLineNumbers as n, type CollectLines as o, type RootAndTarget as p, type Context as q, type Pool as r, startVitest as s, type PoolOptions as t, type BuiltinEnvironment as u, type VitestEnvironment as v, type CSSModuleScopeStrategy as w, type ApiConfig as x, type EnvironmentOptions as y, type TransformModePatterns as z };
+export { type WorkerRPC as $, type AfterSuiteRunMeta as A, type BaseCoverageOptions as B, type CoverageV8Options as C, type ApiConfig as D, type Environment as E, type FakeTimerInstallOpts as F, type EnvironmentOptions as G, type HappyDOMOptions as H, type DepsOptimizationOptions as I, type JSDOMOptions as J, type TransformModePatterns as K, type InlineConfig as L, type MockFactoryWithHelper as M, type TypecheckConfig as N, type RuntimeRPC as O, type ProjectConfig as P, type RunnerRPC as Q, type ResolvedConfig as R, type ContextTestEnvironment as S, type TestSequencer as T, type UserConfig as U, type VitestRunMode as V, type WorkspaceSpec as W, type ResolvedTestEnvironment as X, type ContextRPC as Y, type WorkerContext as Z, type ResolveIdFunction as _, type ResolvedCoverageOptions as a, type WorkerGlobalState as a0, type Awaitable as a1, type Nullable as a2, type Arrayable as a3, type ArgumentsType$1 as a4, type MutableArray as a5, type Constructable as a6, type ModuleCache as a7, type EnvironmentReturn as a8, type VmEnvironmentReturn as a9, type BenchmarkBuiltinReporters as aA, type OnServerRestartHandler as aa, type ReportContext as ab, type CoverageReporter as ac, type CoverageIstanbulOptions as ad, type CustomProviderOptions as ae, type BenchmarkUserOptions as af, type Benchmark as ag, type BenchmarkResult as ah, type BenchFunction as ai, type BenchmarkAPI as aj, type PendingSuiteMock as ak, type MockFactory as al, type MockMap as am, DefaultReporter as an, BasicReporter as ao, DotReporter as ap, JsonReporter$1 as aq, VerboseReporter as ar, TapReporter as as, JUnitReporter as at, TapFlatReporter as au, HangingProcessReporter as av, BaseReporter as aw, ReportersMap as ax, type BuiltinReporters as ay, BenchmarkReportsMap as az, type CoverageOptions as b, type CoverageProvider as c, type CoverageProviderModule as d, Vitest as e, WorkspaceProject as f, type TestSequencerConstructor as g, type BrowserProviderInitializationOptions as h, type BrowserProvider as i, type BrowserProviderOptions as j, type RuntimeConfig as k, type UserConsoleLog as l, type ModuleGraphData as m, type Reporter as n, type RawErrsMap as o, type TscErrorInfo as p, type CollectLineNumbers as q, type CollectLines as r, startVitest as s, type RootAndTarget as t, type Context as u, type Pool as v, type PoolOptions as w, type BuiltinEnvironment as x, type VitestEnvironment as y, type CSSModuleScopeStrategy as z };

package/dist/reporters.d.ts

@@ -1,4 +1,4 @@
-export { at as BaseReporter, al as BasicReporter, ax as BenchmarkBuiltinReporters, aw as BenchmarkReportsMap, av as BuiltinReporters, ak as DefaultReporter, am as DotReporter, as as HangingProcessReporter, aq as JUnitReporter, an as JsonReporter, k as Reporter, au as ReportersMap, ar as TapFlatReporter, ap as TapReporter, ao as VerboseReporter } from './reporters-d10f25e1.js';
+export { aw as BaseReporter, ao as BasicReporter, aA as BenchmarkBuiltinReporters, az as BenchmarkReportsMap, ay as BuiltinReporters, an as DefaultReporter, ap as DotReporter, av as HangingProcessReporter, at as JUnitReporter, aq as JsonReporter, n as Reporter, ax as ReportersMap, au as TapFlatReporter, as as TapReporter, ar as VerboseReporter } from './reporters-1678fe04.js';
 import 'vite';
 import '@vitest/runner';
 import 'vite-node';

package/dist/reporters.js

@@ -1,4 +1,4 @@
-export { f as BasicReporter, B as BenchmarkReportsMap, D as DefaultReporter, g as DotReporter, H as HangingProcessReporter, h as JUnitReporter, J as JsonReporter, R as ReportersMap, i as TapFlatReporter, T as TapReporter, V as VerboseReporter } from './vendor-reporters.2953082e.js';
+export { f as BasicReporter, B as BenchmarkReportsMap, D as DefaultReporter, g as DotReporter, H as HangingProcessReporter, h as JUnitReporter, J as JsonReporter, R as ReportersMap, i as TapFlatReporter, T as TapReporter, V as VerboseReporter } from './vendor-reporters.b9600369.js';
 import 'node:perf_hooks';
 import 'picocolors';
 import './vendor-index.29282562.js';

package/dist/runners.d.ts

@@ -1,12 +1,12 @@
 import { VitestRunner, VitestRunnerImportSource, Suite, Test, CancelReason, Custom, TaskContext, ExtendedContext } from '@vitest/runner';
-import { R as ResolvedConfig } from './reporters-d10f25e1.js';
+import { R as ResolvedConfig } from './reporters-1678fe04.js';
+import * as tinybench from 'tinybench';
 import 'vite';
 import 'vite-node';
 import '@vitest/snapshot';
 import '@vitest/expect';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import 'tinybench';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
@@ -39,6 +39,7 @@ declare class NodeBenchmarkRunner implements VitestRunner {
     config: ResolvedConfig;
     private __vitest_executor;
     constructor(config: ResolvedConfig);
+    importTinybench(): Promise<typeof tinybench>;
     importFile(filepath: string, source: VitestRunnerImportSource): unknown;
     runSuite(suite: Suite): Promise<void>;
     runTask(): Promise<void>;

package/dist/runners.js

@@ -127,11 +127,6 @@ function clearModuleMocks(config) {
     vi.unstubAllGlobals();
 }
 
-async function importTinybench() {
-  if (!globalThis.EventTarget)
-    await import('./vendor-index.98139333.js').then(function (n) { return n.i; });
-  return await import('tinybench');
-}
 function createBenchmarkResult(name) {
   return {
     name,
@@ -143,7 +138,7 @@ function createBenchmarkResult(name) {
 const benchmarkTasks = /* @__PURE__ */ new WeakMap();
 async function runBenchmarkSuite(suite, runner) {
   var _a;
-  const { Task, Bench } = await importTinybench();
+  const { Task, Bench } = await runner.importTinybench();
   const start = performance.now();
   const benchmarkGroup = [];
   const benchmarkSuiteGroup = [];
@@ -159,14 +154,30 @@ async function runBenchmarkSuite(suite, runner) {
     await Promise.all(benchmarkSuiteGroup.map((subSuite) => runBenchmarkSuite(subSuite, runner)));
   if (benchmarkGroup.length) {
     const defer = createDefer();
-    const benchmarkMap = {};
     suite.result = {
       state: "run",
       startTime: start,
       benchmark: createBenchmarkResult(suite.name)
     };
     updateTask$1(suite);
-    benchmarkGroup.forEach((benchmark, idx) => {
+    const addBenchTaskListener = (task, benchmark) => {
+      task.addEventListener("complete", (e) => {
+        const task2 = e.task;
+        const taskRes = task2.result;
+        const result = benchmark.result.benchmark;
+        Object.assign(result, taskRes);
+        updateTask$1(benchmark);
+      }, {
+        once: true
+      });
+      task.addEventListener("error", (e) => {
+        const task2 = e.task;
+        defer.reject(benchmark ? task2.result.error : e);
+      }, {
+        once: true
+      });
+    };
+    benchmarkGroup.forEach((benchmark) => {
       const options = getBenchOptions(benchmark);
       const benchmarkInstance = new Bench(options);
       const benchmarkFn = getBenchFn(benchmark);
@@ -175,43 +186,26 @@ async function runBenchmarkSuite(suite, runner) {
         startTime: start,
         benchmark: createBenchmarkResult(benchmark.name)
       };
-      const id = idx.toString();
-      benchmarkMap[id] = benchmark;
-      const task = new Task(benchmarkInstance, id, benchmarkFn);
+      const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
       benchmarkTasks.set(benchmark, task);
+      addBenchTaskListener(task, benchmark);
       updateTask$1(benchmark);
     });
-    benchmarkGroup.forEach((benchmark) => {
-      const task = benchmarkTasks.get(benchmark);
-      task.addEventListener("complete", (e) => {
-        const task2 = e.task;
-        const _benchmark = benchmarkMap[task2.name || ""];
-        if (_benchmark) {
-          const taskRes = task2.result;
-          const result = _benchmark.result.benchmark;
-          Object.assign(result, taskRes);
-          updateTask$1(_benchmark);
-        }
-      });
-      task.addEventListener("error", (e) => {
-        const task2 = e.task;
-        const _benchmark = benchmarkMap[task2.name || ""];
-        defer.reject(_benchmark ? task2.result.error : e);
-      });
-    });
+    const { setTimeout } = getSafeTimers();
     const tasks = [];
     for (const benchmark of benchmarkGroup) {
       const task = benchmarkTasks.get(benchmark);
       await task.warmup();
-      const { setTimeout } = getSafeTimers();
-      tasks.push(await new Promise((resolve) => setTimeout(async () => {
-        resolve(await task.run());
-      })));
+      tasks.push([
+        await new Promise((resolve) => setTimeout(async () => {
+          resolve(await task.run());
+        })),
+        benchmark
+      ]);
     }
     suite.result.duration = performance.now() - start;
     suite.result.state = "pass";
-    tasks.sort((a, b) => a.result.mean - b.result.mean).forEach((cycle, idx) => {
-      const benchmark = benchmarkMap[cycle.name || ""];
+    tasks.sort(([taskA], [taskB]) => taskA.result.mean - taskB.result.mean).forEach(([, benchmark], idx) => {
       benchmark.result.state = "pass";
       if (benchmark) {
         const result = benchmark.result.benchmark;
@@ -232,6 +226,9 @@ class NodeBenchmarkRunner {
     this.config = config;
   }
   __vitest_executor;
+  async importTinybench() {
+    return await import('tinybench');
+  }
   importFile(filepath, source) {
     if (source === "setup")
       getWorkerState().moduleCache.delete(filepath);

package/dist/{suite-919dd548.d.ts → suite-0579b50d.d.ts}

@@ -1,6 +1,6 @@
 import { Custom } from '@vitest/runner';
 import '@vitest/runner/utils';
-import { af as BenchFunction, ag as BenchmarkAPI } from './reporters-d10f25e1.js';
+import { ai as BenchFunction, aj as BenchmarkAPI } from './reporters-1678fe04.js';
 import { Options } from 'tinybench';
 
 declare function getBenchOptions(key: Custom): Options;

package/dist/suite.d.ts

@@ -1,7 +1,7 @@
 export { createTaskCollector, getCurrentSuite, getFn, setFn } from '@vitest/runner';
 export { createChainable } from '@vitest/runner/utils';
-export { g as getBenchFn, a as getBenchOptions } from './suite-919dd548.js';
-import './reporters-d10f25e1.js';
+export { g as getBenchFn, a as getBenchOptions } from './suite-0579b50d.js';
+import './reporters-1678fe04.js';
 import 'vite';
 import 'vite-node';
 import '@vitest/snapshot';

package/dist/{vendor-environments.094f240c.js → vendor-environments.dcc4a34e.js}

@@ -1,6 +1,3 @@
-import { resolve, normalize } from 'pathe';
-import { r as resolvePath } from './vendor-index.0b5b3600.js';
-import { ViteNodeRunner } from 'vite-node/client';
 import { Console } from 'node:console';
 import { importModule } from 'local-pkg';
 
@@ -479,7 +476,9 @@ var jsdom = {
       "Response",
       "BroadcastChannel",
       "MessageChannel",
-      "MessagePort"
+      "MessagePort",
+      "TextEncoder",
+      "TextDecoder"
     ];
     for (const name of globalNames) {
       const value = globalThis[name];
@@ -646,9 +645,6 @@ const envPackageNames = {
   "happy-dom": "happy-dom",
   "edge-runtime": "@edge-runtime/vm"
 };
-function isBuiltinEnvironment(env) {
-  return env in environments;
-}
 function getEnvPackageName(env) {
   if (env === "node")
     return null;
@@ -658,34 +654,5 @@ function getEnvPackageName(env) {
     return null;
   return `vitest-environment-${env}`;
 }
-const _loaders = /* @__PURE__ */ new Map();
-async function createEnvironmentLoader(options) {
-  if (!_loaders.has(options.root)) {
-    const loader = new ViteNodeRunner(options);
-    await loader.executeId("/@vite/env");
-    _loaders.set(options.root, loader);
-  }
-  return _loaders.get(options.root);
-}
-async function loadEnvironment(name, options) {
-  if (isBuiltinEnvironment(name))
-    return environments[name];
-  const loader = await createEnvironmentLoader(options);
-  const root = loader.root;
-  const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : await resolvePath(`vitest-environment-${name}`, { url: [root] }) ?? resolve(root, name);
-  const pkg = await loader.executeId(normalize(packageId));
-  if (!pkg || !pkg.default || typeof pkg.default !== "object") {
-    throw new TypeError(
-      `Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`
-    );
-  }
-  const environment = pkg.default;
-  if (environment.transformMode !== "web" && environment.transformMode !== "ssr") {
-    throw new TypeError(
-      `Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web".`
-    );
-  }
-  return environment;
-}
 
-export { environments as e, getEnvPackageName as g, loadEnvironment as l, populateGlobal as p };
+export { environments as e, getEnvPackageName as g, populateGlobal as p };

package/dist/{vendor-execute.07d1a420.js → vendor-execute.e6e4e89b.js}

@@ -1009,6 +1009,7 @@ async function startVitestExecutor(options) {
     }
     rpc().onUnhandledError(error, type);
   }
+  process.setMaxListeners(25);
   process.on("uncaughtException", (e) => catchError(e, "Uncaught Exception"));
   process.on("unhandledRejection", (e) => catchError(e, "Unhandled Rejection"));
   const getTransformMode = () => {

package/dist/{vendor-index.d36f5516.js → vendor-index.3d079eea.js}

@@ -68,8 +68,13 @@ async function resolveTestRunner(config, executor) {
   };
   const originalOnAfterRun = testRunner.onAfterRunFiles;
   testRunner.onAfterRunFiles = async (files) => {
+    const state = getWorkerState();
     const coverage = await takeCoverageInsideWorker(config.coverage, executor);
-    rpc().onAfterSuiteRun({ coverage });
+    rpc().onAfterSuiteRun({
+      coverage,
+      transformMode: state.environment.transformMode,
+      projectName: state.ctx.projectName
+    });
     await (originalOnAfterRun == null ? void 0 : originalOnAfterRun.call(testRunner, files));
   };
   const originalOnAfterRunTask = testRunner.onAfterRunTask;