vitest 2.1.3 → 2.1.5

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.Cx4wXyTR.js → runBaseTests.3qpJUEJM.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.BskyZC5g.js';
-import { a as startCoverageInsideWorker, s as stopCoverageInsideWorker } from './coverage.zlNdAMHK.js';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.4GFF2h22.js';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.nEwtF0bu.js';
+import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './coverage.BoMDb1ip.js';
+import { a as globalExpect, v as vi } from './vi.DgezovHB.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.-d_XpZEA.js';
-import { s as setupCommonEnv } from './setup-common.BKyF15v_.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.ckWaX2gY.js';
+import { s as setupCommonEnv } from './setup-common.Dj6BZI3u.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.CfT1Wjed.js');
+  const { createCustomConsole } = await import('./console.BYGVloWk.js');
   globalThis.console = createCustomConsole();
 }
 async function withEnv({ environment }, options, fn) {

package/dist/chunks/{setup-common.BKyF15v_.js → setup-common.Dj6BZI3u.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.Bdzt04Qm.js')).registerApiGlobally();
+    (await import('./globals.D8ZVAdXd.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.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/{utils.CY6Spixo.js → utils.DNoFbBUZ.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";
@@ -179,6 +179,9 @@ function formatProjectName(name, suffix = " ") {
   const colors = [c.blue, c.yellow, c.cyan, c.green, c.magenta];
   return colors[index % colors.length](`|${name}|`) + suffix;
 }
+function withLabel(color, label, message) {
+  return `${c.bold(c.inverse(c[color](` ${label} `)))} ${c[color](message)}`;
+}
 
 var utils = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -202,7 +205,8 @@ var utils = /*#__PURE__*/Object.freeze({
   spinnerMap: spinnerMap,
   suiteFail: suiteFail,
   taskFail: taskFail,
-  testPass: testPass
+  testPass: testPass,
+  withLabel: withLabel
 });
 
-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, formatTimeString as a, F_RIGHT as b, F_CHECK as c, divider as d, getStateString 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, withLabel as w };

package/dist/chunks/{vi.BskyZC5g.js → vi.DgezovHB.js}

@@ -1,61 +1,140 @@
+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;
+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 test = chai$1.util.flag(assertion, "vitest-test");
+    if (!test) {
+      throw new Error("expect.poll() must be called inside a test");
     }
-    modules.invalidateModule(mod);
-  });
-}
-function waitNextTick() {
-  const { setTimeout } = getSafeTimers();
-  return new Promise((resolve) => setTimeout(resolve, 0));
+    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");
+          const promise = () => 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();
+          });
+          let awaited = false;
+          test.onFinished ??= [];
+          test.onFinished.push(() => {
+            if (!awaited) {
+              const negated = chai$1.util.flag(assertion, "negate") ? "not." : "";
+              const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
+              const assertionString = `expect.${name}.${negated}${String(key)}()`;
+              const error = new Error(
+                `${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
+
+await ${assertionString}
+`
+              );
+              throw copyStackTrace$1(error, STACK_TRACE_ERROR);
+            }
+          });
+          let resultPromise;
+          return {
+            then(onFulfilled, onRejected) {
+              awaited = true;
+              return (resultPromise ||= promise()).then(onFulfilled, onRejected);
+            },
+            catch(onRejected) {
+              return (resultPromise ||= promise()).catch(onRejected);
+            },
+            finally(onFinally) {
+              return (resultPromise ||= promise()).finally(onFinally);
+            },
+            [Symbol.toStringTag]: "Promise"
+          };
+        };
+      }
+    });
+    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) {
@@ -157,9 +236,20 @@ function requireChaiSubset () {
 var chaiSubsetExports = requireChaiSubset();
 var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports);
 
-function recordAsyncExpect(test, promise) {
+function createAssertionMessage(util, assertion, hasArgs) {
+  const not = util.flag(assertion, "negate") ? "not." : "";
+  const name = `${util.flag(assertion, "_name")}(${"expected" })`;
+  const promiseName = util.flag(assertion, "promise");
+  const promise = promiseName ? `.${promiseName}` : "";
+  return `expect(actual)${promise}.${not}${name}`;
+}
+function recordAsyncExpect(_test, promise, assertion, error) {
+  const test = _test;
   if (test && promise instanceof Promise) {
     promise = promise.finally(() => {
+      if (!test.promises) {
+        return;
+      }
       const index = test.promises.indexOf(promise);
       if (index !== -1) {
         test.promises.splice(index, 1);
@@ -169,6 +259,33 @@ function recordAsyncExpect(test, promise) {
       test.promises = [];
     }
     test.promises.push(promise);
+    let resolved = false;
+    test.onFinished ??= [];
+    test.onFinished.push(() => {
+      if (!resolved) {
+        const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
+        const stack = processor(error.stack);
+        console.warn([
+          `Promise returned by \`${assertion}\` was not awaited. `,
+          "Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
+          "Please remember to await the assertion.\n",
+          stack
+        ].join(""));
+      }
+    });
+    return {
+      then(onFullfilled, onRejected) {
+        resolved = true;
+        return promise.then(onFullfilled, onRejected);
+      },
+      catch(onRejected) {
+        return promise.catch(onRejected);
+      },
+      finally(onFinally) {
+        return promise.finally(onFinally);
+      },
+      [Symbol.toStringTag]: "Promise"
+    };
   }
   return promise;
 }
@@ -215,6 +332,7 @@ const SnapshotPlugin = (chai, utils) => {
       chai.Assertion.prototype,
       key,
       function(properties, message) {
+        utils.flag(this, "_name", key);
         const isNot = utils.flag(this, "negate");
         if (isNot) {
           throw new Error(`${key} cannot be used with "not"`);
@@ -241,10 +359,12 @@ const SnapshotPlugin = (chai, utils) => {
     chai.Assertion.prototype,
     "toMatchFileSnapshot",
     function(file, message) {
+      utils.flag(this, "_name", "toMatchFileSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error('toMatchFileSnapshot cannot be used with "not"');
       }
+      const error = new Error("resolves");
       const expected = utils.flag(this, "object");
       const test = utils.flag(this, "vitest-test");
       const errorMessage = utils.flag(this, "message");
@@ -258,13 +378,19 @@ const SnapshotPlugin = (chai, utils) => {
         errorMessage,
         ...getTestNames(test)
       });
-      return recordAsyncExpect(test, promise);
+      return recordAsyncExpect(
+        test,
+        promise,
+        createAssertionMessage(utils, this),
+        error
+      );
     }
   );
   utils.addMethod(
     chai.Assertion.prototype,
     "toMatchInlineSnapshot",
     function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+      utils.flag(this, "_name", "toMatchInlineSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error('toMatchInlineSnapshot cannot be used with "not"');
@@ -303,6 +429,7 @@ const SnapshotPlugin = (chai, utils) => {
     chai.Assertion.prototype,
     "toThrowErrorMatchingSnapshot",
     function(message) {
+      utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error(
@@ -365,98 +492,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
-    });
-    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;
-  };
-}
-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);
@@ -3942,4 +3977,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.YH7MrecS.d.ts → vite.C-N5BBZe.d.ts}

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

package/dist/chunks/{vm.DB_hLchi.js → vm.Zr4qWzDJ.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.CfT1Wjed.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();
@@ -119,6 +116,9 @@ class CommonjsExecutor {
       // @ts-expect-error not typed
       static globalPaths = Module.globalPaths;
       static isBuiltin = Module.isBuiltin;
+      static constants = Module.constants;
+      static enableCompileCache = Module.enableCompileCache;
+      static getCompileCacheDir = Module.getCompileCacheDir;
       static Module = Module$1;
     };
     this.extensions[".js"] = this.requireJs;

package/dist/chunks/{worker.CcJLfX8w.d.ts → worker.B9FxPCaC.d.ts}

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