vitest 2.1.0-beta.4 → 2.1.0-beta.6

package/dist/chunks/{resolveConfig.CGobt8AB.js → resolveConfig.C0vpvVRF.js}

@@ -9,7 +9,7 @@ import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
 import c from 'tinyrainbow';
-import { e as extraInlineDeps, d as defaultPort, a as defaultBrowserPort, b as defaultInspectPort } from './constants.CaAN7icJ.js';
+import { e as extraInlineDeps, d as defaultPort, a as defaultBrowserPort, b as defaultInspectPort } from './constants.fzPh7AOq.js';
 import * as nodeos from 'node:os';
 import nodeos__default from 'node:os';
 import { i as isWindows } from './env.CmHVDJnw.js';
@@ -18,7 +18,7 @@ import { hasFailed } from '@vitest/runner/utils';
 import { b as groupBy, A as AggregateErrorPonyfill, a as slash, t as toArray } from './base.BH-FAiX7.js';
 import { createDefer } from '@vitest/utils';
 import crypto, { createHash } from 'node:crypto';
-import { w as wrapSerializableConfig, T as Typechecker, R as RandomSequencer, B as BaseSequencer } from './RandomSequencer.B4M2ux5b.js';
+import { w as wrapSerializableConfig, T as Typechecker, R as RandomSequencer, B as BaseSequencer } from './RandomSequencer.CjkAy_bL.js';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import require$$0 from 'util';
 import p from 'path';
@@ -4010,7 +4010,9 @@ function getTransformMode(patterns, filename) {
 }
 async function groupFilesByEnv(files) {
   const filesWithEnv = await Promise.all(
-    files.map(async ([project, file]) => {
+    files.map(async (spec) => {
+      const file = spec.moduleId;
+      const project = spec.project.workspaceProject;
       const code = await promises$1.readFile(file, "utf-8");
       let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
       if (!env) {
@@ -4237,16 +4239,18 @@ function createForksPool(ctx, { execArgv, env }) {
         return config;
       };
       const workspaceMap = /* @__PURE__ */ new Map();
-      for (const [project, file] of specs) {
+      for (const spec of specs) {
+        const file = spec.moduleId;
+        const project = spec.project.workspaceProject;
         const workspaceFiles = workspaceMap.get(file) ?? [];
         workspaceFiles.push(project);
         workspaceMap.set(file, workspaceFiles);
       }
       const singleFork = specs.filter(
-        ([project]) => project.config.poolOptions?.forks?.singleFork
+        (spec) => spec.project.config.poolOptions?.forks?.singleFork
       );
       const multipleForks = specs.filter(
-        ([project]) => !project.config.poolOptions?.forks?.singleFork
+        (spec) => !spec.project.config.poolOptions?.forks?.singleFork
       );
       if (multipleForks.length) {
         const filesByEnv = await groupFilesByEnv(multipleForks);
@@ -4439,10 +4443,10 @@ See https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for t
         workspaceMap.set(file, workspaceFiles);
       }
       const singleThreads = specs.filter(
-        ([project]) => project.config.poolOptions?.threads?.singleThread
+        (spec) => spec.project.config.poolOptions?.threads?.singleThread
       );
       const multipleThreads = specs.filter(
-        ([project]) => !project.config.poolOptions?.threads?.singleThread
+        (spec) => !spec.project.config.poolOptions?.threads?.singleThread
       );
       if (multipleThreads.length) {
         const filesByEnv = await groupFilesByEnv(multipleThreads);
@@ -4740,7 +4744,7 @@ function getMemoryLimit$1(config) {
 
 function createTypecheckPool(ctx) {
   const promisesMap = /* @__PURE__ */ new WeakMap();
-  const rerunTriggered = /* @__PURE__ */ new WeakMap();
+  const rerunTriggered = /* @__PURE__ */ new WeakSet();
   async function onParseEnd(project, { files, sourceErrors }) {
     const checker = project.typechecker;
     await ctx.report("onTaskUpdate", checker.getTestPacks());
@@ -4756,7 +4760,7 @@ function createTypecheckPool(ctx) {
       ctx.state.catchError(error, "Typecheck Error");
     }
     promisesMap.get(project)?.resolve();
-    rerunTriggered.set(project, false);
+    rerunTriggered.delete(project);
     if (ctx.config.watch && !ctx.runningPromise) {
       await ctx.report("onFinished", files, []);
       await ctx.report("onWatcherStart", files, [
@@ -4778,7 +4782,7 @@ function createTypecheckPool(ctx) {
     });
     checker.onParseEnd((result) => onParseEnd(project, result));
     checker.onWatcherRerun(async () => {
-      rerunTriggered.set(project, true);
+      rerunTriggered.add(project);
       if (!ctx.runningPromise) {
         ctx.state.clearErrors();
         await ctx.report(
@@ -4804,19 +4808,19 @@ function createTypecheckPool(ctx) {
     await checker.start();
   }
   async function collectTests(specs) {
-    const specsByProject = groupBy(specs, ([project]) => project.getName());
+    const specsByProject = groupBy(specs, (spec) => spec.project.name);
     for (const name in specsByProject) {
-      const project = specsByProject[name][0][0];
-      const files = specsByProject[name].map(([_, file]) => file);
-      const checker = await createWorkspaceTypechecker(project, files);
+      const project = specsByProject[name][0].project;
+      const files = specsByProject[name].map((spec) => spec.moduleId);
+      const checker = await createWorkspaceTypechecker(project.workspaceProject, files);
       checker.setFiles(files);
       await checker.collectTests();
-      ctx.state.collectFiles(project, checker.getTestFiles());
+      ctx.state.collectFiles(project.workspaceProject, checker.getTestFiles());
       await ctx.report("onCollected");
     }
   }
   async function runTests(specs) {
-    const specsByProject = groupBy(specs, ([project]) => project.getName());
+    const specsByProject = groupBy(specs, (spec) => spec.project.name);
     const promises = [];
     for (const name in specsByProject) {
       const project = specsByProject[name][0][0];
@@ -4824,7 +4828,7 @@ function createTypecheckPool(ctx) {
       const promise = createDefer();
       const _p = new Promise((resolve) => {
         const _i = setInterval(() => {
-          if (!project.typechecker || rerunTriggered.get(project)) {
+          if (!project.typechecker || rerunTriggered.has(project)) {
             resolve(true);
             clearInterval(_i);
           }
@@ -5013,14 +5017,7 @@ const builtinPools = [
   "vmForks",
   "typescript"
 ];
-function getDefaultPoolName(project, file) {
-  if (project.config.typecheck.enabled) {
-    for (const glob of project.config.typecheck.include) {
-      if (mm.isMatch(file, glob, { cwd: project.config.root })) {
-        return "typescript";
-      }
-    }
-  }
+function getDefaultPoolName(project) {
   if (project.config.browser.enabled) {
     return "browser";
   }
@@ -5037,7 +5034,7 @@ function getFilePoolName(project, file) {
       return pool;
     }
   }
-  return getDefaultPoolName(project, file);
+  return getDefaultPoolName(project);
 }
 function createPool(ctx) {
   const pools = {
@@ -5122,7 +5119,7 @@ function createPool(ctx) {
       typescript: () => createTypecheckPool(ctx)
     };
     for (const spec of files) {
-      const pool = getFilePoolName(spec[0], spec[1]);
+      const { pool } = spec[2];
       filesByPool[pool] ??= [];
       filesByPool[pool].push(spec);
     }
@@ -7337,6 +7334,7 @@ const coverageConfigDefaults = {
     ".marko"
   ],
   allowExternal: false,
+  excludeAfterRemap: false,
   ignoreEmptyLines: true,
   processingConcurrency: Math.min(
     20,
@@ -7612,6 +7610,7 @@ function resolveConfig(mode, options, viteConfig, logger) {
     root: viteConfig.root,
     mode
   };
+  resolved.provide ??= {};
   const inspector = resolved.inspect || resolved.inspectBrk;
   resolved.inspector = {
     ...resolved.inspector,
@@ -7668,10 +7667,21 @@ function resolveConfig(mode, options, viteConfig, logger) {
       );
     }
   }
-  if (resolved.coverage.provider === "v8" && resolved.coverage.enabled && isBrowserEnabled(resolved)) {
-    throw new Error(
-      "@vitest/coverage-v8 does not work with --browser. Use @vitest/coverage-istanbul instead"
-    );
+  if (resolved.browser.enabled && resolved.coverage.enabled && resolved.coverage.provider === "v8") {
+    if (!(resolved.browser.provider === "playwright" && resolved.browser.name === "chromium")) {
+      const browserConfig = { browser: { provider: resolved.browser.provider, name: resolved.browser.name } };
+      throw new Error(
+        `@vitest/coverage-v8 does not work with
+${JSON.stringify(browserConfig, null, 2)}
+
+Use either:
+${JSON.stringify({ browser: { provider: "playwright", name: "chromium" } }, null, 2)}
+
+...or change your coverage provider to:
+${JSON.stringify({ coverage: { provider: "istanbul" } }, null, 2)}
+`
+      );
+    }
   }
   resolved.coverage.reporter = resolveCoverageReporters(resolved.coverage.reporter);
   if (resolved.coverage.enabled && resolved.coverage.reportsDirectory) {
@@ -8117,4 +8127,4 @@ function resolveCoverageReporters(configReporters) {
   return resolvedReporters;
 }
 
-export { VitestCache as V, resolveConfig as a, resolveCoverageReporters as b, createMethodsRPC as c, braces_1 as d, configDefaults as e, isPackageExists as f, getFilePoolName as g, createPool as h, isBrowserEnabled as i, coverageConfigDefaults as j, mm as m, picomatch$1 as p, resolveApiServerConfig as r, utils$4 as u };
+export { VitestCache as V, resolveApiServerConfig as a, resolveConfig as b, createMethodsRPC as c, braces_1 as d, configDefaults as e, isPackageExists as f, getFilePoolName as g, createPool as h, isBrowserEnabled as i, coverageConfigDefaults as j, mm as m, picomatch$1 as p, resolveCoverageReporters as r, utils$4 as u };

package/dist/chunks/{runBaseTests.BAhL8UH_.js → runBaseTests.Cf8lGnUq.js}

@@ -5,16 +5,16 @@ import '@vitest/runner/utils';
 import { getSafeTimers } from '@vitest/utils';
 import { g as getWorkerState } from './utils.Ck2hJTRs.js';
 import './env.CmHVDJnw.js';
-import { a as globalExpect, r as resetModules, v as vi } from './vi.B6QZ938s.js';
-import { a as startCoverageInsideWorker, s as stopCoverageInsideWorker } from './coverage.CqfT4xaf.js';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.CxWPpGJz.js';
+import { a as globalExpect, r as resetModules, v as vi } from './vi.DBepMgvg.js';
+import { a as startCoverageInsideWorker, s as stopCoverageInsideWorker } from './coverage.zlNdAMHK.js';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.dWDhoZDV.js';
 import { createRequire } from 'node:module';
 import util from 'node:util';
 import timers from 'node:timers';
 import { installSourcemapsSupport } from 'vite-node/source-map';
 import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
-import { V as VitestIndex } from './index.CNZXZ9PJ.js';
-import { s as setupCommonEnv } from './setup-common.KBrCO5LJ.js';
+import { V as VitestIndex } from './index.m3Xip5Zz.js';
+import { s as setupCommonEnv } from './setup-common.B7uEQsGB.js';
 import { c as closeInspector } from './inspector.70d6emsh.js';
 import 'std-env';
 import 'chai';

package/dist/chunks/{setup-common.KBrCO5LJ.js → setup-common.B7uEQsGB.js}

@@ -13,7 +13,7 @@ async function setupCommonEnv(config) {
   globalSetup = true;
   setSafeTimers();
   if (config.globals) {
-    (await import('./globals.DRPLtPOv.js')).registerApiGlobally();
+    (await import('./globals.Br36EZIp.js')).registerApiGlobally();
   }
 }
 function setupDefines(defines) {

package/dist/chunks/{vi.B6QZ938s.js → vi.DBepMgvg.js}

@@ -3228,6 +3228,11 @@ class FakeTimers {
       await this._clock.tickAsync(msToRun);
     }
   }
+  advanceTimersToNextFrame() {
+    if (this._checkFakeTimers()) {
+      this._clock.runToFrame();
+    }
+  }
   runAllTicks() {
     if (this._checkFakeTimers()) {
       this._clock.runMicrotasks();
@@ -3555,6 +3560,10 @@ function createVitest() {
       await timers().advanceTimersToNextTimerAsync();
       return utils;
     },
+    advanceTimersToNextFrame() {
+      timers().advanceTimersToNextFrame();
+      return utils;
+    },
     getTimerCount() {
       return timers().getTimerCount();
     },

package/dist/chunks/vite.Bvz2vSw0.d.ts

@@ -0,0 +1,11 @@
+import { I as InlineConfig } from './reporters.B0Ao6Zu1.js';
+
+type VitestInlineConfig = InlineConfig;
+declare module 'vite' {
+    interface UserConfig {
+        /**
+         * Options for Vitest
+         */
+        test?: VitestInlineConfig;
+    }
+}

package/dist/chunks/{worker.BANO5ak1.d.ts → worker.CTdJUeeB.d.ts}

@@ -2,9 +2,10 @@ import { FetchResult, ViteNodeResolveId, RawSourceMap, ModuleCacheMap } from 'vi
 import { File, TaskResultPack, CancelReason, Task } from '@vitest/runner';
 import { S as SerializedConfig } from './config.CHuotKvS.js';
 import { SnapshotResult } from '@vitest/snapshot';
-import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.0M5R1SX_.js';
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.C5eAp3K6.js';
 
-type MockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M>() => Promise<T>) => any;
+type Promisable<T> = T | Promise<T>;
+type MockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M = M>() => Promise<T>) => Promisable<Partial<M>>;
 type MockFactory = () => any;
 type MockMap = Map<string, Record<string, string | null | MockFactory>>;
 interface PendingSuiteMock {

package/dist/chunks/{worker.Cx2xE71X.d.ts → worker.DTM-0OlZ.d.ts}

@@ -1,5 +1,5 @@
 import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.BANO5ak1.js';
+import { C as ContextRPC } from './worker.CTdJUeeB.js';
 
 interface WorkerContext extends ContextRPC {
     port: MessagePort;

package/dist/cli.js

@@ -1,9 +1,9 @@
-import { c as createCLI } from './chunks/cac.C8rwFluK.js';
+import { c as createCLI } from './chunks/cac.BZlOqtiQ.js';
 import 'pathe';
 import 'events';
 import 'tinyrainbow';
 import './chunks/base.BH-FAiX7.js';
 import '@vitest/utils';
-import './chunks/constants.CaAN7icJ.js';
+import './chunks/constants.fzPh7AOq.js';
 
 createCLI().parse();

package/dist/config.cjs

@@ -71,6 +71,7 @@ const coverageConfigDefaults = {
     ".marko"
   ],
   allowExternal: false,
+  excludeAfterRemap: false,
   ignoreEmptyLines: true,
   processingConcurrency: Math.min(
     20,

package/dist/config.d.ts

@@ -1,12 +1,14 @@
-export { ap as UserConfigExport, ao as UserConfigFn, am as UserConfigFnObject, an as UserConfigFnPromise, ar as UserProjectConfigExport, aq as UserProjectConfigFn, z as UserWorkspaceConfig, aw as configDefaults, az as coverageConfigDefaults, av as defaultBrowserPort, ay as defaultExclude, ax as defaultInclude, as as defineConfig, at as defineProject, au as defineWorkspace, aA as extraInlineDeps } from './chunks/reporters.DRZ7ndzr.js';
+import './chunks/vite.Bvz2vSw0.js';
+import { ConfigEnv, UserConfig } from 'vite';
 export { ConfigEnv, Plugin, UserConfig, mergeConfig } from 'vite';
+import { R as ResolvedCoverageOptions, b as CoverageV8Options, U as UserWorkspaceConfig, c as UserProjectConfigFn, d as UserProjectConfigExport, W as WorkspaceProjectConfiguration } from './chunks/reporters.B0Ao6Zu1.js';
 import '@vitest/runner';
 import '@vitest/pretty-format';
 import './chunks/config.CHuotKvS.js';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
 import 'vite-node';
-import './chunks/environment.0M5R1SX_.js';
+import './chunks/environment.C5eAp3K6.js';
 import 'node:stream';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
@@ -18,3 +20,69 @@ import 'chai';
 import './chunks/benchmark.puBFxyfE.js';
 import '@vitest/runner/utils';
 import 'tinybench';
+
+declare const defaultBrowserPort = 63315;
+declare const extraInlineDeps: RegExp[];
+
+declare const defaultInclude: string[];
+declare const defaultExclude: string[];
+declare const coverageConfigDefaults: ResolvedCoverageOptions;
+declare const configDefaults: Readonly<{
+    allowOnly: boolean;
+    isolate: true;
+    watch: boolean;
+    globals: false;
+    environment: "node";
+    pool: "forks";
+    clearMocks: false;
+    restoreMocks: false;
+    mockReset: false;
+    unstubGlobals: false;
+    unstubEnvs: false;
+    include: string[];
+    exclude: string[];
+    teardownTimeout: number;
+    forceRerunTriggers: string[];
+    update: false;
+    reporters: never[];
+    silent: false;
+    hideSkippedTests: false;
+    api: false;
+    ui: false;
+    uiBase: string;
+    open: boolean;
+    css: {
+        include: never[];
+    };
+    coverage: CoverageV8Options;
+    fakeTimers: {
+        loopLimit: number;
+        shouldClearNativeTimers: true;
+        toFake: ("setTimeout" | "setInterval" | "clearInterval" | "clearTimeout" | "setImmediate" | "clearImmediate" | "Date")[];
+    };
+    maxConcurrency: number;
+    dangerouslyIgnoreUnhandledErrors: false;
+    typecheck: {
+        checker: "tsc";
+        include: string[];
+        exclude: string[];
+    };
+    slowTestThreshold: number;
+    disableConsoleIntercept: false;
+}>;
+
+type UserConfigFnObject = (env: ConfigEnv) => UserConfig;
+type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
+type UserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
+type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
+declare function defineConfig(config: UserConfig): UserConfig;
+declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+declare function defineProject(config: UserWorkspaceConfig): UserWorkspaceConfig;
+declare function defineProject(config: Promise<UserWorkspaceConfig>): Promise<UserWorkspaceConfig>;
+declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn;
+declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
+declare function defineWorkspace(config: WorkspaceProjectConfiguration[]): WorkspaceProjectConfiguration[];
+
+export { type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, WorkspaceProjectConfiguration, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };

package/dist/config.js

@@ -69,6 +69,7 @@ const coverageConfigDefaults = {
     ".marko"
   ],
   allowExternal: false,
+  excludeAfterRemap: false,
   ignoreEmptyLines: true,
   processingConcurrency: Math.min(
     20,

package/dist/coverage.d.ts

@@ -1,12 +1,12 @@
-import { B as BaseCoverageOptions, R as ResolvedCoverageOptions } from './chunks/reporters.DRZ7ndzr.js';
+import * as vite from 'vite';
+import { B as BaseCoverageOptions, R as ResolvedCoverageOptions, V as Vitest } from './chunks/reporters.B0Ao6Zu1.js';
 import '@vitest/runner';
-import 'vite';
 import '@vitest/pretty-format';
 import './chunks/config.CHuotKvS.js';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
 import 'vite-node';
-import './chunks/environment.0M5R1SX_.js';
+import './chunks/environment.C5eAp3K6.js';
 import 'node:stream';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
@@ -164,6 +164,7 @@ declare class BaseCoverageProvider {
     resolveReporters(configReporters: NonNullable<BaseCoverageOptions['reporter']>): ResolvedCoverageOptions['reporter'];
     hasTerminalReporter(reporters: ResolvedCoverageOptions['reporter']): boolean;
     toSlices<T>(array: T[], size: number): T[][];
+    createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<vite.TransformResult | null | undefined>;
 }
 
 export { BaseCoverageProvider };

package/dist/coverage.js

@@ -1,5 +1,5 @@
 import { relative } from 'pathe';
-import { m as mm, b as resolveCoverageReporters } from './chunks/resolveConfig.CGobt8AB.js';
+import { m as mm, r as resolveCoverageReporters } from './chunks/resolveConfig.C0vpvVRF.js';
 import 'node:path';
 import 'node:fs';
 import 'node:fs/promises';
@@ -10,7 +10,7 @@ import 'node:assert';
 import 'node:v8';
 import 'node:util';
 import 'tinyrainbow';
-import './chunks/constants.CaAN7icJ.js';
+import './chunks/constants.fzPh7AOq.js';
 import 'node:os';
 import './chunks/env.CmHVDJnw.js';
 import 'std-env';
@@ -18,7 +18,7 @@ import '@vitest/runner/utils';
 import './chunks/base.BH-FAiX7.js';
 import '@vitest/utils';
 import 'node:crypto';
-import './chunks/RandomSequencer.B4M2ux5b.js';
+import './chunks/RandomSequencer.CjkAy_bL.js';
 import 'node:perf_hooks';
 import 'execa';
 import '@vitest/utils/source-map';
@@ -212,6 +212,30 @@ class BaseCoverageProvider {
       return chunks;
     }, []);
   }
+  createUncoveredFileTransformer(ctx) {
+    const servers = [
+      ...ctx.projects.map((project) => ({
+        root: project.config.root,
+        vitenode: project.vitenode
+      })),
+      // Check core last as it will match all files anyway
+      { root: ctx.config.root, vitenode: ctx.vitenode }
+    ];
+    return async function transformFile(filename) {
+      let lastError;
+      for (const { root, vitenode } of servers) {
+        if (!filename.startsWith(root)) {
+          continue;
+        }
+        try {
+          return await vitenode.transformRequest(filename);
+        } catch (error) {
+          lastError = error;
+        }
+      }
+      throw lastError;
+    };
+  }
 }
 function resolveGlobThresholds(thresholds) {
   if (!thresholds || typeof thresholds !== "object") {

package/dist/environments.d.ts

@@ -1,5 +1,5 @@
-import { E as Environment } from './chunks/environment.0M5R1SX_.js';
-export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.0M5R1SX_.js';
+import { E as Environment } from './chunks/environment.C5eAp3K6.js';
+export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.C5eAp3K6.js';
 
 declare const environments: {
     node: Environment;

package/dist/execute.d.ts

@@ -1,13 +1,13 @@
 import vm from 'node:vm';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeRunnerOptions } from 'vite-node';
-import { P as PendingSuiteMock, f as MockFactory, R as RuntimeRPC, W as WorkerGlobalState, g as MockMap } from './chunks/worker.BANO5ak1.js';
+import { P as PendingSuiteMock, f as MockFactory, R as RuntimeRPC, W as WorkerGlobalState, g as MockMap } from './chunks/worker.CTdJUeeB.js';
 import '@vitest/runner';
 import './chunks/config.CHuotKvS.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
-import './chunks/environment.0M5R1SX_.js';
+import './chunks/environment.C5eAp3K6.js';
 
 type Key = string | symbol;
 interface MockContext {

package/dist/index.d.ts

@@ -1,23 +1,24 @@
-import { V as VitestEnvironment$1, S as SerializedSpec, b as RawErrsMap$1, T as TscErrorInfo$1, c as CollectLineNumbers$1, d as CollectLines$1, e as RootAndTarget$1, f as Context$1, C as CoverageProvider$1, g as ReportContext$1, a as CoverageProviderModule$1, h as CoverageReporter$1, i as CoverageProviderName, j as CoverageOptions$1, R as ResolvedCoverageOptions$1, B as BaseCoverageOptions$1, k as CoverageIstanbulOptions$1, l as CoverageV8Options$1, m as CustomProviderOptions$1, n as Reporter$1, o as Vitest$1, p as BrowserScript$1, q as BrowserConfigOptions$1, r as BuiltinEnvironment$1, P as Pool$1, s as PoolOptions$1, t as CSSModuleScopeStrategy$1, A as ApiConfig$1, u as VitestRunMode$1, D as DepsOptimizationOptions$1, v as TransformModePatterns$1, I as InlineConfig$1, w as TypecheckConfig$1, U as UserConfig$1, x as ResolvedConfig$1, y as ProjectConfig$1, z as UserWorkspaceConfig$1, E as BenchmarkUserOptions$1 } from './chunks/reporters.DRZ7ndzr.js';
+import './chunks/vite.Bvz2vSw0.js';
 import { Plugin } from '@vitest/pretty-format';
 import { SnapshotState } from '@vitest/snapshot';
 export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
 import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
 export { Assertion, AsymmetricMatchersContaining, ExpectPollOptions, ExpectStatic, JestAssertion } from '@vitest/expect';
+import { e as VitestEnvironment$1, S as SerializedSpec, f as RawErrsMap$1, T as TscErrorInfo$1, g as CollectLineNumbers$1, h as CollectLines$1, i as RootAndTarget$1, j as Context$1, C as CoverageProvider$1, k as ReportContext$1, a as CoverageProviderModule$1, l as CoverageReporter$1, m as CoverageProviderName, n as CoverageOptions$1, R as ResolvedCoverageOptions$1, B as BaseCoverageOptions$1, o as CoverageIstanbulOptions$1, b as CoverageV8Options$1, p as CustomProviderOptions$1, q as Reporter$1, V as Vitest$1, r as BrowserScript$1, s as BrowserConfigOptions$1, t as BuiltinEnvironment$1, P as Pool$1, u as PoolOptions$1, v as CSSModuleScopeStrategy$1, A as ApiConfig$1, w as VitestRunMode$1, D as DepsOptimizationOptions$1, x as TransformModePatterns$1, I as InlineConfig$1, y as TypecheckConfig$1, z as UserConfig$1, E as ResolvedConfig$1, F as ProjectConfig$1, U as UserWorkspaceConfig$1, G as BenchmarkUserOptions$1 } from './chunks/reporters.B0Ao6Zu1.js';
 import { B as BenchmarkResult } from './chunks/benchmark.puBFxyfE.js';
 export { b as BenchFunction, a as Benchmark, c as BenchmarkAPI } from './chunks/benchmark.puBFxyfE.js';
-import { U as UserConsoleLog, P as ProvidedContext, M as ModuleGraphData, b as Awaitable$1, N as Nullable$1, c as Arrayable$1, d as ArgumentsType$1, e as MutableArray$1, C as Constructable$1, O as OnServerRestartHandler$1, a as EnvironmentReturn$1, V as VmEnvironmentReturn$1, E as Environment$1, R as ResolvedTestEnvironment$1, J as JSDOMOptions$1, H as HappyDOMOptions$1, f as EnvironmentOptions$1 } from './chunks/environment.0M5R1SX_.js';
-export { A as AfterSuiteRunMeta, g as ModuleCache } from './chunks/environment.0M5R1SX_.js';
+import { U as UserConsoleLog, P as ProvidedContext, M as ModuleGraphData, b as Awaitable$1, N as Nullable$1, c as Arrayable$1, d as ArgumentsType$1, e as MutableArray$1, C as Constructable$1, O as OnServerRestartHandler$1, a as EnvironmentReturn$1, V as VmEnvironmentReturn$1, E as Environment$1, R as ResolvedTestEnvironment$1, J as JSDOMOptions$1, H as HappyDOMOptions$1, f as EnvironmentOptions$1 } from './chunks/environment.C5eAp3K6.js';
+export { A as AfterSuiteRunMeta, g as ModuleCache } from './chunks/environment.C5eAp3K6.js';
 import { TaskPopulated, TaskResultPack, File as File$1, Suite as Suite$1, Test as Test$1, Custom as Custom$1, Task as Task$1, SequenceHooks as SequenceHooks$1, SequenceSetupFiles as SequenceSetupFiles$1 } from '@vitest/runner';
 export { CancelReason, DoneCallback, ExtendedContext, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, Custom as RunnerCustomCase, Task as RunnerTask, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, RuntimeContext, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, TaskBase, TaskContext, TaskCustomOptions, TaskMeta, TaskResult, TaskResultPack, TaskState, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 export { b as bench } from './chunks/suite.CcK46U-P.js';
 import { F as FakeTimerInstallOpts, R as RuntimeOptions, S as SerializedConfig } from './chunks/config.CHuotKvS.js';
 export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.CHuotKvS.js';
-import { M as MockFactoryWithHelper, a as BirpcReturn } from './chunks/worker.BANO5ak1.js';
-export { C as ContextRPC, e as ContextTestEnvironment, c as ResolveIdFunction, b as RunnerRPC, R as RuntimeRPC, W as WorkerGlobalState, d as WorkerRPC } from './chunks/worker.BANO5ak1.js';
+import { M as MockFactoryWithHelper, a as BirpcReturn } from './chunks/worker.CTdJUeeB.js';
+export { C as ContextRPC, e as ContextTestEnvironment, c as ResolveIdFunction, b as RunnerRPC, R as RuntimeRPC, W as WorkerGlobalState, d as WorkerRPC } from './chunks/worker.CTdJUeeB.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
 export { Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject } from '@vitest/spy';
-export { W as WorkerContext } from './chunks/worker.Cx2xE71X.js';
+export { W as WorkerContext } from './chunks/worker.DTM-0OlZ.js';
 export { ErrorWithDiff, ParsedStack, SerializedError, TestError } from '@vitest/utils';
 export { DiffOptions } from '@vitest/utils/diff';
 import * as chai from 'chai';
@@ -1233,6 +1234,10 @@ interface VitestUtils {
      * Will call next available timer and wait until it's resolved if it was set asynchronously. Useful to make assertions between each timer call.
      */
     advanceTimersToNextTimerAsync: () => Promise<VitestUtils>;
+    /**
+     * Similar to [`vi.advanceTimersByTime`](https://vitest.dev/api/vi#vi-advancetimersbytime), but will advance timers by the milliseconds needed to execute callbacks currently scheduled with `requestAnimationFrame`.
+     */
+    advanceTimersToNextFrame: () => VitestUtils;
     /**
      * Get the number of waiting timers.
      */

package/dist/index.js

@@ -1,9 +1,9 @@
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 export { b as bench } from './chunks/benchmark.C8CRJYG4.js';
-import { d as dist } from './chunks/index.CNZXZ9PJ.js';
-export { a as assertType, g as getRunningMode, b as inject, i as isWatchMode } from './chunks/index.CNZXZ9PJ.js';
+import { d as dist } from './chunks/index.m3Xip5Zz.js';
+export { a as assertType, g as getRunningMode, b as inject, i as isWatchMode } from './chunks/index.m3Xip5Zz.js';
 export { i as isFirstRun, a as runOnce } from './chunks/run-once.Sxe67Wng.js';
-export { c as createExpect, a as expect, v as vi, b as vitest } from './chunks/vi.B6QZ938s.js';
+export { c as createExpect, a as expect, v as vi, b as vitest } from './chunks/vi.DBepMgvg.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';

package/dist/node.d.ts

@@ -1,15 +1,15 @@
-import { u as VitestRunMode, U as UserConfig, F as VitestOptions, o as Vitest, x as ResolvedConfig, W as WorkspaceProject, A as ApiConfig, L as Logger, G as TestSequencer, H as WorkspaceSpec } from './chunks/reporters.DRZ7ndzr.js';
-export { B as BaseCoverageOptions, E as BenchmarkUserOptions, $ as BrowserBuiltinProvider, a0 as BrowserCommand, a1 as BrowserCommandContext, q as BrowserConfigOptions, a5 as BrowserOrchestrator, Q as BrowserProvider, O as BrowserProviderInitializationOptions, Y as BrowserProviderModule, _ as BrowserProviderOptions, p as BrowserScript, a2 as BrowserServer, a3 as BrowserServerState, a4 as BrowserServerStateContext, r as BuiltinEnvironment, X as CDPSession, t as CSSModuleScopeStrategy, k as CoverageIstanbulOptions, j as CoverageOptions, C as CoverageProvider, a as CoverageProviderModule, h as CoverageReporter, l as CoverageV8Options, m as CustomProviderOptions, D as DepsOptimizationOptions, ag as FileDiagnostic, a8 as HTMLOptions, I as InlineConfig, a7 as JUnitOptions, a6 as JsonOptions, P as Pool, s as PoolOptions, J as ProcessPool, y as ProjectConfig, g as ReportContext, Z as ResolvedBrowserOptions, R as ResolvedCoverageOptions, al as ResolvedProjectConfig, ae as TaskOptions, a9 as TestCase, ad as TestCollection, af as TestDiagnostic, aa as TestFile, ac as TestProject, ah as TestResult, aj as TestResultFailed, ai as TestResultPassed, ak as TestResultSkipped, N as TestSequencerConstructor, ab as TestSuite, v as TransformModePatterns, c as TypeCheckCollectLineNumbers, d as TypeCheckCollectLines, f as TypeCheckContext, T as TypeCheckErrorInfo, b as TypeCheckRawErrorsMap, e as TypeCheckRootAndTarget, w as TypecheckConfig, z as UserWorkspaceConfig, V as VitestEnvironment, M as VitestPackageInstaller, K as getFilePoolName } from './chunks/reporters.DRZ7ndzr.js';
+import { w as VitestRunMode, z as UserConfig, H as VitestOptions, V as Vitest, E as ResolvedConfig, J as WorkspaceProject, A as ApiConfig, L as Logger, K as TestSequencer, M as WorkspaceSpec, N as TestModule, O as ModuleDiagnostic } from './chunks/reporters.B0Ao6Zu1.js';
+export { B as BaseCoverageOptions, G as BenchmarkUserOptions, a4 as BrowserBuiltinProvider, a5 as BrowserCommand, a6 as BrowserCommandContext, s as BrowserConfigOptions, aa as BrowserOrchestrator, $ as BrowserProvider, _ as BrowserProviderInitializationOptions, a1 as BrowserProviderModule, a3 as BrowserProviderOptions, r as BrowserScript, a7 as BrowserServer, a8 as BrowserServerState, a9 as BrowserServerStateContext, t as BuiltinEnvironment, a0 as CDPSession, v as CSSModuleScopeStrategy, o as CoverageIstanbulOptions, n as CoverageOptions, C as CoverageProvider, a as CoverageProviderModule, l as CoverageReporter, b as CoverageV8Options, p as CustomProviderOptions, D as DepsOptimizationOptions, ad as HTMLOptions, I as InlineConfig, ac as JUnitOptions, ab as JsonOptions, P as Pool, u as PoolOptions, Q as ProcessPool, F as ProjectConfig, k as ReportContext, a2 as ResolvedBrowserOptions, R as ResolvedCoverageOptions, ao as ResolvedProjectConfig, ai as TaskOptions, ae as TestCase, ah as TestCollection, aj as TestDiagnostic, ag as TestProject, ak as TestResult, am as TestResultFailed, al as TestResultPassed, an as TestResultSkipped, Z as TestSequencerConstructor, af as TestSuite, x as TransformModePatterns, g as TypeCheckCollectLineNumbers, h as TypeCheckCollectLines, j as TypeCheckContext, T as TypeCheckErrorInfo, f as TypeCheckRawErrorsMap, i as TypeCheckRootAndTarget, y as TypecheckConfig, U as UserWorkspaceConfig, e as VitestEnvironment, Y as VitestPackageInstaller, X as getFilePoolName } from './chunks/reporters.B0Ao6Zu1.js';
 import { UserConfig as UserConfig$1, Plugin, ResolvedConfig as ResolvedConfig$1 } from 'vite';
 import * as vite from 'vite';
 export { vite as Vite };
 export { createServer, isFileServingAllowed, parseAst, parseAstAsync } from 'vite';
 import { Writable } from 'node:stream';
-import { P as ProvidedContext } from './chunks/environment.0M5R1SX_.js';
-export { f as EnvironmentOptions, H as HappyDOMOptions, J as JSDOMOptions, O as OnServerRestartHandler } from './chunks/environment.0M5R1SX_.js';
-import { R as RuntimeRPC } from './chunks/worker.BANO5ak1.js';
+import { P as ProvidedContext } from './chunks/environment.C5eAp3K6.js';
+export { f as EnvironmentOptions, H as HappyDOMOptions, J as JSDOMOptions, O as OnServerRestartHandler } from './chunks/environment.C5eAp3K6.js';
+import { R as RuntimeRPC } from './chunks/worker.CTdJUeeB.js';
 import createDebug from 'debug';
-export { W as WorkerContext } from './chunks/worker.Cx2xE71X.js';
+export { W as WorkerContext } from './chunks/worker.DTM-0OlZ.js';
 export { SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
 export { b as RuntimeConfig } from './chunks/config.CHuotKvS.js';
 import '@vitest/pretty-format';
@@ -99,4 +99,14 @@ declare class BaseSequencer implements TestSequencer {
     sort(files: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
 }
 
-export { ApiConfig, BaseSequencer, GitNotFoundError, type GlobalSetupContext, ResolvedConfig, TestSequencer, FilesNotFoundError as TestsNotFoundError, UserConfig, Vitest, VitestPlugin, VitestRunMode, WorkspaceProject, WorkspaceSpec, createDebugger, createMethodsRPC, createVitest, distDir, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rootDir, startVitest };
+/**
+ * @deprecated Use `TestModule` instead
+ */
+declare const TestFile: typeof TestModule;
+
+/**
+ * @deprecated Use `ModuleDiagnostic` instead
+ */
+type FileDiagnostic = ModuleDiagnostic;
+
+export { ApiConfig, BaseSequencer, type FileDiagnostic, GitNotFoundError, type GlobalSetupContext, ModuleDiagnostic, ResolvedConfig, TestFile, TestModule, TestSequencer, FilesNotFoundError as TestsNotFoundError, UserConfig, Vitest, VitestPlugin, VitestRunMode, WorkspaceProject, WorkspaceSpec, createDebugger, createMethodsRPC, createVitest, distDir, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rootDir, startVitest };