vitest 2.1.2 → 2.1.4

package/dist/chunks/{rpc.B7Mfb-Yf.js → rpc.C3q9uwRX.js}

@@ -1,6 +1,6 @@
 import { getSafeTimers } from '@vitest/utils';
-import { c as createBirpc } from './index.BpSiYbpB.js';
-import { g as getWorkerState } from './utils.Ck2hJTRs.js';
+import { c as createBirpc } from './index.68735LiX.js';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {

package/dist/chunks/{run-once.Sxe67Wng.js → run-once.2ogXb3JV.js}

@@ -1,4 +1,4 @@
-import { g as getWorkerState } from './utils.Ck2hJTRs.js';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
 
 const filesCount = /* @__PURE__ */ new Map();
 const cache = /* @__PURE__ */ new Map();

package/dist/chunks/{runBaseTests.D-Gcin7G.js → runBaseTests.Dm-659zB.js}

@@ -1,39 +1,35 @@
 import { performance } from 'node:perf_hooks';
 import { startTests, collectTests } from '@vitest/runner';
-import 'pathe';
-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.DUs2eKik.js';
-import { a as startCoverageInsideWorker, s as stopCoverageInsideWorker } from './coverage.zlNdAMHK.js';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.Ckn0Cw1h.js';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.D3d79vc8.js';
+import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './coverage.BoMDb1ip.js';
+import { a as globalExpect, v as vi } from './vi.JMQoNY_Z.js';
+import { c as closeInspector } from './inspector.70d6emsh.js';
 import { createRequire } from 'node:module';
-import util from 'node:util';
 import timers from 'node:timers';
-import { installSourcemapsSupport } from 'vite-node/source-map';
+import util from 'node:util';
+import { getSafeTimers } from '@vitest/utils';
 import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
-import { V as VitestIndex } from './index.mAqbj9F9.js';
-import { s as setupCommonEnv } from './setup-common.DF96bIYE.js';
-import { c as closeInspector } from './inspector.70d6emsh.js';
-import 'std-env';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { V as VitestIndex } from './index.Dqe5k2Rk.js';
+import { s as setupCommonEnv } from './setup-common.DDmVKp6O.js';
+import { g as getWorkerState, r as resetModules } from './utils.C8RiOc4B.js';
 import 'chai';
-import './_commonjsHelpers.BFTU3MAI.js';
+import 'node:path';
+import '../path.js';
+import 'node:url';
+import './rpc.C3q9uwRX.js';
+import './index.68735LiX.js';
 import '@vitest/expect';
+import '@vitest/runner/utils';
+import './_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
-import './tasks.BZnCS9aT.js';
 import '@vitest/utils/source-map';
-import './base.DwXGwWst.js';
 import './date.W2xKR2qe.js';
 import '@vitest/spy';
-import '../path.js';
-import 'node:url';
-import './rpc.B7Mfb-Yf.js';
-import './index.BpSiYbpB.js';
-import './benchmark.C8CRJYG4.js';
-import './index.CxRxs566.js';
-import './run-once.Sxe67Wng.js';
+import './run-once.2ogXb3JV.js';
+import './benchmark.Cdu9hjj4.js';
+import 'expect-type';
 
 let globalSetup = false;
 async function setupGlobalEnv(config, { environment }, executor) {
@@ -81,7 +77,7 @@ function resolveAsset(mod, url) {
   mod.exports = url;
 }
 async function setupConsoleLogSpy() {
-  const { createCustomConsole } = await import('./console.DI3gHgtH.js');
+  const { createCustomConsole } = await import('./console.BYGVloWk.js');
   globalThis.console = createCustomConsole();
 }
 async function withEnv({ environment }, options, fn) {

package/dist/chunks/{setup-common.DF96bIYE.js → setup-common.DDmVKp6O.js}

@@ -1,6 +1,6 @@
-import { setSafeTimers } from '@vitest/utils';
 import { addSerializer } from '@vitest/snapshot';
-import { r as resetRunOnceCounter } from './run-once.Sxe67Wng.js';
+import { setSafeTimers } from '@vitest/utils';
+import { r as resetRunOnceCounter } from './run-once.2ogXb3JV.js';
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
@@ -13,7 +13,7 @@ async function setupCommonEnv(config) {
   globalSetup = true;
   setSafeTimers();
   if (config.globals) {
-    (await import('./globals.HsM2o-0O.js')).registerApiGlobally();
+    (await import('./globals.Bp645TTJ.js')).registerApiGlobally();
   }
 }
 function setupDefines(defines) {

package/dist/chunks/{suite.BMWOKiTe.d.ts → suite.B2jumIFP.d.ts}

@@ -1,7 +1,7 @@
 import { Custom } from '@vitest/runner';
-import '@vitest/runner/utils';
-import { b as BenchFunction, c as BenchmarkAPI } from './benchmark.JVlTzojj.js';
+import { a as BenchFunction, c as BenchmarkAPI } from './benchmark.geERunq4.js';
 import { Options } from 'tinybench';
+import '@vitest/runner/utils';
 
 declare function getBenchOptions(key: Custom): Options;
 declare function getBenchFn(key: Custom): BenchFunction;

package/dist/chunks/{utils.CY6Spixo.js → utils.BB4zjzR8.js}

@@ -1,7 +1,7 @@
 import { stripVTControlCharacters } from 'node:util';
+import { slash } from '@vitest/utils';
 import { isAbsolute, relative, dirname, basename } from 'pathe';
 import c from 'tinyrainbow';
-import { a as slash } from './base.DwXGwWst.js';
 
 const F_RIGHT = "\u2192";
 const F_DOWN = "\u2193";
@@ -205,4 +205,4 @@ var utils = /*#__PURE__*/Object.freeze({
   testPass: testPass
 });
 
-export { F_RIGHT as F, F_POINTER as a, getStateString as b, formatTimeString as c, countTestErrors as d, divider as e, formatProjectName as f, getStateSymbol as g, getCols as h, getHookStateSymbol as i, renderSnapshotSummary as r, taskFail as t, utils as u };
+export { F_POINTER as F, F_RIGHT as a, F_CHECK as b, getStateString as c, divider as d, formatTimeString as e, formatProjectName as f, getStateSymbol as g, countTestErrors as h, getCols as i, getHookStateSymbol as j, renderSnapshotSummary as r, taskFail as t, utils as u };

package/dist/chunks/utils.C8RiOc4B.js

@@ -0,0 +1,77 @@
+import { getSafeTimers } from '@vitest/utils';
+
+const NAME_WORKER_STATE = "__vitest_worker__";
+function getWorkerState() {
+  const workerState = globalThis[NAME_WORKER_STATE];
+  if (!workerState) {
+    const errorMsg = 'Vitest failed to access its internal state.\n\nOne of the following is possible:\n- "vitest" is imported directly without running "vitest" command\n- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
+    throw new Error(errorMsg);
+  }
+  return workerState;
+}
+function provideWorkerState(context, state) {
+  Object.defineProperty(context, NAME_WORKER_STATE, {
+    value: state,
+    configurable: true,
+    writable: true,
+    enumerable: false
+  });
+  return state;
+}
+function getCurrentEnvironment() {
+  const state = getWorkerState();
+  return state?.environment.name;
+}
+function isChildProcess() {
+  return typeof process !== "undefined" && !!process.send;
+}
+function setProcessTitle(title) {
+  try {
+    process.title = `node (${title})`;
+  } catch {
+  }
+}
+function resetModules(modules, resetMocks = false) {
+  const skipPaths = [
+    // Vitest
+    /\/vitest\/dist\//,
+    /\/vite-node\/dist\//,
+    // yarn's .store folder
+    /vitest-virtual-\w+\/dist/,
+    // cnpm
+    /@vitest\/dist/,
+    // don't clear mocks
+    ...!resetMocks ? [/^mock:/] : []
+  ];
+  modules.forEach((mod, path) => {
+    if (skipPaths.some((re) => re.test(path))) {
+      return;
+    }
+    modules.invalidateModule(mod);
+  });
+}
+function waitNextTick() {
+  const { setTimeout } = getSafeTimers();
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+async function waitForImportsToResolve() {
+  await waitNextTick();
+  const state = getWorkerState();
+  const promises = [];
+  let resolvingCount = 0;
+  for (const mod of state.moduleCache.values()) {
+    if (mod.promise && !mod.evaluated) {
+      promises.push(mod.promise);
+    }
+    if (mod.resolving) {
+      resolvingCount++;
+    }
+  }
+  if (!promises.length && !resolvingCount) {
+    return;
+  }
+  await Promise.allSettled(promises);
+  await waitForImportsToResolve();
+}
+
+export { getCurrentEnvironment as a, getWorkerState as g, isChildProcess as i, provideWorkerState as p, resetModules as r, setProcessTitle as s, waitForImportsToResolve as w };

package/dist/chunks/{vi.DUs2eKik.js → vi.JMQoNY_Z.js}

@@ -1,61 +1,106 @@
+import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters } from '@vitest/expect';
+import { getCurrentTest } from '@vitest/runner';
+import { getNames, getTestName } from '@vitest/runner/utils';
 import * as chai$1 from 'chai';
+import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, r as resetModules, w as waitForImportsToResolve } from './utils.C8RiOc4B.js';
+import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
-import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters } from '@vitest/expect';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
-import { getNames } from '@vitest/runner/utils';
 import '@vitest/utils/error';
-import { getCurrentTest } from '@vitest/runner';
-import { g as getTestName } from './tasks.BZnCS9aT.js';
-import { g as getWorkerState, a as getCurrentEnvironment } from './utils.Ck2hJTRs.js';
-import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
-import 'pathe';
-import './env.CmHVDJnw.js';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { i as isChildProcess } from './base.DwXGwWst.js';
 import { R as RealDate, r as resetDate, m as mockDate } from './date.W2xKR2qe.js';
 import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy';
 
-function resetModules(modules, resetMocks = false) {
-  const skipPaths = [
-    // Vitest
-    /\/vitest\/dist\//,
-    /\/vite-node\/dist\//,
-    // yarn's .store folder
-    /vitest-virtual-\w+\/dist/,
-    // cnpm
-    /@vitest\/dist/,
-    // don't clear mocks
-    ...!resetMocks ? [/^mock:/] : []
-  ];
-  modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path))) {
-      return;
-    }
-    modules.invalidateModule(mod);
-  });
-}
-function waitNextTick() {
-  const { setTimeout } = getSafeTimers();
-  return new Promise((resolve) => setTimeout(resolve, 0));
+const unsupported = [
+  // .poll is meant to retry matchers until they succeed, and
+  // snapshots will always succeed as long as the poll method doesn't thow an error
+  // in this case using the `vi.waitFor` method is more appropriate
+  "matchSnapshot",
+  "toMatchSnapshot",
+  "toMatchInlineSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "toThrowErrorMatchingInlineSnapshot",
+  // toThrow will never succeed because we call the poll callback until it doesn't throw
+  "throws",
+  "Throw",
+  "throw",
+  "toThrow",
+  "toThrowError"
+  // these are not supported because you can call them without `.poll`,
+  // we throw an error inside the rejects/resolves methods to prevent this
+  // rejects,
+  // resolves
+];
+function createExpectPoll(expect) {
+  return function poll(fn, options = {}) {
+    const state = getWorkerState();
+    const defaults = state.config.expect?.poll ?? {};
+    const {
+      interval = defaults.interval ?? 50,
+      timeout = defaults.timeout ?? 1e3,
+      message
+    } = options;
+    const assertion = expect(null, message).withContext({
+      poll: true
+    });
+    fn = fn.bind(assertion);
+    const proxy = new Proxy(assertion, {
+      get(target, key, receiver) {
+        const assertionFunction = Reflect.get(target, key, receiver);
+        if (typeof assertionFunction !== "function") {
+          return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
+        }
+        if (key === "assert") {
+          return assertionFunction;
+        }
+        if (typeof key === "string" && unsupported.includes(key)) {
+          throw new SyntaxError(
+            `expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`
+          );
+        }
+        return function(...args) {
+          const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+          return new Promise((resolve, reject) => {
+            let intervalId;
+            let lastError;
+            const { setTimeout, clearTimeout } = getSafeTimers();
+            const timeoutId = setTimeout(() => {
+              clearTimeout(intervalId);
+              reject(
+                copyStackTrace$1(
+                  new Error(`Matcher did not succeed in ${timeout}ms`, {
+                    cause: lastError
+                  }),
+                  STACK_TRACE_ERROR
+                )
+              );
+            }, timeout);
+            const check = async () => {
+              try {
+                chai$1.util.flag(assertion, "_name", key);
+                const obj = await fn();
+                chai$1.util.flag(assertion, "object", obj);
+                resolve(await assertionFunction.call(assertion, ...args));
+                clearTimeout(intervalId);
+                clearTimeout(timeoutId);
+              } catch (err) {
+                lastError = err;
+                intervalId = setTimeout(check, interval);
+              }
+            };
+            check();
+          });
+        };
+      }
+    });
+    return proxy;
+  };
 }
-async function waitForImportsToResolve() {
-  await waitNextTick();
-  const state = getWorkerState();
-  const promises = [];
-  let resolvingCount = 0;
-  for (const mod of state.moduleCache.values()) {
-    if (mod.promise && !mod.evaluated) {
-      promises.push(mod.promise);
-    }
-    if (mod.resolving) {
-      resolvingCount++;
-    }
-  }
-  if (!promises.length && !resolvingCount) {
-    return;
+function copyStackTrace$1(target, source) {
+  if (source.stack !== void 0) {
+    target.stack = source.stack.replace(source.message, target.message);
   }
-  await Promise.allSettled(promises);
-  await waitForImportsToResolve();
+  return target;
 }
 
 function commonjsRequire(path) {
@@ -365,96 +410,6 @@ chai$1.use(Subset);
 chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
 
-const unsupported = [
-  // .poll is meant to retry matchers until they succeed, and
-  // snapshots will always succeed as long as the poll method doesn't thow an error
-  // in this case using the `vi.waitFor` method is more appropriate
-  "matchSnapshot",
-  "toMatchSnapshot",
-  "toMatchInlineSnapshot",
-  "toThrowErrorMatchingSnapshot",
-  "toThrowErrorMatchingInlineSnapshot",
-  // toThrow will never succeed because we call the poll callback until it doesn't throw
-  "throws",
-  "Throw",
-  "throw",
-  "toThrow",
-  "toThrowError"
-  // these are not supported because you can call them without `.poll`,
-  // we throw an error inside the rejects/resolves methods to prevent this
-  // rejects,
-  // resolves
-];
-function createExpectPoll(expect) {
-  return function poll(fn, options = {}) {
-    const state = getWorkerState();
-    const defaults = state.config.expect?.poll ?? {};
-    const {
-      interval = defaults.interval ?? 50,
-      timeout = defaults.timeout ?? 1e3,
-      message
-    } = options;
-    const assertion = expect(null, message).withContext({
-      poll: true
-    });
-    const proxy = new Proxy(assertion, {
-      get(target, key, receiver) {
-        const assertionFunction = Reflect.get(target, key, receiver);
-        if (typeof assertionFunction !== "function") {
-          return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
-        }
-        if (key === "assert") {
-          return assertionFunction;
-        }
-        if (typeof key === "string" && unsupported.includes(key)) {
-          throw new SyntaxError(
-            `expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`
-          );
-        }
-        return function(...args) {
-          const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-          return new Promise((resolve, reject) => {
-            let intervalId;
-            let lastError;
-            const { setTimeout, clearTimeout } = getSafeTimers();
-            const timeoutId = setTimeout(() => {
-              clearTimeout(intervalId);
-              reject(
-                copyStackTrace$1(
-                  new Error(`Matcher did not succeed in ${timeout}ms`, {
-                    cause: lastError
-                  }),
-                  STACK_TRACE_ERROR
-                )
-              );
-            }, timeout);
-            const check = async () => {
-              try {
-                const obj = await fn();
-                chai$1.util.flag(assertion, "object", obj);
-                resolve(await assertionFunction.call(assertion, ...args));
-                clearTimeout(intervalId);
-                clearTimeout(timeoutId);
-              } catch (err) {
-                lastError = err;
-                intervalId = setTimeout(check, interval);
-              }
-            };
-            check();
-          });
-        };
-      }
-    });
-    return proxy;
-  };
-}
-function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
-  return target;
-}
-
 function createExpect(test) {
   const expect = (value, message) => {
     const { assertionCalls } = getState(expect);
@@ -3940,4 +3895,4 @@ function getImporter(name) {
   return stack?.file || "";
 }
 
-export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, resetModules as r, vi as v };
+export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, vi as v };

package/dist/chunks/{vite.8fk186v-.d.ts → vite.BdBj-UWY.d.ts}

@@ -1,4 +1,4 @@
-import { I as InlineConfig } from './reporters.DAfKSDh5.js';
+import { I as InlineConfig } from './reporters.anwo7Y6a.js';
 
 type VitestInlineConfig = InlineConfig;
 declare module 'vite' {

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

@@ -1,18 +1,15 @@
-import vm, { isContext } from 'node:vm';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import vm, { isContext } from 'node:vm';
 import { dirname, basename, extname, normalize, join, resolve } from 'pathe';
-import { createCustomConsole } from './console.DI3gHgtH.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 { createCustomConsole } from './console.BYGVloWk.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.2pr0rHgK.js';
 import fs from 'node:fs';
+import { dirname as dirname$1 } from 'node:path';
 import { isNodeBuiltin, isPrimitive, toArray, getCachedData, setCacheData } from 'vite-node/utils';
 import { createRequire, Module } from 'node:module';
 import { CSS_LANGS_RE, KNOWN_ASSET_RE } from 'vite-node/constants';
-import '@vitest/runner/utils';
-import '@vitest/utils';
-import { p as provideWorkerState } from './utils.Ck2hJTRs.js';
-import './env.CmHVDJnw.js';
+import { p as provideWorkerState } from './utils.C8RiOc4B.js';
 
 const _require = createRequire(import.meta.url);
 const requiresCache = /* @__PURE__ */ new WeakMap();

package/dist/chunks/{worker.Chrs-_NL.d.ts → worker.BAlI9hII.d.ts}

@@ -1,32 +1,8 @@
-import { FetchResult, ViteNodeResolveId, RawSourceMap, ModuleCacheMap } from 'vite-node';
 import { File, TaskResultPack, CancelReason, Task } from '@vitest/runner';
+import { ViteNodeResolveId, ModuleCacheMap } from 'vite-node';
 import { S as SerializedConfig } from './config.Crbj2GAb.js';
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.LoooBwUu.js';
 import { SnapshotResult } from '@vitest/snapshot';
-import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.CzISCQ7o.js';
-
-interface RuntimeRPC {
-    fetch: (id: string, transformMode: TransformMode) => Promise<{
-        externalize?: string;
-        id?: string;
-    }>;
-    transform: (id: string, transformMode: TransformMode) => Promise<FetchResult>;
-    resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<ViteNodeResolveId | null>;
-    getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
-    onFinished: (files: File[], errors?: unknown[]) => void;
-    onPathsCollected: (paths: string[]) => void;
-    onUserConsoleLog: (log: UserConsoleLog) => void;
-    onUnhandledError: (err: unknown, type: string) => void;
-    onCollected: (files: File[]) => Promise<void>;
-    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
-    onTaskUpdate: (pack: TaskResultPack[]) => Promise<void>;
-    onCancel: (reason: CancelReason) => void;
-    getCountOfFailedTests: () => number;
-    snapshotSaved: (snapshot: SnapshotResult) => void;
-    resolveSnapshotPath: (testPath: string) => string;
-}
-interface RunnerRPC {
-    onCancel: (reason: CancelReason) => void;
-}
 
 type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
 type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
@@ -41,6 +17,10 @@ interface ChannelOptions {
      * Listener to receive raw message
      */
     on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Clear the listener when `$close` is called
+     */
+    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
     /**
      * Custom function to serialize data
      *
@@ -53,6 +33,10 @@ interface ChannelOptions {
      * by default it passes the data as-is
      */
     deserialize?: (data: any) => any;
+    /**
+     * Call the methods with the RPC context or the original functions object
+     */
+    bind?: 'rpc' | 'functions';
 }
 interface EventOptions<Remote> {
     /**
@@ -91,8 +75,47 @@ type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
     [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
 } & {
     $functions: LocalFunctions;
+    $close: () => void;
 };
 
+interface RuntimeRPC {
+    fetch: (id: string, transformMode: TransformMode) => Promise<{
+        externalize?: string;
+        id?: string;
+    }>;
+    transform: (id: string, transformMode: TransformMode) => Promise<{
+        code?: string;
+    }>;
+    resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
+        external?: boolean | 'absolute' | 'relative';
+        id: string;
+        /** @deprecated */
+        meta?: Record<string, any> | null;
+        /** @deprecated */
+        moduleSideEffects?: boolean | 'no-treeshake' | null;
+        /** @deprecated */
+        syntheticNamedExports?: boolean | string | null;
+    } | null>;
+    /**
+     * @deprecated unused
+     */
+    getSourceMap: (id: string, force?: boolean) => Promise<any>;
+    onFinished: (files: File[], errors?: unknown[]) => void;
+    onPathsCollected: (paths: string[]) => void;
+    onUserConsoleLog: (log: UserConsoleLog) => void;
+    onUnhandledError: (err: unknown, type: string) => void;
+    onCollected: (files: File[]) => Promise<void>;
+    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+    onTaskUpdate: (pack: TaskResultPack[]) => Promise<void>;
+    onCancel: (reason: CancelReason) => void;
+    getCountOfFailedTests: () => number;
+    snapshotSaved: (snapshot: SnapshotResult) => void;
+    resolveSnapshotPath: (testPath: string) => string;
+}
+interface RunnerRPC {
+    onCancel: (reason: CancelReason) => void;
+}
+
 /** @deprecated unused */
 type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
@@ -129,4 +152,4 @@ interface WorkerGlobalState {
     };
 }
 
-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 };
+export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, WorkerGlobalState as W, BirpcReturn as a, WorkerRPC as b, RunnerRPC as c, ContextTestEnvironment as d, ResolveIdFunction as e };

package/dist/chunks/{worker.Qtv8v5nL.d.ts → worker.DHnGaO2M.d.ts}

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

package/dist/cli.js

@@ -1,9 +1,8 @@
-import { c as createCLI } from './chunks/cac.B9PaPYY1.js';
-import 'pathe';
+import { c as createCLI } from './chunks/cac.DrfPaMvZ.js';
+import '@vitest/utils';
 import 'events';
+import 'pathe';
 import 'tinyrainbow';
-import './chunks/base.DwXGwWst.js';
-import '@vitest/utils';
 import './chunks/constants.fzPh7AOq.js';
 
 createCLI().parse();

package/dist/config.cjs

@@ -4,10 +4,6 @@ var os = require('node:os');
 var stdEnv = require('std-env');
 var vite = require('vite');
 
-const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
-const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
-(isNode || isDeno) && process.platform === "win32";
-
 const defaultBrowserPort = 63315;
 const extraInlineDeps = [
   /^(?!.*node_modules).*\.mjs$/,
@@ -16,6 +12,10 @@ const extraInlineDeps = [
   /vite\w*\/dist\/client\/env.mjs/
 ];
 
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
+(isNode || isDeno) && process.platform === "win32";
+
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
 const defaultExclude = [
   "**/node_modules/**",