@voidzero-dev/vite-plus-test 0.1.8 → 0.1.10

package/dist/chunks/{vi.2VT5v0um.js → test.CTcmp4Su.js}

@@ -1,16 +1,18 @@
-import { chai, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '../@vitest/expect/index.js';
-import { getCurrentTest } from '../@vitest/runner/index.js';
-import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.DvEY5TfP.js';
+import { getCurrentTest, updateTask, createTaskCollector, getCurrentSuite, getHooks, getFn } from '../@vitest/runner/index.js';
+import { assertTypes, createSimpleStackTrace, createDefer } from '../@vitest/utils/helpers.js';
 import { getSafeTimers, delay } from '../@vitest/utils/timers.js';
-import { getNames } from '../@vitest/runner/utils.js';
+import { a as getBenchOptions, g as getBenchFn } from './benchmark.D0SlKNbZ.js';
+import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.BX5Fg8C4.js';
+import { chai, wrapAssertion, recordAsyncExpect, createAssertionMessage, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, ChaiStyleAssertions, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '../@vitest/expect/index.js';
+import { getNames, getTests, getTestName, createChainable } from '../@vitest/runner/utils.js';
+import { processError } from '../@vitest/utils/error.js';
+import { normalize } from '../vendor/pathe.mjs';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '../@vitest/snapshot/index.js';
-import '../@vitest/utils/error.js';
-import { assertTypes, createSimpleStackTrace } from '../@vitest/utils/helpers.js';
 import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunction } from '../@vitest/spy/index.js';
 import '../@vitest/utils/offset.js';
 import { parseSingleStack } from '../@vitest/utils/source-map.js';
 import { c as commonjsGlobal } from './_commonjsHelpers.D26ty3Ew.js';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.Bq6ZW5rf.js';
+import { R as RealDate, b as resetDate, m as mockDate, r as rpc } from './rpc.MzXet3jl.js';
 
 // these matchers are not supported because they don't make sense with poll
 const unsupported = [
@@ -61,6 +63,7 @@ function createExpectPoll(expect) {
             hasTimedOut = true;
           }, timeout);
           chai.util.flag(assertion, "_name", key);
+          const onSettled = chai.util.flag(assertion, "_poll.onSettled");
           try {
             while (true) {
               const isLastAttempt = hasTimedOut;
@@ -70,9 +73,20 @@ function createExpectPoll(expect) {
                 const obj = await fn();
                 chai.util.flag(assertion, "object", obj);
                 executionPhase = "assertion";
-                return await assertionFunction.call(assertion, ...args);
+                const output = await assertionFunction.call(assertion, ...args);
+                await onSettled?.({
+                  assertion,
+                  status: "pass"
+                });
+                return output;
               } catch (err) {
-                if (isLastAttempt || executionPhase === "assertion" && chai.util.flag(assertion, "_poll.assert_once")) throwWithCause(err, STACK_TRACE_ERROR);
+                if (isLastAttempt || executionPhase === "assertion" && chai.util.flag(assertion, "_poll.assert_once")) {
+                  await onSettled?.({
+                    assertion,
+                    status: "fail"
+                  });
+                  throwWithCause(err, STACK_TRACE_ERROR);
+                }
                 await delay(interval, setTimeout);
               }
             }
@@ -98,9 +112,11 @@ function createExpectPoll(expect) {
             return (resultPromise ||= promise()).then(onFulfilled, onRejected);
           },
           catch(onRejected) {
+            awaited = true;
             return (resultPromise ||= promise()).catch(onRejected);
           },
           finally(onFinally) {
+            awaited = true;
             return (resultPromise ||= promise()).finally(onFinally);
           },
           [Symbol.toStringTag]: "Promise"
@@ -115,55 +131,6 @@ function copyStackTrace$1(target, source) {
   return target;
 }
 
-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");
-  return `expect(actual)${promiseName ? `.${promiseName}` : ""}.${not}${name}`;
-}
-function recordAsyncExpect(_test, promise, assertion, error) {
-  const test = _test;
-  // record promise for test, that resolves before test ends
-  if (test && promise instanceof Promise) {
-    // if promise is explicitly awaited, remove it from the list
-    promise = promise.finally(() => {
-      if (!test.promises) return;
-      const index = test.promises.indexOf(promise);
-      if (index !== -1) test.promises.splice(index, 1);
-    });
-    // record promise
-    if (!test.promises) test.promises = [];
-    test.promises.push(promise);
-    let resolved = false;
-    test.onFinished ??= [];
-    test.onFinished.push(() => {
-      if (!resolved) {
-        const stack = (globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""))(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(onFulfilled, onRejected) {
-        resolved = true;
-        return promise.then(onFulfilled, onRejected);
-      },
-      catch(onRejected) {
-        return promise.catch(onRejected);
-      },
-      finally(onFinally) {
-        return promise.finally(onFinally);
-      },
-      [Symbol.toStringTag]: "Promise"
-    };
-  }
-  return promise;
-}
-
 let _client;
 function getSnapshotClient() {
   if (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {
@@ -197,7 +164,7 @@ const SnapshotPlugin = (chai, utils) => {
     if (!test) throw new Error(`'${assertionName}' cannot be used without test context`);
     return test;
   }
-  for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, wrapAssertion(utils, key, function(properties, message) {
     utils.flag(this, "_name", key);
     if (utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
     const expected = utils.flag(this, "object");
@@ -215,7 +182,7 @@ const SnapshotPlugin = (chai, utils) => {
       errorMessage,
       ...getTestNames(test)
     });
-  });
+  }));
   utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
     utils.flag(this, "_name", "toMatchFileSnapshot");
     if (utils.flag(this, "negate")) throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
@@ -230,13 +197,12 @@ const SnapshotPlugin = (chai, utils) => {
       rawSnapshot: { file },
       errorMessage,
       ...getTestNames(test)
-    }), createAssertionMessage(utils, this), error);
+    }), createAssertionMessage(utils, this, true), error, utils.flag(this, "soft"));
   });
-  utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+  utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", wrapAssertion(utils, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(properties, inlineSnapshot, message) {
     utils.flag(this, "_name", "toMatchInlineSnapshot");
     if (utils.flag(this, "negate")) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
     const test = getTest("toMatchInlineSnapshot", this);
-    if (test.each || test.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
     const expected = utils.flag(this, "object");
     const error = utils.flag(this, "error");
     if (typeof properties === "string") {
@@ -256,8 +222,8 @@ const SnapshotPlugin = (chai, utils) => {
       errorMessage,
       ...getTestNames(test)
     });
-  });
-  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
+  }));
+  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", wrapAssertion(utils, "toThrowErrorMatchingSnapshot", function(properties, message) {
     utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
     if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingSnapshot cannot be used with \"not\"");
     const expected = utils.flag(this, "object");
@@ -270,11 +236,10 @@ const SnapshotPlugin = (chai, utils) => {
       errorMessage,
       ...getTestNames(test)
     });
-  });
-  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+  }));
+  utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", wrapAssertion(utils, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshot, message) {
     if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
     const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
-    if (test.each || test.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
     const expected = utils.flag(this, "object");
     const error = utils.flag(this, "error");
     const promise = utils.flag(this, "promise");
@@ -289,12 +254,13 @@ const SnapshotPlugin = (chai, utils) => {
       errorMessage,
       ...getTestNames(test)
     });
-  });
+  }));
   utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
 
 chai.use(JestExtend);
 chai.use(JestChaiExpect);
+chai.use(ChaiStyleAssertions);
 chai.use(SnapshotPlugin);
 chai.use(JestAsymmetricMatchers);
 
@@ -1326,6 +1292,30 @@ function requireFakeTimersSrc () {
       }
   }
 
+  /**
+   * @typedef {"nextAsync" | "manual" | "interval"} TickMode
+   */
+
+  /**
+   * @typedef {object} NextAsyncTickMode
+   * @property {"nextAsync"} mode
+   */
+
+  /**
+   * @typedef {object} ManualTickMode
+   * @property {"manual"} mode
+   */
+
+  /**
+   * @typedef {object} IntervalTickMode
+   * @property {"interval"} mode
+   * @property {number} [delta]
+   */
+
+  /**
+   * @typedef {IntervalTickMode | NextAsyncTickMode | ManualTickMode} TimerTickMode
+   */
+
   /**
    * @typedef {object} IdleDeadline
    * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout
@@ -1411,6 +1401,7 @@ function requireFakeTimersSrc () {
    * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods
    * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods
    * @property {Map<function(): void, AbortSignal>} abortListenerMap
+   * @property {function(TimerTickMode): void} setTickMode
    */
   /* eslint-enable jsdoc/require-property-description */
 
@@ -2208,10 +2199,9 @@ function requireFakeTimersSrc () {
 
       /**
        * @param {Clock} clock
-       * @param {Config} config
        * @returns {Timer[]}
        */
-      function uninstall(clock, config) {
+      function uninstall(clock) {
           let method, i, l;
           const installedHrTime = "_hrtime";
           const installedNextTick = "_nextTick";
@@ -2269,9 +2259,7 @@ function requireFakeTimersSrc () {
               }
           }
 
-          if (config.shouldAdvanceTime === true) {
-              _global.clearInterval(clock.attachedInterval);
-          }
+          clock.setTickMode("manual");
 
           // Prevent multiple executions which will completely remove these props
           clock.methods = [];
@@ -2427,6 +2415,8 @@ function requireFakeTimersSrc () {
       }
 
       const originalSetTimeout = _global.setImmediate || _global.setTimeout;
+      const originalClearInterval = _global.clearInterval;
+      const originalSetInterval = _global.setInterval;
 
       /**
        * @param {Date|number} [start] the system time - non-integer values are floored
@@ -2445,6 +2435,7 @@ function requireFakeTimersSrc () {
               now: start,
               Date: createDate(),
               loopLimit: loopLimit,
+              tickMode: { mode: "manual", counter: 0, delta: undefined },
           };
 
           clock.Date.clock = clock;
@@ -2511,6 +2502,74 @@ function requireFakeTimersSrc () {
               clock.Intl.clock = clock;
           }
 
+          /**
+           * @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.
+           */
+          clock.setTickMode = function (tickModeConfig) {
+              const { mode: newMode, delta: newDelta } = tickModeConfig;
+              const { mode: oldMode, delta: oldDelta } = clock.tickMode;
+              if (newMode === oldMode && newDelta === oldDelta) {
+                  return;
+              }
+
+              if (oldMode === "interval") {
+                  originalClearInterval(clock.attachedInterval);
+              }
+
+              clock.tickMode = {
+                  counter: clock.tickMode.counter + 1,
+                  mode: newMode,
+                  delta: newDelta,
+              };
+
+              if (newMode === "nextAsync") {
+                  advanceUntilModeChanges();
+              } else if (newMode === "interval") {
+                  createIntervalTick(clock, newDelta || 20);
+              }
+          };
+
+          async function advanceUntilModeChanges() {
+              async function newMacrotask() {
+                  // MessageChannel ensures that setTimeout is not throttled to 4ms.
+                  // https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#reasons_for_delays_longer_than_specified
+                  // https://stackblitz.com/edit/stackblitz-starters-qtlpcc
+                  const channel = new MessageChannel();
+                  await new Promise((resolve) => {
+                      channel.port1.onmessage = () => {
+                          resolve();
+                          channel.port1.close();
+                      };
+                      channel.port2.postMessage(undefined);
+                  });
+                  channel.port1.close();
+                  channel.port2.close();
+                  // setTimeout ensures microtask queue is emptied
+                  await new Promise((resolve) => {
+                      originalSetTimeout(resolve);
+                  });
+              }
+
+              const { counter } = clock.tickMode;
+              while (clock.tickMode.counter === counter) {
+                  await newMacrotask();
+                  if (clock.tickMode.counter !== counter) {
+                      return;
+                  }
+                  clock.next();
+              }
+          }
+
+          function pauseAutoTickUntilFinished(promise) {
+              if (clock.tickMode.mode !== "nextAsync") {
+                  return promise;
+              }
+              clock.setTickMode({ mode: "manual" });
+              return promise.finally(() => {
+                  clock.setTickMode({ mode: "nextAsync" });
+              });
+          }
+
           clock.requestIdleCallback = function requestIdleCallback(
               func,
               timeout,
@@ -2809,15 +2868,17 @@ function requireFakeTimersSrc () {
                * @returns {Promise}
                */
               clock.tickAsync = function tickAsync(tickValue) {
-                  return new _global.Promise(function (resolve, reject) {
-                      originalSetTimeout(function () {
-                          try {
-                              doTick(tickValue, true, resolve, reject);
-                          } catch (e) {
-                              reject(e);
-                          }
-                      });
-                  });
+                  return pauseAutoTickUntilFinished(
+                      new _global.Promise(function (resolve, reject) {
+                          originalSetTimeout(function () {
+                              try {
+                                  doTick(tickValue, true, resolve, reject);
+                              } catch (e) {
+                                  reject(e);
+                              }
+                          });
+                      }),
+                  );
               };
           }
 
@@ -2841,37 +2902,39 @@ function requireFakeTimersSrc () {
 
           if (typeof _global.Promise !== "undefined") {
               clock.nextAsync = function nextAsync() {
-                  return new _global.Promise(function (resolve, reject) {
-                      originalSetTimeout(function () {
-                          try {
-                              const timer = firstTimer(clock);
-                              if (!timer) {
-                                  resolve(clock.now);
-                                  return;
-                              }
-
-                              let err;
-                              clock.duringTick = true;
-                              clock.now = timer.callAt;
+                  return pauseAutoTickUntilFinished(
+                      new _global.Promise(function (resolve, reject) {
+                          originalSetTimeout(function () {
                               try {
-                                  callTimer(clock, timer);
-                              } catch (e) {
-                                  err = e;
-                              }
-                              clock.duringTick = false;
-
-                              originalSetTimeout(function () {
-                                  if (err) {
-                                      reject(err);
-                                  } else {
+                                  const timer = firstTimer(clock);
+                                  if (!timer) {
                                       resolve(clock.now);
+                                      return;
                                   }
-                              });
-                          } catch (e) {
-                              reject(e);
-                          }
-                      });
-                  });
+
+                                  let err;
+                                  clock.duringTick = true;
+                                  clock.now = timer.callAt;
+                                  try {
+                                      callTimer(clock, timer);
+                                  } catch (e) {
+                                      err = e;
+                                  }
+                                  clock.duringTick = false;
+
+                                  originalSetTimeout(function () {
+                                      if (err) {
+                                          reject(err);
+                                      } else {
+                                          resolve(clock.now);
+                                      }
+                                  });
+                              } catch (e) {
+                                  reject(e);
+                              }
+                          });
+                      }),
+                  );
               };
           }
 
@@ -2904,51 +2967,55 @@ function requireFakeTimersSrc () {
 
           if (typeof _global.Promise !== "undefined") {
               clock.runAllAsync = function runAllAsync() {
-                  return new _global.Promise(function (resolve, reject) {
-                      let i = 0;
-                      /**
-                       *
-                       */
-                      function doRun() {
-                          originalSetTimeout(function () {
-                              try {
-                                  runJobs(clock);
-
-                                  let numTimers;
-                                  if (i < clock.loopLimit) {
-                                      if (!clock.timers) {
-                                          resetIsNearInfiniteLimit();
-                                          resolve(clock.now);
-                                          return;
-                                      }
-
-                                      numTimers = Object.keys(
-                                          clock.timers,
-                                      ).length;
-                                      if (numTimers === 0) {
-                                          resetIsNearInfiniteLimit();
-                                          resolve(clock.now);
+                  return pauseAutoTickUntilFinished(
+                      new _global.Promise(function (resolve, reject) {
+                          let i = 0;
+                          /**
+                           *
+                           */
+                          function doRun() {
+                              originalSetTimeout(function () {
+                                  try {
+                                      runJobs(clock);
+
+                                      let numTimers;
+                                      if (i < clock.loopLimit) {
+                                          if (!clock.timers) {
+                                              resetIsNearInfiniteLimit();
+                                              resolve(clock.now);
+                                              return;
+                                          }
+
+                                          numTimers = Object.keys(
+                                              clock.timers,
+                                          ).length;
+                                          if (numTimers === 0) {
+                                              resetIsNearInfiniteLimit();
+                                              resolve(clock.now);
+                                              return;
+                                          }
+
+                                          clock.next();
+
+                                          i++;
+
+                                          doRun();
+                                          checkIsNearInfiniteLimit(clock, i);
                                           return;
                                       }
 
-                                      clock.next();
-
-                                      i++;
-
-                                      doRun();
-                                      checkIsNearInfiniteLimit(clock, i);
-                                      return;
+                                      const excessJob = firstTimer(clock);
+                                      reject(
+                                          getInfiniteLoopError(clock, excessJob),
+                                      );
+                                  } catch (e) {
+                                      reject(e);
                                   }
-
-                                  const excessJob = firstTimer(clock);
-                                  reject(getInfiniteLoopError(clock, excessJob));
-                              } catch (e) {
-                                  reject(e);
-                              }
-                          });
-                      }
-                      doRun();
-                  });
+                              });
+                          }
+                          doRun();
+                      }),
+                  );
               };
           }
 
@@ -2964,21 +3031,25 @@ function requireFakeTimersSrc () {
 
           if (typeof _global.Promise !== "undefined") {
               clock.runToLastAsync = function runToLastAsync() {
-                  return new _global.Promise(function (resolve, reject) {
-                      originalSetTimeout(function () {
-                          try {
-                              const timer = lastTimer(clock);
-                              if (!timer) {
-                                  runJobs(clock);
-                                  resolve(clock.now);
-                              }
+                  return pauseAutoTickUntilFinished(
+                      new _global.Promise(function (resolve, reject) {
+                          originalSetTimeout(function () {
+                              try {
+                                  const timer = lastTimer(clock);
+                                  if (!timer) {
+                                      runJobs(clock);
+                                      resolve(clock.now);
+                                  }
 
-                              resolve(clock.tickAsync(timer.callAt - clock.now));
-                          } catch (e) {
-                              reject(e);
-                          }
-                      });
-                  });
+                                  resolve(
+                                      clock.tickAsync(timer.callAt - clock.now),
+                                  );
+                              } catch (e) {
+                                  reject(e);
+                              }
+                          });
+                      }),
+                  );
               };
           }
 
@@ -3042,6 +3113,12 @@ function requireFakeTimersSrc () {
           return clock;
       }
 
+      function createIntervalTick(clock, delta) {
+          const intervalTick = doIntervalTick.bind(null, clock, delta);
+          const intervalId = originalSetInterval(intervalTick, delta);
+          clock.attachedInterval = intervalId;
+      }
+
       /* eslint-disable complexity */
 
       /**
@@ -3102,7 +3179,7 @@ function requireFakeTimersSrc () {
           clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
 
           clock.uninstall = function () {
-              return uninstall(clock, config);
+              return uninstall(clock);
           };
 
           clock.abortListenerMap = new Map();
@@ -3114,16 +3191,10 @@ function requireFakeTimersSrc () {
           }
 
           if (config.shouldAdvanceTime === true) {
-              const intervalTick = doIntervalTick.bind(
-                  null,
-                  clock,
-                  config.advanceTimeDelta,
-              );
-              const intervalId = _global.setInterval(
-                  intervalTick,
-                  config.advanceTimeDelta,
-              );
-              clock.attachedInterval = intervalId;
+              clock.setTickMode({
+                  mode: "interval",
+                  delta: config.advanceTimeDelta,
+              });
           }
 
           if (clock.methods.includes("performance")) {
@@ -3535,9 +3606,7 @@ class FakeTimers {
     if (this._checkFakeTimers()) this._clock.runToFrame();
   }
   runAllTicks() {
-    if (this._checkFakeTimers())
- // @ts-expect-error method not exposed
-    this._clock.runMicrotasks();
+    if (this._checkFakeTimers()) this._clock.runMicrotasks();
   }
   useRealTimers() {
     if (this._fakingDate) {
@@ -3591,6 +3660,15 @@ class FakeTimers {
     if (this._checkFakeTimers()) return this._clock.countTimers();
     return 0;
   }
+  setTimerTickMode(mode, interval) {
+    if (this._checkFakeTimers()) if (mode === "manual") this._clock.setTickMode({ mode: "manual" });
+    else if (mode === "nextTimerAsync") this._clock.setTickMode({ mode: "nextAsync" });
+    else if (mode === "interval") this._clock.setTickMode({
+      mode: "interval",
+      delta: interval
+    });
+    else throw new Error(`Invalid tick mode: ${mode}`);
+  }
   configure(config) {
     this._userConfig = config;
   }
@@ -3793,10 +3871,23 @@ function createVitest() {
       timers().clearAllTimers();
       return utils;
     },
+    setTimerTickMode(mode, interval) {
+      timers().setTimerTickMode(mode, interval);
+      return utils;
+    },
     spyOn,
     fn,
     waitFor,
     waitUntil,
+    defineHelper: (fn) => {
+      return function __VITEST_HELPER__(...args) {
+        const result = fn(...args);
+        if (result && typeof result === "object" && typeof result.then === "function") return (async function __VITEST_HELPER__() {
+          return await result;
+        })();
+        return result;
+      };
+    },
     hoisted(factory) {
       assertTypes(factory, "\"vi.hoisted\" factory", ["function"]);
       return factory();
@@ -3814,6 +3905,11 @@ function createVitest() {
       if (typeof path !== "string") throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
       const importer = getImporter("doMock");
       _mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
+      const rv = {};
+      if (Symbol.dispose) rv[Symbol.dispose] = () => {
+        _mocker().queueUnmock(path, importer);
+      };
+      return rv;
     },
     doUnmock(path) {
       if (typeof path !== "string") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
@@ -3916,4 +4012,265 @@ function getImporter(name) {
   }) + 1])?.file || "";
 }
 
-export { getSnapshotClient as a, assert as b, createExpect as c, vitest as d, globalExpect as g, inject as i, should as s, vi as v };
+function createBenchmarkResult(name) {
+  return {
+    name,
+    rank: 0,
+    rme: 0,
+    samples: []
+  };
+}
+const benchmarkTasks = /* @__PURE__ */ new WeakMap();
+async function runBenchmarkSuite(suite, runner) {
+  const { Task, Bench } = await runner.importTinybench();
+  const start = performance.now();
+  const benchmarkGroup = [];
+  const benchmarkSuiteGroup = [];
+  for (const task of suite.tasks) {
+    if (task.mode !== "run" && task.mode !== "queued") continue;
+    if (task.meta?.benchmark) benchmarkGroup.push(task);
+    else if (task.type === "suite") benchmarkSuiteGroup.push(task);
+  }
+  // run sub suites sequentially
+  for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
+  if (benchmarkGroup.length) {
+    const defer = createDefer();
+    suite.result = {
+      state: "run",
+      startTime: start,
+      benchmark: createBenchmarkResult(suite.name)
+    };
+    updateTask$1("suite-prepare", suite);
+    const addBenchTaskListener = (task, benchmark) => {
+      task.addEventListener("complete", (e) => {
+        const taskRes = e.task.result;
+        const result = benchmark.result.benchmark;
+        benchmark.result.state = "pass";
+        Object.assign(result, taskRes);
+        // compute extra stats and free raw samples as early as possible
+        const samples = result.samples;
+        result.sampleCount = samples.length;
+        result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
+        if (!runner.config.benchmark?.includeSamples) result.samples.length = 0;
+        updateTask$1("test-finished", benchmark);
+      }, { once: true });
+      task.addEventListener("error", (e) => {
+        const task = e.task;
+        defer.reject(benchmark ? task.result.error : e);
+      }, { once: true });
+    };
+    benchmarkGroup.forEach((benchmark) => {
+      const benchmarkInstance = new Bench(getBenchOptions(benchmark));
+      const benchmarkFn = getBenchFn(benchmark);
+      benchmark.result = {
+        state: "run",
+        startTime: start,
+        benchmark: createBenchmarkResult(benchmark.name)
+      };
+      const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
+      benchmarkTasks.set(benchmark, task);
+      addBenchTaskListener(task, benchmark);
+    });
+    const { setTimeout } = getSafeTimers();
+    const tasks = [];
+    for (const benchmark of benchmarkGroup) {
+      const task = benchmarkTasks.get(benchmark);
+      updateTask$1("test-prepare", benchmark);
+      await task.warmup();
+      tasks.push([await new Promise((resolve) => setTimeout(async () => {
+        resolve(await task.run());
+      })), benchmark]);
+    }
+    suite.result.duration = performance.now() - start;
+    suite.result.state = "pass";
+    updateTask$1("suite-finished", suite);
+    defer.resolve(null);
+    await defer;
+  }
+  function updateTask$1(event, task) {
+    updateTask(event, task, runner);
+  }
+}
+class NodeBenchmarkRunner {
+  moduleRunner;
+  constructor(config) {
+    this.config = config;
+  }
+  async importTinybench() {
+    return await import('../vendor/tinybench.mjs');
+  }
+  importFile(filepath, source) {
+    if (source === "setup") {
+      const moduleNode = getWorkerState().evaluatedModules.getModuleById(filepath);
+      if (moduleNode) getWorkerState().evaluatedModules.invalidateModule(moduleNode);
+    }
+    return this.moduleRunner.import(filepath);
+  }
+  async runSuite(suite) {
+    await runBenchmarkSuite(suite, this);
+  }
+  async runTask() {
+    throw new Error("`test()` and `it()` is only available in test mode.");
+  }
+}
+
+class TestRunner {
+  snapshotClient = getSnapshotClient();
+  workerState = getWorkerState();
+  moduleRunner;
+  cancelRun = false;
+  assertionsErrors = /* @__PURE__ */ new WeakMap();
+  pool = this.workerState.ctx.pool;
+  _otel;
+  viteEnvironment;
+  viteModuleRunner;
+  constructor(config) {
+    this.config = config;
+    const environment = this.workerState.environment;
+    this.viteEnvironment = environment.viteEnvironment || environment.name;
+    this.viteModuleRunner = config.experimental.viteModuleRunner;
+  }
+  importFile(filepath, source) {
+    if (source === "setup") {
+      const moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);
+      if (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);
+    }
+    return this._otel.$(`vitest.module.import_${source === "setup" ? "setup" : "spec"}`, { attributes: { "code.file.path": filepath } }, () => {
+      if (!this.viteModuleRunner) filepath = `${filepath}?vitest=${Date.now()}`;
+      return this.moduleRunner.import(filepath);
+    });
+  }
+  onCollectStart(file) {
+    this.workerState.current = file;
+  }
+  onCleanupWorkerContext(listener) {
+    this.workerState.onCleanup(listener);
+  }
+  onAfterRunFiles() {
+    this.snapshotClient.clear();
+    this.workerState.current = void 0;
+  }
+  async onAfterRunSuite(suite) {
+    if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
+    if (suite.mode !== "skip" && "filepath" in suite) {
+      // mark snapshots in skipped tests as not obsolete
+      for (const test of getTests(suite)) if (test.mode === "skip") {
+        const name = getNames(test).slice(1).join(" > ");
+        this.snapshotClient.skipTest(suite.file.filepath, name);
+      }
+      const result = await this.snapshotClient.finish(suite.file.filepath);
+      if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
+        let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
+        for (const key of result.uncheckedKeys) message += `· ${key}\n`;
+        suite.result.errors ??= [];
+        suite.result.errors.push(processError(new Error(message)));
+        suite.result.state = "fail";
+      }
+      await rpc().snapshotSaved(result);
+    }
+    this.workerState.current = suite.suite || suite.file;
+  }
+  onAfterRunTask(test) {
+    if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
+    this.workerState.current = test.suite || test.file;
+  }
+  cancel(_reason) {
+    this.cancelRun = true;
+  }
+  injectValue(key) {
+    // inject has a very limiting type controlled by ProvidedContext
+    // some tests override it which causes the build to fail
+    return inject(key);
+  }
+  async onBeforeRunTask(test) {
+    if (this.cancelRun) test.mode = "skip";
+    if (test.mode !== "run" && test.mode !== "queued") return;
+    this.workerState.current = test;
+  }
+  async onBeforeRunSuite(suite) {
+    if (this.cancelRun) suite.mode = "skip";
+    // initialize snapshot state before running file suite
+    if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
+    this.workerState.current = suite;
+  }
+  onBeforeTryTask(test) {
+    clearModuleMocks(this.config);
+    this.snapshotClient.clearTest(test.file.filepath, test.id);
+    setState({
+      assertionCalls: 0,
+      isExpectingAssertions: false,
+      isExpectingAssertionsError: null,
+      expectedAssertionsNumber: null,
+      expectedAssertionsNumberErrorGen: null,
+      currentTestName: getTestName(test),
+      snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
+    }, globalThis[GLOBAL_EXPECT]);
+  }
+  onAfterTryTask(test) {
+    const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
+    if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
+    if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
+  }
+  extendTaskContext(context) {
+    // create error during the test initialization so we have a nice stack trace
+    if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
+    let _expect;
+    Object.defineProperty(context, "expect", { get() {
+      if (!_expect) _expect = createExpect(context.task);
+      return _expect;
+    } });
+    Object.defineProperty(context, "_local", { get() {
+      return _expect != null;
+    } });
+    return context;
+  }
+  getImportDurations() {
+    const { limit } = this.config.experimental.importDurations;
+    // skip sorting if limit is 0
+    if (limit === 0) return {};
+    // Sort by duration descending and keep top entries
+    const sortedEntries = [...this.workerState.moduleExecutionInfo?.entries() || []].sort(([, a], [, b]) => b.duration - a.duration).slice(0, limit);
+    const importDurations = {};
+    for (const [filepath, { duration, selfTime, external, importer }] of sortedEntries) importDurations[normalize(filepath)] = {
+      selfTime,
+      totalTime: duration,
+      external,
+      importer
+    };
+    return importDurations;
+  }
+  trace = (name, attributes, cb) => {
+    const options = typeof attributes === "object" ? { attributes } : {};
+    return this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);
+  };
+  __setTraces(traces) {
+    this._otel = traces;
+  }
+  static createTaskCollector = createTaskCollector;
+  static getCurrentSuite = getCurrentSuite;
+  static getCurrentTest = getCurrentTest;
+  static createChainable = createChainable;
+  static getSuiteHooks = getHooks;
+  static getTestFn = getFn;
+  static setSuiteHooks = getHooks;
+  static setTestFn = getFn;
+  /**
+  * @deprecated
+  */
+  static getBenchFn = getBenchFn;
+  /**
+  * @deprecated
+  */
+  static getBenchOptions = getBenchOptions;
+}
+function clearModuleMocks(config) {
+  const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+  if (restoreMocks) vi.restoreAllMocks();
+  if (mockReset) vi.resetAllMocks();
+  if (clearMocks) vi.clearAllMocks();
+  if (unstubEnvs) vi.unstubAllEnvs();
+  if (unstubGlobals) vi.unstubAllGlobals();
+}
+
+export { NodeBenchmarkRunner as N, TestRunner as T, assert as a, vitest as b, createExpect as c, globalExpect as g, inject as i, should as s, vi as v };