vitest 2.1.0-beta.5 → 2.1.0-beta.7

package/dist/chunks/{resolveConfig.RHsAM2_Q.js → resolveConfig.-K5hHm0S.js}

@@ -9,16 +9,16 @@ 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';
 import { isCI, provider } from 'std-env';
 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 { g as groupBy, A as AggregateErrorPonyfill, a as slash, t as toArray } from './base.BlXpj3e_.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.Bh5-tlNJ.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,
@@ -7669,10 +7667,34 @@ 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.browser.provider === "playwright" && resolved.browser.name === "chromium")) {
+    const browserConfig = { browser: { provider: resolved.browser.provider, name: resolved.browser.name } };
+    if (resolved.coverage.enabled && resolved.coverage.provider === "v8") {
+      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)}
+`
+      );
+    }
+    if (resolved.inspect || resolved.inspectBrk) {
+      const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
+      throw new Error(
+        `${inspectOption} does not work with
+${JSON.stringify(browserConfig, null, 2)}
+
+Use either:
+${JSON.stringify({ browser: { provider: "playwright", name: "chromium" } }, null, 2)}
+
+...or disable ${inspectOption}
+`
+      );
+    }
   }
   resolved.coverage.reporter = resolveCoverageReporters(resolved.coverage.reporter);
   if (resolved.coverage.enabled && resolved.coverage.reportsDirectory) {
@@ -8118,4 +8140,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, configDefaults as d, isPackageExists as e, createPool as f, getFilePoolName as g, coverageConfigDefaults as h, isBrowserEnabled as i, mm as m, resolveCoverageReporters as r };

package/dist/chunks/{runBaseTests.BAhL8UH_.js → runBaseTests.Cztfoflv.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.DGgiNzJE.js';
+import { a as startCoverageInsideWorker, s as stopCoverageInsideWorker } from './coverage.zlNdAMHK.js';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.CSjyR2-v.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.xm8OIiKD.js';
+import { s as setupCommonEnv } from './setup-common.fGBFoQKJ.js';
 import { c as closeInspector } from './inspector.70d6emsh.js';
 import 'std-env';
 import 'chai';
@@ -24,7 +24,7 @@ import '@vitest/snapshot';
 import '@vitest/utils/error';
 import './tasks.BZnCS9aT.js';
 import '@vitest/utils/source-map';
-import './base.BH-FAiX7.js';
+import './base.BlXpj3e_.js';
 import './date.W2xKR2qe.js';
 import '@vitest/spy';
 import '../path.js';
@@ -122,7 +122,7 @@ async function run(method, files, config, environment, executor) {
         const isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true);
         const isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true);
         if (isIsolatedThreads || isIsolatedForks) {
-          workerState.mockMap.clear();
+          executor.mocker.reset();
           resetModules(workerState.moduleCache, true);
         }
         workerState.filepath = file;

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

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

package/dist/chunks/{utils.C3_cBsyn.js → utils.Cn0zI1t3.js}

@@ -3,6 +3,8 @@ import { parseRegexp } from '@vitest/utils';
 const REGEXP_WRAP_PREFIX = "$$vitest:";
 const processSend = process.send?.bind(process);
 const processOn = process.on?.bind(process);
+const processOff = process.off?.bind(process);
+const dispose = [];
 function createThreadsRpcOptions({
   port
 }) {
@@ -15,6 +17,15 @@ function createThreadsRpcOptions({
     }
   };
 }
+function disposeInternalListeners() {
+  for (const fn of dispose) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+  dispose.length = 0;
+}
 function createForksRpcOptions(nodeV8) {
   return {
     serialize: nodeV8.serialize,
@@ -23,12 +34,14 @@ function createForksRpcOptions(nodeV8) {
       processSend(v);
     },
     on(fn) {
-      processOn("message", (message, ...extras) => {
+      const handler = (message, ...extras) => {
         if (message?.__tinypool_worker_message__) {
           return;
         }
         return fn(message, ...extras);
-      });
+      };
+      processOn("message", handler);
+      dispose.push(() => processOff("message", handler));
     }
   };
 }
@@ -52,4 +65,4 @@ function unwrapSerializableConfig(config) {
   return config;
 }
 
-export { createThreadsRpcOptions as a, createForksRpcOptions as c, unwrapSerializableConfig as u };
+export { createThreadsRpcOptions as a, createForksRpcOptions as c, disposeInternalListeners as d, unwrapSerializableConfig as u };

package/dist/chunks/{utils.DO38lwfj.js → utils.Dbnmsfq1.js}

@@ -1,6 +1,6 @@
 import { isAbsolute, relative, dirname, basename } from 'pathe';
 import c from 'tinyrainbow';
-import { a as slash } from './base.BH-FAiX7.js';
+import { a as slash } from './base.BlXpj3e_.js';
 
 const F_RIGHT = "\u2192";
 const F_DOWN = "\u2193";

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

@@ -11,7 +11,7 @@ import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/util
 import 'pathe';
 import './env.CmHVDJnw.js';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { i as isChildProcess } from './base.BH-FAiX7.js';
+import { i as isChildProcess } from './base.BlXpj3e_.js';
 import { R as RealDate, r as resetDate, m as mockDate } from './date.W2xKR2qe.js';
 import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy';
 
@@ -191,16 +191,16 @@ function getError(expected, promise) {
   }
   throw new Error("snapshot function didn't throw");
 }
-const SnapshotPlugin = (chai, utils) => {
-  const getTestNames = (test) => {
-    if (!test) {
-      return {};
-    }
-    return {
-      filepath: test.file.filepath,
-      name: getNames(test).slice(1).join(" > ")
-    };
+function getTestNames(test) {
+  if (!test) {
+    return {};
+  }
+  return {
+    filepath: test.file.filepath,
+    name: getNames(test).slice(1).join(" > ")
   };
+}
+const SnapshotPlugin = (chai, utils) => {
   for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
     utils.addMethod(
       chai.Assertion.prototype,
@@ -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();
@@ -3464,18 +3469,6 @@ function waitUntil(callback, options = {}) {
 function createVitest() {
   let _mockedDate = null;
   let _config = null;
-  function _mocker() {
-    return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy(
-      {},
-      {
-        get(_, name) {
-          throw new Error(
-            `Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`
-          );
-        }
-      }
-    );
-  }
   const workerState = getWorkerState();
   let _timers;
   const timers = () => _timers ||= new FakeTimers({
@@ -3485,15 +3478,6 @@ function createVitest() {
   const _stubsGlobal = /* @__PURE__ */ new Map();
   const _stubsEnv = /* @__PURE__ */ new Map();
   const _envBooleans = ["PROD", "DEV", "SSR"];
-  const getImporter = (name) => {
-    const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
-    const stackArray = stackTrace.split("\n");
-    const importerStackIndex = stackArray.findIndex((stack2) => {
-      return stack2.includes(` at Object.${name}`) || stack2.includes(`${name}@`);
-    });
-    const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
-    return stack?.file || "";
-  };
   const utils = {
     useFakeTimers(config) {
       if (isChildProcess()) {
@@ -3555,6 +3539,10 @@ function createVitest() {
       await timers().advanceTimersToNextTimerAsync();
       return utils;
     },
+    advanceTimersToNextFrame() {
+      timers().advanceTimersToNextFrame();
+      return utils;
+    },
     getTimerCount() {
       return timers().getTimerCount();
     },
@@ -3593,14 +3581,13 @@ function createVitest() {
       _mocker().queueMock(
         path,
         importer,
-        factory ? () => factory(
+        typeof factory === "function" ? () => factory(
           () => _mocker().importActual(
             path,
             importer,
             _mocker().getMockContext().callstack
           )
-        ) : void 0,
-        true
+        ) : factory
       );
     },
     unmock(path) {
@@ -3621,14 +3608,13 @@ function createVitest() {
       _mocker().queueMock(
         path,
         importer,
-        factory ? () => factory(
+        typeof factory === "function" ? () => factory(
           () => _mocker().importActual(
             path,
             importer,
             _mocker().getMockContext().callstack
           )
-        ) : void 0,
-        false
+        ) : factory
       );
     },
     doUnmock(path) {
@@ -3689,6 +3675,8 @@ function createVitest() {
       }
       if (_envBooleans.includes(name)) {
         process.env[name] = value ? "1" : "";
+      } else if (value === void 0) {
+        delete process.env[name];
       } else {
         process.env[name] = String(value);
       }
@@ -3739,5 +3727,26 @@ function createVitest() {
 }
 const vitest = createVitest();
 const vi = vitest;
+function _mocker() {
+  return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy(
+    {},
+    {
+      get(_, name) {
+        throw new Error(
+          `Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`
+        );
+      }
+    }
+  );
+}
+function getImporter(name) {
+  const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
+  const stackArray = stackTrace.split("\n");
+  const importerStackIndex = stackArray.findIndex((stack2) => {
+    return stack2.includes(` at Object.${name}`) || stack2.includes(`${name}@`);
+  });
+  const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
+  return stack?.file || "";
+}
 
 export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, resetModules as r, vi as v };

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

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

package/dist/chunks/{vm.kl9T_5ai.js → vm.CPXwWp4C.js}

@@ -2,7 +2,7 @@ import vm, { isContext } from 'node:vm';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, basename, extname, normalize, join, resolve } from 'pathe';
 import { createCustomConsole } from './console.DI3gHgtH.js';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.DT9BA6zp.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute._eQQfgI8.js';
 import { distDir } from '../path.js';
 import { dirname as dirname$1 } from 'node:path';
 import fs from 'node:fs';
@@ -822,7 +822,6 @@ async function runVmTests(method, state) {
   const executor = await startVitestExecutor({
     context,
     moduleCache: state.moduleCache,
-    mockMap: state.mockMap,
     state,
     externalModulesExecutor,
     requestStubs: stubs

package/dist/chunks/{worker.Cx2xE71X.d.ts → worker.Bws9Zuxu.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.CmPmTxgH.js';
 
 interface WorkerContext extends ContextRPC {
     port: MessagePort;

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

@@ -2,18 +2,7 @@ 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';
-
-type MockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M>() => Promise<T>) => any;
-type MockFactory = () => any;
-type MockMap = Map<string, Record<string, string | null | MockFactory>>;
-interface PendingSuiteMock {
-    id: string;
-    importer: string;
-    type: 'mock' | 'unmock';
-    throwIfCached: boolean;
-    factory?: MockFactory;
-}
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.C5eAp3K6.js';
 
 interface RuntimeRPC {
     fetch: (id: string, transformMode: TransformMode) => Promise<{
@@ -133,7 +122,6 @@ interface WorkerGlobalState {
     environmentTeardownRun?: boolean;
     onCancel: Promise<CancelReason>;
     moduleCache: ModuleCacheMap;
-    mockMap: MockMap;
     providedContext: Record<string, any>;
     durations: {
         environment: number;
@@ -141,4 +129,4 @@ interface WorkerGlobalState {
     };
 }
 
-export type { BirpcOptions as B, ContextRPC as C, MockFactoryWithHelper as M, PendingSuiteMock as P, RuntimeRPC as R, WorkerGlobalState as W, BirpcReturn as a, RunnerRPC as b, ResolveIdFunction as c, WorkerRPC as d, ContextTestEnvironment as e, MockFactory as f, MockMap as g };
+export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, WorkerGlobalState as W, BirpcReturn as a, RunnerRPC as b, ResolveIdFunction as c, WorkerRPC as d, ContextTestEnvironment as e };

package/dist/cli.js

@@ -1,9 +1,9 @@
-import { c as createCLI } from './chunks/cac.DosbLiJg.js';
+import { c as createCLI } from './chunks/cac.B5XYKv2_.js';
 import 'pathe';
 import 'events';
 import 'tinyrainbow';
-import './chunks/base.BH-FAiX7.js';
+import './chunks/base.BlXpj3e_.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.DbwOGCsU.js';
+import './chunks/vite.D2yAwzwa.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.WnPwkmgA.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,