@vitest/runner 3.0.0-beta.4 → 3.0.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { B as BeforeAllListener, A as AfterAllListener, b as BeforeEachListener, d as AfterEachListener, e as TaskHook, O as OnTestFailedHandler, f as OnTestFinishedHandler, a as Test, g as Custom, S as Suite, h as SuiteHooks, T as Task, F as File, i as SuiteAPI, j as TestAPI, k as SuiteCollector } from './tasks-B64RTJlW.js';
-export { D as DoneCallback, E as ExtendedContext, l as Fixture, m as FixtureFn, n as FixtureOptions, o as Fixtures, H as HookCleanupCallback, p as HookListener, I as InferFixturesTypes, R as RunMode, q as RuntimeContext, r as SequenceHooks, s as SequenceSetupFiles, t as SuiteFactory, u as TaskBase, v as TaskContext, w as TaskCustomOptions, x as TaskMeta, y as TaskPopulated, z as TaskResult, G as TaskResultPack, J as TaskState, K as TestContext, L as TestFunction, M as TestOptions, U as Use } from './tasks-B64RTJlW.js';
+import { B as BeforeAllListener, A as AfterAllListener, b as BeforeEachListener, d as AfterEachListener, e as TaskHook, O as OnTestFailedHandler, f as OnTestFinishedHandler, a as Test, g as Custom, S as Suite, h as SuiteHooks, i as TaskUpdateEvent, T as Task, F as File, j as SuiteAPI, k as TestAPI, l as SuiteCollector } from './tasks-CUXfn9LM.js';
+export { D as DoneCallback, E as ExtendedContext, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, H as HookCleanupCallback, q as HookListener, I as InferFixturesTypes, R as RunMode, r as RuntimeContext, s as SequenceHooks, t as SequenceSetupFiles, u as SuiteFactory, v as TaskBase, w as TaskContext, x as TaskCustomOptions, y as TaskEventPack, z as TaskMeta, G as TaskPopulated, J as TaskResult, K as TaskResultPack, L as TaskState, M as TestContext, N as TestFunction, P as TestOptions, U as Use } from './tasks-CUXfn9LM.js';
 import { Awaitable } from '@vitest/utils';
 import { VitestRunner, FileSpecification } from './types.js';
 export { CancelReason, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource } from './types.js';
@@ -105,6 +105,8 @@ declare const onTestFailed: TaskHook<OnTestFailedHandler>;
  *
  * **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
  *
+ * **Note:** The `onTestFinished` hook is not called if the test is canceled with a dynamic `ctx.skip()` call.
+ *
  * @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
  * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
  * @throws {Error} Throws an error if the function is not called within a test.
@@ -125,7 +127,7 @@ declare function getFn<Task = Test | Custom>(key: Task): () => Awaitable<void>;
 declare function setHooks(key: Suite, hooks: SuiteHooks): void;
 declare function getHooks(key: Suite): SuiteHooks;
 
-declare function updateTask(task: Task, runner: VitestRunner): void;
+declare function updateTask(event: TaskUpdateEvent, task: Task, runner: VitestRunner): void;
 declare function startTests(specs: string[] | FileSpecification[], runner: VitestRunner): Promise<File[]>;
 declare function publicCollect(specs: string[] | FileSpecification[], runner: VitestRunner): Promise<File[]>;
 
@@ -256,4 +258,4 @@ declare function createTaskCollector(fn: (...args: any[]) => any, context?: Reco
 
 declare function getCurrentTest<T extends Test | undefined>(): T;
 
-export { AfterAllListener, AfterEachListener, BeforeAllListener, BeforeEachListener, Custom, TestAPI as CustomAPI, File, FileSpecification, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, TaskHook, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };
+export { AfterAllListener, AfterEachListener, BeforeAllListener, BeforeEachListener, Custom, TestAPI as CustomAPI, File, FileSpecification, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, TaskHook, TaskUpdateEvent, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { getSafeTimers, isObject, createDefer, isNegativeNaN, format, objDisplay, objectAttr, toArray, assertTypes, shuffle } from '@vitest/utils';
+import { getSafeTimers, isObject, createDefer, toArray, isNegativeNaN, format, objDisplay, objectAttr, assertTypes, shuffle } from '@vitest/utils';
 import { parseSingleStack } from '@vitest/utils/source-map';
 import { c as createChainable, b as createFileTask, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, l as limitConcurrency, p as partitionSuiteChildren, o as hasTests, n as hasFailed } from './chunk-tasks.js';
 import { processError } from '@vitest/utils/error';
@@ -58,7 +58,8 @@ function createTestContext(test, runner) {
   };
   context.task = test;
   context.skip = (note) => {
-    test.pending = true;
+    test.result ?? (test.result = { state: "skip" });
+    test.result.pending = true;
     throw new PendingError("test is skipped; abort execution", test, note);
   };
   context.onTestFailed = (handler, timeout) => {
@@ -538,7 +539,7 @@ function createSuiteCollector(name, factory = () => {
 }
 function withAwaitAsyncAssertions(fn, task) {
   return async (...args) => {
-    await fn(...args);
+    const fnResult = await fn(...args);
     if (task.promises) {
       const result = await Promise.allSettled(task.promises);
       const errors = result.map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
@@ -546,6 +547,7 @@ function withAwaitAsyncAssertions(fn, task) {
         throw errors;
       }
     }
+    return fnResult;
   };
 }
 function createSuite() {
@@ -610,6 +612,18 @@ function createSuite() {
       this.setContext("each", void 0);
     };
   };
+  suiteFn.for = function(cases, ...args) {
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const name_ = formatName(name);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      cases.forEach((item, idx) => {
+        suite(formatTitle(name_, toArray(item), idx), options, () => handler(item));
+      });
+    };
+  };
   suiteFn.skipIf = (condition) => condition ? suite.skip : suite;
   suiteFn.runIf = (condition) => condition ? suite : suite.skip;
   return createChainable(
@@ -927,18 +941,25 @@ function mergeHooks(baseHooks, hooks) {
 
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const unixNow = Date.now;
-function updateSuiteHookState(suite, name, state, runner) {
-  var _a;
-  if (!suite.result) {
-    suite.result = { state: "run" };
+function updateSuiteHookState(task, name, state, runner) {
+  if (!task.result) {
+    task.result = { state: "run" };
   }
-  if (!((_a = suite.result) == null ? void 0 : _a.hooks)) {
-    suite.result.hooks = {};
+  if (!task.result.hooks) {
+    task.result.hooks = {};
   }
-  const suiteHooks = suite.result.hooks;
+  const suiteHooks = task.result.hooks;
   if (suiteHooks) {
     suiteHooks[name] = state;
-    updateTask(suite, runner);
+    let event = state === "run" ? "before-hook-start" : "before-hook-end";
+    if (name === "afterAll" || name === "afterEach") {
+      event = state === "run" ? "after-hook-start" : "after-hook-end";
+    }
+    updateTask(
+      event,
+      task,
+      runner
+    );
   }
 }
 function getSuiteHooks(suite, name, sequence) {
@@ -990,8 +1011,10 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
       ...await callSuiteHook(parentSuite, currentTask, name, runner, args)
     );
   }
-  updateSuiteHookState(currentTask, name, "run", runner);
   const hooks = getSuiteHooks(suite, name, sequence);
+  if (hooks.length > 0) {
+    updateSuiteHookState(currentTask, name, "run", runner);
+  }
   if (sequence === "parallel") {
     callbacks.push(
       ...await Promise.all(hooks.map((hook) => hook(...args)))
@@ -1001,7 +1024,9 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
       callbacks.push(await hook(...args));
     }
   }
-  updateSuiteHookState(currentTask, name, "pass", runner);
+  if (hooks.length > 0) {
+    updateSuiteHookState(currentTask, name, "pass", runner);
+  }
   if (name === "afterEach" && parentSuite) {
     callbacks.push(
       ...await callSuiteHook(parentSuite, currentTask, name, runner, args)
@@ -1010,9 +1035,11 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
   return callbacks;
 }
 const packs = /* @__PURE__ */ new Map();
+const eventsPacks = [];
 let updateTimer;
 let previousUpdate;
-function updateTask(task, runner) {
+function updateTask(event, task, runner) {
+  eventsPacks.push([task.id, event]);
   packs.set(task.id, [task.result, task.meta]);
   const { clearTimeout, setTimeout } = getSafeTimers();
   clearTimeout(updateTimer);
@@ -1029,7 +1056,8 @@ async function sendTasksUpdate(runner) {
     const taskPacks = Array.from(packs).map(([id, task]) => {
       return [id, task[0], task[1]];
     });
-    const p = (_a = runner.onTaskUpdate) == null ? void 0 : _a.call(runner, taskPacks);
+    const p = (_a = runner.onTaskUpdate) == null ? void 0 : _a.call(runner, taskPacks, eventsPacks);
+    eventsPacks.length = 0;
     packs.clear();
     return p;
   }
@@ -1045,13 +1073,13 @@ async function callCleanupHooks(cleanups) {
   );
 }
 async function runTest(test, runner) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   await ((_a = runner.onBeforeRunTask) == null ? void 0 : _a.call(runner, test));
   if (test.mode !== "run" && test.mode !== "queued") {
     return;
   }
   if (((_b = test.result) == null ? void 0 : _b.state) === "fail") {
-    updateTask(test, runner);
+    updateTask("test-failed-early", test, runner);
     return;
   }
   const start = now();
@@ -1060,7 +1088,7 @@ async function runTest(test, runner) {
     startTime: unixNow(),
     retryCount: 0
   };
-  updateTask(test, runner);
+  updateTask("test-prepare", test, runner);
   setCurrentTest(test);
   const suite = test.suite || test.file;
   const repeats = test.repeats ?? 0;
@@ -1106,15 +1134,15 @@ async function runTest(test, runner) {
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
       }
-      if (test.pending || ((_e = test.result) == null ? void 0 : _e.state) === "skip") {
+      if (((_e = test.result) == null ? void 0 : _e.pending) || ((_f = test.result) == null ? void 0 : _f.state) === "skip") {
         test.mode = "skip";
-        test.result = { state: "skip", note: (_f = test.result) == null ? void 0 : _f.note };
-        updateTask(test, runner);
+        test.result = { state: "skip", note: (_g = test.result) == null ? void 0 : _g.note, pending: true };
+        updateTask("test-finished", test, runner);
         setCurrentTest(void 0);
         return;
       }
       try {
-        await ((_g = runner.onTaskFinished) == null ? void 0 : _g.call(runner, test));
+        await ((_h = runner.onTaskFinished) == null ? void 0 : _h.call(runner, test));
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
       }
@@ -1137,8 +1165,8 @@ async function runTest(test, runner) {
           runner.config.sequence.hooks
         );
       }
-      delete test.onFailed;
-      delete test.onFinished;
+      test.onFailed = void 0;
+      test.onFinished = void 0;
       if (test.result.state === "pass") {
         break;
       }
@@ -1146,7 +1174,7 @@ async function runTest(test, runner) {
         test.result.state = "run";
         test.result.retryCount = (test.result.retryCount ?? 0) + 1;
       }
-      updateTask(test, runner);
+      updateTask("test-retried", test, runner);
     }
   }
   if (test.fails) {
@@ -1161,13 +1189,14 @@ async function runTest(test, runner) {
   }
   setCurrentTest(void 0);
   test.result.duration = now() - start;
-  await ((_h = runner.onAfterRunTask) == null ? void 0 : _h.call(runner, test));
-  updateTask(test, runner);
+  await ((_i = runner.onAfterRunTask) == null ? void 0 : _i.call(runner, test));
+  updateTask("test-finished", test, runner);
 }
 function failTask(result, err, diffOptions) {
   if (err instanceof PendingError) {
     result.state = "skip";
     result.note = err.note;
+    result.pending = true;
     return;
   }
   result.state = "fail";
@@ -1182,7 +1211,7 @@ function markTasksAsSkipped(suite, runner) {
   suite.tasks.forEach((t) => {
     t.mode = "skip";
     t.result = { ...t.result, state: "skip" };
-    updateTask(t, runner);
+    updateTask("test-finished", t, runner);
     if (t.type === "suite") {
       markTasksAsSkipped(t, runner);
     }
@@ -1193,20 +1222,23 @@ async function runSuite(suite, runner) {
   await ((_a = runner.onBeforeRunSuite) == null ? void 0 : _a.call(runner, suite));
   if (((_b = suite.result) == null ? void 0 : _b.state) === "fail") {
     markTasksAsSkipped(suite, runner);
-    updateTask(suite, runner);
+    updateTask("suite-failed-early", suite, runner);
     return;
   }
   const start = now();
+  const mode = suite.mode;
   suite.result = {
-    state: "run",
+    state: mode === "skip" || mode === "todo" ? mode : "run",
     startTime: unixNow()
   };
-  updateTask(suite, runner);
+  updateTask("suite-prepare", suite, runner);
   let beforeAllCleanups = [];
   if (suite.mode === "skip") {
     suite.result.state = "skip";
+    updateTask("suite-finished", suite, runner);
   } else if (suite.mode === "todo") {
     suite.result.state = "todo";
+    updateTask("suite-finished", suite, runner);
   } else {
     try {
       try {
@@ -1269,8 +1301,8 @@ async function runSuite(suite, runner) {
         suite.result.state = "pass";
       }
     }
-    updateTask(suite, runner);
     suite.result.duration = now() - start;
+    updateTask("suite-finished", suite, runner);
     await ((_d = runner.onAfterRunSuite) == null ? void 0 : _d.call(runner, suite));
   }
 }

package/dist/{tasks-B64RTJlW.d.ts → tasks-CUXfn9LM.d.ts}

@@ -94,10 +94,6 @@ interface TaskPopulated extends TaskBase {
      * File task. It's the root task of the file.
      */
     file: File;
-    /**
-     * Whether the task was skipped by calling `t.skip()`.
-     */
-    pending?: boolean;
     /**
      * Whether the task should succeed if it fails. If the task fails, it will be marked as passed.
      */
@@ -176,6 +172,17 @@ type TaskResultPack = [
      */
     meta: TaskMeta
 ];
+type TaskEventPack = [
+    /**
+     * Unique task identifier from `task.id`.
+     */
+    id: string,
+    /**
+     * The name of the event that triggered the update.
+     */
+    event: TaskUpdateEvent
+];
+type TaskUpdateEvent = 'test-failed-early' | 'suite-failed-early' | 'test-prepare' | 'test-finished' | 'test-retried' | 'suite-prepare' | 'suite-finished' | 'before-hook-start' | 'before-hook-end' | 'after-hook-start' | 'after-hook-end';
 interface Suite extends TaskBase {
     type: 'suite';
     /**
@@ -263,6 +270,10 @@ interface TestForFunction<ExtraContext> {
     <T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, TestContext & ExtraContext>;
     (strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, TestContext & ExtraContext>;
 }
+interface SuiteForFunction {
+    <T>(cases: ReadonlyArray<T>): EachFunctionReturn<[T]>;
+    (...args: [TemplateStringsArray, ...any]): EachFunctionReturn<any[]>;
+}
 interface TestCollectorCallable<C = object> {
     /**
      * @deprecated Use options as the second argument instead
@@ -363,6 +374,7 @@ interface SuiteCollectorCallable<ExtraContext = object> {
 }
 type ChainableSuiteAPI<ExtraContext = object> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'shuffle', SuiteCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
+    for: SuiteForFunction;
 }>;
 type SuiteAPI<ExtraContext = object> = ChainableSuiteAPI<ExtraContext> & {
     skipIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
@@ -469,4 +481,4 @@ interface TaskHook<HookListener> {
 type SequenceHooks = 'stack' | 'list' | 'parallel';
 type SequenceSetupFiles = 'list' | 'parallel';
 
-export { type AfterAllListener as A, type BeforeAllListener as B, type ChainableFunction as C, type DoneCallback as D, type ExtendedContext as E, type File as F, type TaskResultPack as G, type HookCleanupCallback as H, type InferFixturesTypes as I, type TaskState as J, type TestContext as K, type TestFunction as L, type TestOptions as M, type OnTestFailedHandler as O, type RunMode as R, type Suite as S, type Task as T, type Use as U, type Test as a, type BeforeEachListener as b, createChainable as c, type AfterEachListener as d, type TaskHook as e, type OnTestFinishedHandler as f, type Custom as g, type SuiteHooks as h, type SuiteAPI as i, type TestAPI as j, type SuiteCollector as k, type Fixture as l, type FixtureFn as m, type FixtureOptions as n, type Fixtures as o, type HookListener as p, type RuntimeContext as q, type SequenceHooks as r, type SequenceSetupFiles as s, type SuiteFactory as t, type TaskBase as u, type TaskContext as v, type TaskCustomOptions as w, type TaskMeta as x, type TaskPopulated as y, type TaskResult as z };
+export { type AfterAllListener as A, type BeforeAllListener as B, type ChainableFunction as C, type DoneCallback as D, type ExtendedContext as E, type File as F, type TaskPopulated as G, type HookCleanupCallback as H, type InferFixturesTypes as I, type TaskResult as J, type TaskResultPack as K, type TaskState as L, type TestContext as M, type TestFunction as N, type OnTestFailedHandler as O, type TestOptions as P, type RunMode as R, type Suite as S, type Task as T, type Use as U, type Test as a, type BeforeEachListener as b, createChainable as c, type AfterEachListener as d, type TaskHook as e, type OnTestFinishedHandler as f, type Custom as g, type SuiteHooks as h, type TaskUpdateEvent as i, type SuiteAPI as j, type TestAPI as k, type SuiteCollector as l, type Fixture as m, type FixtureFn as n, type FixtureOptions as o, type Fixtures as p, type HookListener as q, type RuntimeContext as r, type SequenceHooks as s, type SequenceSetupFiles as t, type SuiteFactory as u, type TaskBase as v, type TaskContext as w, type TaskCustomOptions as x, type TaskEventPack as y, type TaskMeta as z };

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { DiffOptions } from '@vitest/utils/diff';
-import { r as SequenceHooks, s as SequenceSetupFiles, F as File, T as Task, a as Test, S as Suite, G as TaskResultPack, K as TestContext } from './tasks-B64RTJlW.js';
-export { A as AfterAllListener, d as AfterEachListener, B as BeforeAllListener, b as BeforeEachListener, g as Custom, j as CustomAPI, D as DoneCallback, E as ExtendedContext, l as Fixture, m as FixtureFn, n as FixtureOptions, o as Fixtures, H as HookCleanupCallback, p as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, f as OnTestFinishedHandler, R as RunMode, q as RuntimeContext, i as SuiteAPI, k as SuiteCollector, t as SuiteFactory, h as SuiteHooks, u as TaskBase, v as TaskContext, w as TaskCustomOptions, e as TaskHook, x as TaskMeta, y as TaskPopulated, z as TaskResult, J as TaskState, j as TestAPI, L as TestFunction, M as TestOptions, U as Use } from './tasks-B64RTJlW.js';
+import { s as SequenceHooks, t as SequenceSetupFiles, F as File, T as Task, a as Test, S as Suite, K as TaskResultPack, y as TaskEventPack, M as TestContext } from './tasks-CUXfn9LM.js';
+export { A as AfterAllListener, d as AfterEachListener, B as BeforeAllListener, b as BeforeEachListener, g as Custom, k as CustomAPI, D as DoneCallback, E as ExtendedContext, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, H as HookCleanupCallback, q as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, f as OnTestFinishedHandler, R as RunMode, r as RuntimeContext, j as SuiteAPI, l as SuiteCollector, u as SuiteFactory, h as SuiteHooks, v as TaskBase, w as TaskContext, x as TaskCustomOptions, e as TaskHook, z as TaskMeta, G as TaskPopulated, J as TaskResult, L as TaskState, i as TaskUpdateEvent, k as TestAPI, N as TestFunction, P as TestOptions, U as Use } from './tasks-CUXfn9LM.js';
 import '@vitest/utils';
 
 /**
@@ -108,7 +108,7 @@ interface VitestRunner {
     /**
      * Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
      */
-    onTaskUpdate?: (task: TaskResultPack[]) => Promise<void>;
+    onTaskUpdate?: (task: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
     /**
      * Called before running all tests in collected paths.
      */
@@ -142,4 +142,4 @@ interface VitestRunner {
     pool?: string;
 }
 
-export { type CancelReason, File, type FileSpecification, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskResultPack, Test, TestContext, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };
+export { type CancelReason, File, type FileSpecification, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskEventPack, TaskResultPack, Test, TestContext, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, F as File, T as Task, a as Test } from './tasks-B64RTJlW.js';
-export { C as ChainableFunction, c as createChainable } from './tasks-B64RTJlW.js';
+import { S as Suite, F as File, T as Task, a as Test } from './tasks-CUXfn9LM.js';
+export { C as ChainableFunction, c as createChainable } from './tasks-CUXfn9LM.js';
 import { Arrayable } from '@vitest/utils';
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "3.0.0-beta.4",
+  "version": "3.0.0",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "pathe": "^2.0.0",
-    "@vitest/utils": "3.0.0-beta.4"
+    "@vitest/utils": "3.0.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",