@nuxt/test-utils-nightly 3.21.1-20251220-095456-4c8a3b7 → 3.21.1-20251231-212503-838ed8b

package/dist/config.d.mts

@@ -1,9 +1,8 @@
-import * as vite from 'vite';
-import { UserConfig } from 'vite';
 import { NuxtConfig, Nuxt } from '@nuxt/schema';
 import { InlineConfig } from 'vitest/node';
 import { TestProjectInlineConfiguration } from 'vitest/config';
 import { DotenvOptions } from 'c12';
+import { UserConfig, UserConfigFnPromise } from 'vite';
 
 interface GetVitestConfigOptions {
     nuxt: Nuxt;
@@ -19,7 +18,7 @@ declare function getVitestConfigFromNuxt(options?: GetVitestConfigOptions, loadN
 declare function defineVitestProject(config: TestProjectInlineConfiguration): Promise<TestProjectInlineConfiguration>;
 declare function defineVitestConfig(config?: UserConfig & {
     test?: InlineConfig;
-}): vite.UserConfigFnPromise;
+}): UserConfigFnPromise;
 interface NuxtEnvironmentOptions {
     rootDir?: string;
     /**

package/dist/config.mjs

@@ -3,7 +3,7 @@ import { defineConfig } from 'vite';
 import { setupDotenv } from 'c12';
 import { defu } from 'defu';
 import { createResolver, findPath } from '@nuxt/kit';
-import { a as applyEnv, l as loadKit } from './shared/test-utils-nightly.G1ew4kEe.mjs';
+import { a as applyEnv, l as loadKit } from './shared/test-utils-nightly.BIY9XRkB.mjs';
 import 'destr';
 import 'scule';
 import 'node:url';
@@ -91,7 +91,6 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
         noDiscovery: true
       },
       test: {
-        dir: process.cwd(),
         environmentOptions: {
           nuxtRuntimeConfig: applyEnv(structuredClone(options.nuxt.options.runtimeConfig), {
             prefix: "NUXT_",
@@ -188,14 +187,12 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
   return resolvedConfig;
 }
 async function defineVitestProject(config) {
-  if (process.env.__NUXT_VITEST_RESOLVED__) return config;
   const resolvedConfig = await resolveConfig(config);
   resolvedConfig.test.environment = "nuxt";
   return resolvedConfig;
 }
 function defineVitestConfig(config = {}) {
   return defineConfig(async () => {
-    if (process.env.__NUXT_VITEST_RESOLVED__) return config;
     const resolvedConfig = await resolveConfig(config);
     if (resolvedConfig.test.browser?.enabled) {
       return resolvedConfig;

package/dist/e2e.d.mts

@@ -1,5 +1,5 @@
-import { T as TestOptions, a as TestContext, b as TestHooks } from './shared/test-utils-nightly.20kU0tZa.mjs';
-export { $ as $fetch, G as GotoOptions, N as NuxtPage, S as StartServerOptions, h as TestRunner, c as createBrowser, d as createPage, f as fetch, g as getBrowser, s as startServer, e as stopServer, u as url, w as waitForHydration } from './shared/test-utils-nightly.20kU0tZa.mjs';
+import { T as TestOptions, b as TestContext, a as TestHooks } from './shared/test-utils-nightly.ZByFDqps.mjs';
+export { $ as $fetch, G as GotoOptions, N as NuxtPage, S as StartServerOptions, h as TestRunner, c as createBrowser, d as createPage, f as fetch, g as getBrowser, s as startServer, e as stopServer, u as url, w as waitForHydration } from './shared/test-utils-nightly.ZByFDqps.mjs';
 import { LogType } from 'consola';
 import 'playwright-core';
 import '@nuxt/schema';

package/dist/e2e.mjs

@@ -1,4 +1,4 @@
-export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils-nightly.BpHODLaZ.mjs';
+export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils-nightly.D0-o1nCe.mjs';
 import { u as useTestContext } from './shared/test-utils-nightly.C_clWQBc.mjs';
 export { $ as $fetch, c as createTestContext, e as exposeContextToEnv, f as fetch, i as isDev, r as recoverContextFromEnv, s as setTestContext, a as startServer, b as stopServer, d as url } from './shared/test-utils-nightly.C_clWQBc.mjs';
 import { consola } from 'consola';
@@ -7,7 +7,7 @@ import { distDir } from '#dirs';
 import 'node:fs';
 import 'node:path';
 import 'defu';
-import './shared/test-utils-nightly.G1ew4kEe.mjs';
+import './shared/test-utils-nightly.BIY9XRkB.mjs';
 import 'destr';
 import 'scule';
 import 'node:url';

package/dist/module.mjs

@@ -1,22 +1,20 @@
-import { pathToFileURL } from 'node:url';
-import { resolveIgnorePatterns, defineNuxtModule, createResolver, resolvePath, importModule, logger } from '@nuxt/kit';
-import { getPort } from 'get-port-please';
-import { h } from 'vue';
-import { debounce } from 'perfect-debounce';
-import { isCI } from 'std-env';
-import { defu } from 'defu';
-import { extname, join, dirname, relative } from 'pathe';
-import { getVitestConfigFromNuxt } from './config.mjs';
+import { resolveIgnorePatterns, useNuxt, addDevServerHandler, defineNuxtModule, createResolver, resolvePath, logger } from '@nuxt/kit';
+import { extname, join, dirname, resolve, relative } from 'pathe';
+import { provider, isCI } from 'std-env';
 import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 import { createUnplugin } from 'unplugin';
-import { l as loadKit } from './shared/test-utils-nightly.G1ew4kEe.mjs';
+import { l as loadKit } from './shared/test-utils-nightly.BIY9XRkB.mjs';
 import { readFileSync } from 'node:fs';
-import 'node:process';
-import 'vite';
-import 'c12';
+import { h } from 'vue';
+import { defineEventHandler } from 'h3';
+import { debounce } from 'perfect-debounce';
+import { fork } from 'node:child_process';
+import { c as createVitestTestSummary, l as listenCliMessages, s as sendMessageToCli } from './shared/test-utils-nightly.DDUpsMYL.mjs';
+import { distDir } from '#dirs';
 import 'destr';
 import 'scule';
+import 'node:url';
 import 'exsolve';
 
 const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
@@ -325,7 +323,204 @@ const NuxtRootStubPlugin = (options) => {
   };
 };
 
-const vitePluginBlocklist = ["vite-plugin-vue-inspector", "vite-plugin-vue-inspector:post", "vite-plugin-inspect", "nuxt:type-check"];
+async function setupDevTools(vitestWrapper, nuxt = useNuxt()) {
+  const iframeSrc = "/__test_utils_vitest__/";
+  const updateTabs = debounce(() => {
+    nuxt.callHook("devtools:customTabs:refresh");
+  }, 100);
+  nuxt.hook("devtools:customTabs", (tabs) => {
+    const tab = createVitestCustomTab(vitestWrapper, { iframeSrc });
+    const index = tabs.findIndex(({ name }) => tab.name === name);
+    if (index === -1) {
+      tabs.push(tab);
+    } else {
+      tabs.splice(index, 1, tab);
+    }
+  });
+  addDevServerHandler({
+    route: iframeSrc,
+    handler: defineEventHandler(
+      () => iframeContentHtml(vitestWrapper.uiUrl)
+    )
+  });
+  vitestWrapper.ons({
+    started() {
+      updateTabs();
+    },
+    updated() {
+      updateTabs();
+    },
+    finished() {
+      updateTabs();
+    },
+    exited() {
+      updateTabs();
+    }
+  });
+}
+function createVitestCustomTab(vitest, { iframeSrc }) {
+  const launchView = {
+    type: "launch",
+    description: "Start tests along with Nuxt",
+    actions: [
+      {
+        get label() {
+          switch (vitest.status) {
+            case "starting":
+              return "Starting...";
+            case "running":
+              return "Running Vitest";
+            case "stopped":
+              return "Start Vitest";
+            case "finished":
+              return "Start Vitest";
+          }
+        },
+        get pending() {
+          return vitest.status === "starting" || vitest.status === "running";
+        },
+        handle: () => {
+          vitest.start();
+        }
+      }
+    ]
+  };
+  const uiView = {
+    type: "iframe",
+    persistent: false,
+    src: iframeSrc
+  };
+  const tab = {
+    title: "Vitest",
+    name: "vitest",
+    icon: "logos-vitest",
+    get view() {
+      if (vitest.status === "stopped" || vitest.status === "starting" || !vitest.uiUrl) {
+        return launchView;
+      } else {
+        return uiView;
+      }
+    },
+    extraTabVNode: vitest.testSummary.totalCount ? h("div", { style: { color: vitest.testSummary.failedCount ? "orange" : "green" } }, [
+      h("span", {}, vitest.testSummary.passedCount),
+      h("span", { style: { opacity: "0.5", fontSize: "0.9em" } }, "/"),
+      h(
+        "span",
+        { style: { opacity: "0.8", fontSize: "0.9em" } },
+        vitest.testSummary.totalCount
+      )
+    ]) : void 0
+  };
+  return tab;
+}
+function iframeContentHtml(uiUrl) {
+  return [
+    "<html><head><script>",
+    `(${function redirect(uiUrl2, provider2) {
+      if (typeof window === "undefined") return;
+      if (!uiUrl2) return;
+      if (provider2 === "stackblitz") {
+        const url = new URL(window.location.href);
+        const newUrl = new URL(uiUrl2);
+        newUrl.host = url.host.replace(/--\d+--/, `--${newUrl.port}--`);
+        newUrl.protocol = url.protocol;
+        newUrl.port = url.port;
+        uiUrl2 = newUrl.toString();
+      }
+      window.location.replace(uiUrl2);
+    }})(${JSON.stringify(uiUrl)}, ${JSON.stringify(provider)})`,
+    "<\/script></head></html>"
+  ].join("\n");
+}
+
+function vitestWrapper(options) {
+  const { cwd, ...startOptions } = options;
+  let _status = "stopped";
+  let _uiUrl;
+  let _process;
+  let _testSummary = createVitestTestSummary();
+  const _handlers = {
+    started: [({ uiUrl }) => {
+      _uiUrl = uiUrl;
+      _status = "running";
+      _testSummary = createVitestTestSummary();
+    }],
+    updated: [(summary) => {
+      _testSummary = summary;
+    }],
+    finished: [(summary) => {
+      _status = "finished";
+      _testSummary = summary;
+    }],
+    exited: [clear]
+  };
+  function clear() {
+    _status = "stopped";
+    _uiUrl = void 0;
+    _process = void 0;
+    _testSummary = createVitestTestSummary();
+  }
+  function on(name, handler) {
+    _handlers[name] ??= [];
+    _handlers[name]?.push(handler);
+  }
+  function ons(handlers) {
+    for (const [name, handler] of Object.entries(handlers)) {
+      if (typeof handler === "function") {
+        on(name, handler);
+      }
+    }
+  }
+  async function stop() {
+    const vitest = _process;
+    if (!vitest || vitest.exitCode !== null) return;
+    return new Promise((resolve2) => {
+      vitest.once("exit", () => resolve2());
+      sendMessageToCli(vitest, "stop", { force: true });
+    });
+  }
+  async function start() {
+    if (_process) return false;
+    const vitest = fork(resolve(distDir, "./vitest-wrapper/cli.mjs"), {
+      cwd,
+      env: {
+        ...process.env,
+        NODE_ENV: "test",
+        MODE: "test"
+      },
+      stdio: startOptions.logToConsole ? void 0 : ["ignore", "ignore", "inherit", "ipc"]
+    });
+    _status = "starting";
+    _process = vitest;
+    vitest.once("exit", () => {
+      _handlers.exited.forEach((fn) => fn({ exitCode: vitest.exitCode ?? 0 }));
+    });
+    listenCliMessages(vitest, ({ type, payload }) => {
+      _handlers[type].forEach((fn) => fn(payload));
+    });
+    sendMessageToCli(vitest, "start", startOptions);
+    return true;
+  }
+  return {
+    on,
+    ons,
+    stop,
+    start,
+    get uiUrl() {
+      return _uiUrl;
+    },
+    get options() {
+      return options;
+    },
+    get status() {
+      return _status;
+    },
+    get testSummary() {
+      return { ..._testSummary };
+    }
+  };
+}
+
 const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/test-utils",
@@ -351,133 +546,55 @@ const module$1 = defineNuxtModule({
       nuxt.options.vite.define ||= {};
       nuxt.options.vite.define["import.meta.vitest"] = "undefined";
     }
-    nuxt.hook("prepare:types", (ctx2) => {
-      ctx2.references.push({ types: "vitest/import-meta" });
-      if (ctx2.nodeTsConfig) {
-        ctx2.nodeTsConfig.include ||= [];
-        ctx2.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.rootDir, "vitest.config.*")));
+    nuxt.hook("prepare:types", (ctx) => {
+      ctx.references.push({ types: "vitest/import-meta" });
+      if (ctx.nodeTsConfig) {
+        ctx.nodeTsConfig.include ||= [];
+        ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.rootDir, "vitest.config.*")));
         if (nuxt.options.workspaceDir !== nuxt.options.rootDir) {
-          ctx2.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.workspaceDir, "vitest.config.*")));
+          ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.workspaceDir, "vitest.config.*")));
         }
       }
     });
     if (!nuxt.options.dev) return;
     if (process.env.TEST || process.env.VITE_TEST) return;
-    const rawViteConfigPromise = new Promise((resolve) => {
-      nuxt.hook("app:resolve", () => {
-        nuxt.hook("vite:configResolved", (config, { isClient }) => {
-          if (isClient) resolve(config);
-        });
-      });
-    });
-    let loaded = false;
-    let promise;
-    let ctx = void 0;
-    let testFiles = null;
-    const updateTabs = debounce(() => {
-      nuxt.callHook("devtools:customTabs:refresh");
-    }, 100);
-    let URL;
-    async function start() {
-      const { mergeConfig } = await importModule("vite", { paths: nuxt.options.modulesDir });
-      const rawViteConfig = mergeConfig({}, await rawViteConfigPromise);
-      const viteConfig = await getVitestConfigFromNuxt({ nuxt, viteConfig: defu({ test: options.vitestConfig }, rawViteConfig) });
-      viteConfig.plugins = (viteConfig.plugins || []).filter((p) => {
-        return !p || !("name" in p) || !vitePluginBlocklist.includes(p.name);
-      });
-      viteConfig.test.environmentMatchGlobs ||= [];
-      viteConfig.test.environmentMatchGlobs.push(
-        ["**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}", "nuxt"],
-        ["{test,tests}/nuxt/**.*", "nuxt"]
-      );
-      process.env.__NUXT_VITEST_RESOLVED__ = "true";
-      const { startVitest } = await import(pathToFileURL(await resolvePath("vitest/node")).href);
-      const customReporter = {
-        onInit(_ctx) {
-          ctx = _ctx;
-        },
-        onTaskUpdate() {
-          testFiles = ctx.state.getFiles();
-          updateTabs();
-        },
-        onFinished() {
-          testFiles = ctx.state.getFiles();
-          updateTabs();
-        }
-      };
-      const watchMode = !process.env.NUXT_VITEST_DEV_TEST && !isCI;
-      const PORT = await getPort({ port: 15555 });
-      const PROTOCOL = nuxt.options.devServer.https ? "https" : "http";
-      URL = `${PROTOCOL}://localhost:${PORT}/__vitest__/`;
-      const overrides = watchMode ? {
-        passWithNoTests: true,
-        reporters: options.logToConsole ? [
-          ...toArray(options.vitestConfig?.reporters ?? ["default"]),
-          customReporter
-        ] : [customReporter],
-        // do not report to console
-        watch: true,
-        ui: true,
-        open: false,
-        api: {
-          port: PORT
-        }
-      } : { watch: false };
-      const promise2 = startVitest("test", [], defu(overrides, viteConfig.test), viteConfig);
-      promise2.catch(() => process.exit(1));
-      if (watchMode) {
-        logger.info(`Vitest UI starting on ${URL}`);
-        nuxt.hook("close", () => promise2.then((v) => v?.close()));
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-      } else {
-        promise2.then((v) => nuxt.close().then(() => v?.close()).then(() => process.exit()));
-      }
-      loaded = true;
+    const vitestWrapper2 = createVitestWrapper(options, nuxt);
+    const isDevToolsEnabled = typeof nuxt.options.devtools === "boolean" ? nuxt.options.devtools : nuxt.options.devtools.enabled;
+    if (isDevToolsEnabled) {
+      await setupDevTools(vitestWrapper2, nuxt);
     }
-    nuxt.hook("devtools:customTabs", (tabs) => {
-      const failedCount = testFiles?.filter((f) => f.result?.state === "fail").length ?? 0;
-      const passedCount = testFiles?.filter((f) => f.result?.state === "pass").length ?? 0;
-      const totalCount = testFiles?.length ?? 0;
-      tabs.push({
-        title: "Vitest",
-        name: "vitest",
-        icon: "logos-vitest",
-        view: loaded ? {
-          type: "iframe",
-          src: URL
-        } : {
-          type: "launch",
-          description: "Start tests along with Nuxt",
-          actions: [
-            {
-              label: promise ? "Starting..." : "Start Vitest",
-              pending: !!promise,
-              handle: () => {
-                promise = promise || start();
-                return promise;
-              }
-            }
-          ]
-        },
-        extraTabVNode: totalCount ? h("div", { style: { color: failedCount ? "orange" : "green" } }, [
-          h("span", {}, passedCount),
-          h("span", { style: { opacity: "0.5", fontSize: "0.9em" } }, "/"),
-          h(
-            "span",
-            { style: { opacity: "0.8", fontSize: "0.9em" } },
-            totalCount
-          )
-        ]) : void 0
-      });
-    });
     if (options.startOnBoot) {
-      promise = promise || start();
-      promise.then(updateTabs);
+      vitestWrapper2.start();
     }
   }
 });
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
+function createVitestWrapper(options, nuxt = useNuxt()) {
+  const watchMode = !isCI;
+  const wrapper = vitestWrapper({
+    cwd: nuxt.options.rootDir,
+    apiPorts: [15555],
+    logToConsole: options.logToConsole ?? false,
+    watchMode
+  });
+  wrapper.ons({
+    started({ uiUrl }) {
+      if (watchMode) {
+        logger.info(`Vitest UI starting on ${uiUrl}`);
+      }
+    },
+    exited({ exitCode }) {
+      if (watchMode) {
+        logger.info(`Vitest exited with code ${exitCode}`);
+      } else {
+        nuxt.close().finally(() => process.exit(exitCode));
+      }
+    }
+  });
+  nuxt.hooks.addHooks({
+    close: () => wrapper.stop(),
+    restart: () => wrapper.stop()
+  });
+  return wrapper;
 }
 
 export { module$1 as default };

package/dist/playwright.d.mts

@@ -1,7 +1,7 @@
 import * as _playwright_test from '@playwright/test';
 export { expect } from '@playwright/test';
 import { Response } from 'playwright-core';
-import { T as TestOptions$1, G as GotoOptions, b as TestHooks } from './shared/test-utils-nightly.20kU0tZa.mjs';
+import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils-nightly.ZByFDqps.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
 

package/dist/playwright.mjs

@@ -1,7 +1,7 @@
 import defu from 'defu';
 import { test as test$1 } from '@playwright/test';
 export { expect } from '@playwright/test';
-import { w as waitForHydration, d as createTest } from './shared/test-utils-nightly.BpHODLaZ.mjs';
+import { w as waitForHydration, d as createTest } from './shared/test-utils-nightly.D0-o1nCe.mjs';
 import 'node:path';
 import 'ufo';
 import 'std-env';
@@ -14,7 +14,7 @@ import 'exsolve';
 import { d as url } from './shared/test-utils-nightly.C_clWQBc.mjs';
 import 'pathe';
 import '#dirs';
-import './shared/test-utils-nightly.G1ew4kEe.mjs';
+import './shared/test-utils-nightly.BIY9XRkB.mjs';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/runtime-utils/index.d.mts

@@ -1,8 +1,8 @@
 import { EventHandler, HTTPMethod } from 'h3';
 import { SetupContext, RenderFunction, ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentOptionsWithoutProps, ComponentOptionsWithArrayProps, ComponentPropsOptions, ComponentOptionsWithObjectProps } from 'vue';
-import { ComponentMountingOptions, mount } from '@vue/test-utils';
+import { mount } from '@vue/test-utils';
 import { RouteLocationRaw } from 'vue-router';
-import { RenderOptions, RenderResult } from '@testing-library/vue';
+import { render } from '@testing-library/vue';
 
 type Awaitable<T> = T | Promise<T>;
 type OptionalFunction<T> = T | (() => Awaitable<T>);
@@ -95,14 +95,26 @@ declare function mockComponent<Props = {}, RawBindings = {}, D = {}, C extends C
 declare function mockComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(path: string, options: OptionalFunction<ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>>): void;
 declare function mockComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(path: string, options: OptionalFunction<ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>>): void;
 
-type MountSuspendedOptions<T> = ComponentMountingOptions<T> & {
+type SetupState = Record<string, any>;
+type WrapperFnComponent<Fn> = Fn extends (c: infer C, o: infer _) => infer _ ? C : never;
+type WrapperFnOption<Fn> = Fn extends (c: WrapperFnComponent<Fn>, o: infer O) => infer _ ? O : never;
+type WrapperFnResult<Fn> = Fn extends (c: WrapperFnComponent<Fn>, o: WrapperFnOption<Fn>) => infer R ? R : never;
+type WrapperSuspendedOptions<Fn> = WrapperFnOption<Fn> & {
     route?: RouteLocationRaw;
     scoped?: boolean;
 };
-type MountSuspendedResult<T> = ReturnType<typeof mount<T>> & {
-    setupState: SetupState$1;
+type WrapperSuspendedResult<Fn> = WrapperFnResult<Fn> & {
+    setupState: SetupState;
 };
-type SetupState$1 = Record<string, any>;
+declare global {
+    interface Window {
+        __cleanup?: Array<() => void>;
+    }
+}
+
+type WrapperFn$1<C> = typeof mount<C>;
+type WrapperOptions$1<C> = WrapperSuspendedOptions<WrapperFn$1<C>>;
+type WrapperResult$1<C> = WrapperSuspendedResult<WrapperFn$1<C>>;
 /**
  * `mountSuspended` allows you to mount any vue component within the Nuxt environment, allowing async setup and access to injections from your Nuxt plugins. For example:
  *
@@ -129,18 +141,11 @@ type SetupState$1 = Record<string, any>;
  * @param component the component to be tested
  * @param options optional options to set up your component
  */
-declare function mountSuspended<T>(component: T, options?: MountSuspendedOptions<T>): Promise<MountSuspendedResult<T>>;
-declare global {
-    var __cleanup: Array<() => void> | undefined;
-}
+declare function mountSuspended<T>(component: T, options?: WrapperOptions$1<T>): Promise<WrapperResult$1<T>>;
 
-type RenderSuspendeOptions<T> = RenderOptions<T> & {
-    route?: RouteLocationRaw;
-};
-type RenderSuspendeResult = RenderResult & {
-    setupState: SetupState;
-};
-type SetupState = Record<string, any>;
+type WrapperFn<C> = typeof render<C>;
+type WrapperOptions<C> = WrapperSuspendedOptions<WrapperFn<C>>;
+type WrapperResult<C> = WrapperSuspendedResult<WrapperFn<C>>;
 /**
  * `renderSuspended` allows you to mount any vue component within the Nuxt environment, allowing async setup and access to injections from your Nuxt plugins.
  *
@@ -171,11 +176,6 @@ type SetupState = Record<string, any>;
  * @param component the component to be tested
  * @param options optional options to set up your component
  */
-declare function renderSuspended<T>(component: T, options?: RenderSuspendeOptions<T>): Promise<RenderSuspendeResult>;
-declare global {
-    interface Window {
-        __cleanup?: Array<() => void>;
-    }
-}
+declare function renderSuspended<T>(component: T, options?: WrapperOptions<T>): Promise<WrapperResult<T>>;
 
 export { mockComponent, mockNuxtImport, mountSuspended, registerEndpoint, renderSuspended };

package/dist/runtime-utils/index.mjs

@@ -1,8 +1,8 @@
 import { defineEventHandler } from 'h3';
 import { mount } from '@vue/test-utils';
-import { reactive, h as h$1, Suspense, nextTick, getCurrentInstance, effectScope, defineComponent as defineComponent$1 } from 'vue';
+import { reactive, h as h$1, Suspense, nextTick as nextTick$1, getCurrentInstance, onErrorCaptured, effectScope } from 'vue';
 import { defu } from 'defu';
-import { defineComponent, useRouter, h, tryUseNuxtApp, onErrorCaptured } from '#imports';
+import { defineComponent, useRouter, h, tryUseNuxtApp } from '#imports';
 import NuxtRoot from '#build/root-component.mjs';
 
 const endpointRegistry = {};
@@ -88,19 +88,34 @@ const RouterLink = defineComponent({
   }
 });
 
-async function mountSuspended(component, options) {
-  const {
-    props = {},
-    attrs = {},
-    slots = {},
-    route = "/",
-    ..._options
-  } = options || {};
-  for (const cleanupFunction of globalThis.__cleanup || []) {
-    cleanupFunction();
+function cleanupAll() {
+  for (const fn of (window.__cleanup || []).splice(0)) {
+    fn();
   }
+}
+function addCleanup(fn) {
+  window.__cleanup ||= [];
+  window.__cleanup.push(fn);
+}
+function runEffectScope(fn) {
+  const scope = effectScope();
+  addCleanup(() => scope.stop());
+  return scope.run(fn);
+}
+function wrapperSuspended(component, options, {
+  wrapperFn,
+  wrappedRender = (fn) => fn,
+  suspendedHelperName,
+  clonedComponentName
+}) {
+  const { props = {}, attrs = {} } = options;
+  const { route = "/", scoped = false, ...wrapperFnOptions } = options;
   const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, ...componentRest } = component;
+  const {
+    render: componentRender,
+    setup: componentSetup,
+    ...componentRest
+  } = component;
   let wrappedInstance = null;
   let setupContext;
   let setupState;
@@ -113,28 +128,19 @@ async function mountSuspended(component, options) {
       app[key] = value;
     }
   }
-  let componentScope = null;
-  const wrappedSetup = async (props2, setupContext2, instanceContext) => {
-    const currentInstance = getCurrentInstance();
-    if (currentInstance) {
-      currentInstance.emit = (event, ...args) => {
-        setupContext2.emit(event, ...args);
-      };
-    }
-    if (setup) {
-      let result;
-      if (options?.scoped) {
-        componentScope = effectScope();
-        globalThis.__cleanup ||= [];
-        globalThis.__cleanup.push(() => {
-          componentScope?.stop();
-        });
-        result = await componentScope?.run(async () => {
-          return await setup(props2, setupContext2);
-        });
-      } else {
-        result = await setup(props2, setupContext2);
+  const ClonedComponent = {
+    components: {},
+    ...component,
+    name: clonedComponentName,
+    async setup(props2, instanceContext) {
+      const currentInstance = getCurrentInstance();
+      if (currentInstance) {
+        currentInstance.emit = (event, ...args) => {
+          setupContext.emit(event, ...args);
+        };
       }
+      if (!componentSetup) return;
+      const result = scoped ? await runEffectScope(() => componentSetup(props2, setupContext)) : await componentSetup(props2, setupContext);
       if (wrappedInstance?.exposed) {
         instanceContext.expose(wrappedInstance.exposed);
       }
@@ -142,114 +148,108 @@ async function mountSuspended(component, options) {
       return result;
     }
   };
-  return new Promise(
-    (resolve, reject) => {
-      let isMountSettled = false;
-      const vm = mount(
-        {
-          __cssModules: componentRest.__cssModules,
-          inheritAttrs: false,
-          setup: (props2, ctx) => {
-            patchInstanceAppContext();
-            wrappedInstance = getCurrentInstance();
-            setupContext = ctx;
-            let nuxtRootSetupResult;
-            if (options?.scoped) {
-              const scope = effectScope();
-              globalThis.__cleanup ||= [];
-              globalThis.__cleanup.push(() => {
-                scope.stop();
-              });
-              nuxtRootSetupResult = scope.run(() => NuxtRoot.setup(props2, {
-                ...ctx,
-                expose: () => {
-                }
-              }));
-            } else {
-              nuxtRootSetupResult = NuxtRoot.setup(props2, {
-                ...ctx,
-                expose: () => {
-                }
-              });
+  const SuspendedHelper = {
+    name: suspendedHelperName,
+    render: () => "",
+    async setup() {
+      const router = useRouter();
+      await router.replace(route);
+      return () => h$1(ClonedComponent, { ...props, ...setProps, ...attrs }, setupContext.slots);
+    }
+  };
+  return new Promise((resolve, reject) => {
+    let isMountSettled = false;
+    const wrapper = wrapperFn(
+      {
+        inheritAttrs: false,
+        __cssModules: componentRest.__cssModules,
+        setup: (props2, ctx) => {
+          patchInstanceAppContext();
+          wrappedInstance = getCurrentInstance();
+          setupContext = ctx;
+          const nuxtRootSetupResult = runEffectScope(
+            () => NuxtRoot.setup(props2, {
+              ...ctx,
+              expose: () => {
+              }
+            })
+          );
+          onErrorCaptured((error, ...args) => {
+            if (isMountSettled) return;
+            isMountSettled = true;
+            try {
+              wrappedInstance?.appContext.config.errorHandler?.(error, ...args);
+              reject(error);
+            } catch (error2) {
+              reject(error2);
             }
-            onErrorCaptured((error, ...args) => {
+            return false;
+          });
+          return nuxtRootSetupResult;
+        },
+        render: wrappedRender(() => h$1(
+          Suspense,
+          {
+            onResolve: () => nextTick$1().then(() => {
               if (isMountSettled) return;
               isMountSettled = true;
-              try {
-                wrappedInstance?.appContext.config.errorHandler?.(error, ...args);
-                reject(error);
-              } catch (error2) {
-                reject(error2);
-              }
-              return false;
-            });
-            return nuxtRootSetupResult;
-          },
-          render: () => h$1(
-            Suspense,
-            {
-              onResolve: () => nextTick().then(() => {
-                if (isMountSettled) return;
-                isMountSettled = true;
-                vm.setupState = setupState;
-                vm.__setProps = (props2) => {
+              wrapper.setupState = setupState;
+              resolve({
+                wrapper,
+                setProps: (props2) => {
                   Object.assign(setProps, props2);
-                };
-                resolve(wrappedMountedWrapper(vm));
-              })
-            },
-            {
-              default: () => h$1({
-                name: "MountSuspendedHelper",
-                render: () => "",
-                async setup() {
-                  const router = useRouter();
-                  await router.replace(route);
-                  const clonedComponent = {
-                    components: {},
-                    ...component,
-                    name: "MountSuspendedComponent",
-                    setup: (props2, ctx) => wrappedSetup(props2, setupContext, ctx)
-                  };
-                  return () => h$1(clonedComponent, { ...props, ...setProps, ...attrs }, setupContext.slots);
                 }
-              })
-            }
-          )
-        },
-        defu(
-          _options,
+              });
+            })
+          },
           {
-            props,
-            slots,
-            attrs,
-            global: {
-              config: {
-                globalProperties: {
-                  ...vueApp.config.globalProperties,
-                  // make all properties/keys enumerable.
-                  ...Object.fromEntries(
-                    Object.getOwnPropertyNames(vueApp.config.globalProperties).map((key) => [key, vueApp.config.globalProperties[key]])
-                  )
-                }
-              },
-              directives: vueApp._context.directives,
-              provide: vueApp._context.provides,
-              stubs: {
-                Suspense: false,
-                MountSuspendedHelper: false,
-                [component && typeof component === "object" && "name" in component && typeof component.name === "string" ? component.name : "MountSuspendedComponent"]: false
-              },
-              components: { ...vueApp._context.components, RouterLink }
-            }
+            default: () => h$1(SuspendedHelper)
           }
-        )
-      );
-    }
-  );
+        ))
+      },
+      defu(wrapperFnOptions, {
+        global: {
+          config: {
+            globalProperties: makeAllPropertiesEnumerable(
+              vueApp.config.globalProperties
+            )
+          },
+          directives: vueApp._context.directives,
+          provide: vueApp._context.provides,
+          stubs: {
+            Suspense: false,
+            [SuspendedHelper.name]: false,
+            [ClonedComponent.name]: false
+          },
+          components: { ...vueApp._context.components, RouterLink }
+        }
+      })
+    );
+  });
+}
+function makeAllPropertiesEnumerable(target) {
+  return {
+    ...target,
+    ...Object.fromEntries(
+      Object.getOwnPropertyNames(target).map((key) => [key, target[key]])
+    )
+  };
+}
+
+async function mountSuspended(component, options = {}) {
+  const suspendedHelperName = "MountSuspendedHelper";
+  const clonedComponentName = "MountSuspendedComponent";
+  cleanupAll();
+  const { wrapper, setProps } = await wrapperSuspended(component, options, {
+    wrapperFn: mount,
+    suspendedHelperName,
+    clonedComponentName
+  });
+  Object.assign(wrapper, { __setProps: setProps });
+  const clonedComponent = wrapper.findComponent({ name: clonedComponentName });
+  return wrappedMountedWrapper(wrapper, clonedComponent);
 }
-function wrappedMountedWrapper(wrapper) {
-  const component = wrapper.findComponent({ name: "MountSuspendedComponent" });
+function wrappedMountedWrapper(wrapper, component) {
   const wrapperProps = [
     "setProps",
     "emitted",
@@ -290,154 +290,27 @@ function wrappedMountedWrapper(wrapper) {
   }
 }
 
-const WRAPPER_EL_ID = "test-wrapper";
-async function renderSuspended(component, options) {
-  const {
-    props = {},
-    attrs = {},
-    slots = {},
-    route = "/",
-    ..._options
-  } = options || {};
-  const { render: renderFromTestingLibrary } = await import('@testing-library/vue');
-  const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, ...componentRest } = component;
-  let wrappedInstance = null;
-  let setupContext;
-  let setupState;
-  const setProps = reactive({});
-  function patchInstanceAppContext() {
-    const app = getCurrentInstance()?.appContext.app;
-    if (!app) return;
-    for (const [key, value] of Object.entries(vueApp)) {
-      if (key in app) continue;
-      app[key] = value;
-    }
-  }
-  for (const fn of window.__cleanup || []) {
-    fn();
-  }
-  document.querySelector(`#${WRAPPER_EL_ID}`)?.remove();
-  const wrappedSetup = async (props2, setupContext2, instanceContext) => {
-    const currentInstance = getCurrentInstance();
-    if (currentInstance) {
-      currentInstance.emit = (event, ...args) => {
-        setupContext2.emit(event, ...args);
-      };
-    }
-    if (setup) {
-      const result = await setup(props2, setupContext2);
-      setupState = result && typeof result === "object" ? result : {};
-      if (wrappedInstance?.exposed) {
-        instanceContext.expose(wrappedInstance.exposed);
-      }
-      return result;
-    }
-  };
-  const WrapperComponent = defineComponent$1({
-    inheritAttrs: false,
-    render() {
-      return h$1("div", { id: WRAPPER_EL_ID }, this.$slots.default?.());
-    }
-  });
-  return new Promise((resolve, reject) => {
-    let isMountSettled = false;
-    const utils = renderFromTestingLibrary(
-      {
-        __cssModules: componentRest.__cssModules,
-        inheritAttrs: false,
-        setup: (props2, ctx) => {
-          patchInstanceAppContext();
-          wrappedInstance = getCurrentInstance();
-          setupContext = ctx;
-          const scope = effectScope();
-          window.__cleanup ||= [];
-          window.__cleanup.push(() => {
-            scope.stop();
-          });
-          const nuxtRootSetupResult = scope.run(() => NuxtRoot.setup(props2, {
-            ...ctx,
-            expose: () => ({})
-          }));
-          onErrorCaptured((error, ...args) => {
-            if (isMountSettled) return;
-            isMountSettled = true;
-            try {
-              wrappedInstance?.appContext.config.errorHandler?.(error, ...args);
-              reject(error);
-            } catch (error2) {
-              reject(error2);
-            }
-            return false;
-          });
-          return nuxtRootSetupResult;
-        },
-        render: () => (
-          // See discussions in https://github.com/testing-library/vue-testing-library/issues/230
-          // we add this additional root element because otherwise testing-library breaks
-          // because there's no root element while Suspense is resolving
-          h$1(
-            WrapperComponent,
-            {},
-            {
-              default: () => h$1(
-                Suspense,
-                {
-                  onResolve: () => nextTick().then(() => {
-                    if (isMountSettled) return;
-                    isMountSettled = true;
-                    utils.setupState = setupState;
-                    utils.rerender = async (props2) => {
-                      Object.assign(setProps, props2);
-                      await nextTick();
-                    };
-                    resolve(utils);
-                  })
-                },
-                {
-                  default: () => h$1({
-                    name: "RenderHelper",
-                    render: () => "",
-                    async setup() {
-                      const router = useRouter();
-                      await router.replace(route);
-                      const clonedComponent = {
-                        components: {},
-                        ...component,
-                        name: "RenderSuspendedComponent",
-                        render,
-                        setup: (props2, ctx) => wrappedSetup(props2, setupContext, ctx)
-                      };
-                      return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...setProps, ...attrs }, setupContext.slots);
-                    }
-                  })
-                }
-              )
-            }
-          )
-        )
-      },
-      defu(_options, {
-        props,
-        slots,
-        attrs,
-        global: {
-          config: {
-            globalProperties: {
-              ...vueApp.config.globalProperties,
-              // make all properties/keys enumerable.
-              ...Object.fromEntries(
-                Object.getOwnPropertyNames(vueApp.config.globalProperties).map((key) => [key, vueApp.config.globalProperties[key]])
-              )
-            }
-          },
-          directives: vueApp._context.directives,
-          provide: vueApp._context.provides,
-          components: { RouterLink }
-        }
-      })
-    );
+async function renderSuspended(component, options = {}) {
+  const wrapperId = "test-wrapper";
+  const suspendedHelperName = "RenderHelper";
+  const clonedComponentName = "RenderSuspendedComponent";
+  const { render: wrapperFn } = await import('@testing-library/vue');
+  cleanupAll();
+  document.getElementById(wrapperId)?.remove();
+  const { wrapper, setProps } = await wrapperSuspended(component, options, {
+    wrapperFn,
+    wrappedRender: (render) => () => h$1({
+      inheritAttrs: false,
+      render: () => h$1("div", { id: wrapperId }, render())
+    }),
+    suspendedHelperName,
+    clonedComponentName
   });
+  wrapper.rerender = async (props) => {
+    setProps(props);
+    await nextTick();
+  };
+  return wrapper;
 }
 
 export { mockComponent, mockNuxtImport, mountSuspended, registerEndpoint, renderSuspended };

package/dist/shared/{test-utils-nightly.G1ew4kEe.mjs → test-utils-nightly.BIY9XRkB.mjs}

@@ -48,7 +48,7 @@ async function loadKit(rootDir) {
   } catch (e) {
     if (e.toString().includes("Cannot find module '@nuxt/kit'")) {
       throw new Error(
-        "nuxi requires `@nuxt/kit` to be installed in your project. Try installing `nuxt` v3+ or `@nuxt/bridge` first."
+        "`@nuxt/test-utils` requires `@nuxt/kit` to be installed in your project. Try installing `nuxt` v3+ or `@nuxt/bridge` first."
       );
     }
     throw e;

package/dist/shared/{test-utils-nightly.BpHODLaZ.mjs → test-utils-nightly.D0-o1nCe.mjs}

@@ -2,7 +2,7 @@ import { u as useTestContext, d as url, c as createTestContext, a as startServer
 import { existsSync, promises } from 'node:fs';
 import { resolve } from 'node:path';
 import { defu } from 'defu';
-import { l as loadKit } from './test-utils-nightly.G1ew4kEe.mjs';
+import { l as loadKit } from './test-utils-nightly.BIY9XRkB.mjs';
 
 async function createBrowser() {
   const ctx = useTestContext();

package/dist/shared/test-utils-nightly.DDUpsMYL.mjs

@@ -0,0 +1,32 @@
+function isMessage(message) {
+  return message !== null && typeof message === "object" && "type" in message && message.type !== null && typeof message.type === "string" && "payload" in message && message.payload !== null && typeof message.payload === "object";
+}
+function createVitestTestSummary() {
+  return {
+    failedCount: 0,
+    passedCount: 0,
+    totalCount: 0
+  };
+}
+function sendMessageToHost(type, payload) {
+  process.send?.({ type, payload });
+}
+function listenHostMessages(listener) {
+  process.on("message", (message) => {
+    if (isMessage(message)) {
+      listener(message);
+    }
+  });
+}
+function sendMessageToCli(cli, type, payload) {
+  cli.send({ type, payload });
+}
+function listenCliMessages(cli, listener) {
+  cli.on("message", (message) => {
+    if (isMessage(message)) {
+      listener(message);
+    }
+  });
+}
+
+export { listenHostMessages as a, sendMessageToHost as b, createVitestTestSummary as c, listenCliMessages as l, sendMessageToCli as s };

package/dist/shared/{test-utils-nightly.20kU0tZa.d.mts → test-utils-nightly.ZByFDqps.d.mts}

@@ -116,4 +116,4 @@ interface TestHooks {
 }
 
 export { $fetch as $, createBrowser as c, createPage as d, stopServer as e, fetch as f, getBrowser as g, startServer as s, url as u, waitForHydration as w };
-export type { GotoOptions as G, NuxtPage as N, StartServerOptions as S, TestOptions as T, TestContext as a, TestHooks as b, TestRunner as h };
+export type { GotoOptions as G, NuxtPage as N, StartServerOptions as S, TestOptions as T, TestHooks as a, TestContext as b, TestRunner as h };

package/dist/vitest-wrapper/cli.d.mts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/vitest-wrapper/cli.mjs

@@ -0,0 +1,78 @@
+import { importModule } from 'local-pkg';
+import { getPort } from 'get-port-please';
+import { a as listenHostMessages, b as sendMessageToHost } from '../shared/test-utils-nightly.DDUpsMYL.mjs';
+
+function createCustomReporter(onVitestInit) {
+  let ctx = void 0;
+  function getVitestUiUrl() {
+    if (!ctx.config.ui) return void 0;
+    const protocol = ctx.vite.config.server.https ? "https:" : "http:";
+    const host = ctx.config.api.host || "localhost";
+    const port = ctx.config.api.port;
+    const uiBase = ctx.config.uiBase;
+    return `${protocol}//${host}:${port}${uiBase}`;
+  }
+  function toUpdatedResult() {
+    const files = ctx.state.getFiles();
+    return {
+      failedCount: files.filter((f) => f.result?.state === "fail").length ?? 0,
+      passedCount: files.filter((f) => f.result?.state === "pass").length ?? 0,
+      totalCount: files.length ?? 0
+    };
+  }
+  function toFinishedResult() {
+    return toUpdatedResult();
+  }
+  return {
+    onInit(_ctx) {
+      ctx = _ctx;
+      onVitestInit(ctx);
+      sendMessageToHost("started", { uiUrl: getVitestUiUrl() });
+    },
+    onTestRunStart() {
+      sendMessageToHost("updated", toUpdatedResult());
+    },
+    onTaskUpdate() {
+      sendMessageToHost("updated", toUpdatedResult());
+    },
+    onFinished() {
+      sendMessageToHost("finished", toFinishedResult());
+    }
+  };
+}
+async function main() {
+  const {
+    apiPorts,
+    watchMode
+  } = await new Promise((resolve) => {
+    listenHostMessages(({ type, payload }) => {
+      if (type === "start") resolve(payload);
+    });
+  });
+  const port = apiPorts ? await getPort({ ports: apiPorts }) : void 0;
+  const { startVitest } = await importModule("vitest/node");
+  const customReporter = createCustomReporter((vitest2) => {
+    listenHostMessages(async ({ type, payload }) => {
+      if (type === "stop") {
+        await vitest2.exit(payload.force);
+        process.exit();
+      }
+    });
+  });
+  const vitest = await startVitest("test", [], watchMode ? {
+    passWithNoTests: true,
+    ui: true,
+    watch: true,
+    open: false,
+    api: { port }
+  } : { ui: false, watch: false }, {
+    test: {
+      reporters: ["default", customReporter]
+    }
+  });
+  if (!watchMode) {
+    await vitest.exit();
+    process.exit();
+  }
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/test-utils-nightly",
-  "version": "3.21.1-20251220-095456-4c8a3b7",
+  "version": "3.21.1-20251231-212503-838ed8b",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/test-utils.git"
@@ -67,8 +67,8 @@
     "dev:prepare": "nuxt prepare && unbuild --stub && pnpm -r dev:prepare"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.20.1",
-    "c12": "^3.3.2",
+    "@nuxt/kit": "^3.20.2",
+    "c12": "^3.3.3",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "destr": "^2.0.5",
@@ -91,17 +91,17 @@
     "ufo": "^1.6.1",
     "unplugin": "^2.3.11",
     "vitest-environment-nuxt": "^1.0.1",
-    "vue": "^3.5.25"
+    "vue": "^3.5.26"
   },
   "devDependencies": {
-    "@cucumber/cucumber": "12.4.0",
+    "@cucumber/cucumber": "12.5.0",
     "@jest/globals": "30.2.0",
     "@nuxt/devtools-kit": "2.7.0",
     "@nuxt/eslint-config": "1.12.1",
-    "@nuxt/schema": "4.2.1",
+    "@nuxt/schema": "4.2.2",
     "@playwright/test": "1.57.0",
     "@testing-library/vue": "8.1.0",
-    "@types/bun": "1.3.4",
+    "@types/bun": "1.3.5",
     "@types/estree": "1.0.8",
     "@types/jsdom": "27.0.0",
     "@types/node": "latest",
@@ -111,12 +111,12 @@
     "compatx": "0.2.0",
     "eslint": "9.39.2",
     "installed-check": "9.3.0",
-    "knip": "5.73.4",
+    "knip": "5.78.0",
     "nitropack": "2.12.9",
-    "nuxt": "4.2.1",
+    "nuxt": "4.2.2",
     "pkg-pr-new": "0.0.62",
     "playwright-core": "1.57.0",
-    "rollup": "4.53.4",
+    "rollup": "4.54.0",
     "semver": "7.7.3",
     "typescript": "5.9.3",
     "unbuild": "latest",
@@ -124,7 +124,7 @@
     "vite": "7.3.0",
     "vitest": "3.2.4",
     "vue-router": "4.6.4",
-    "vue-tsc": "3.1.8"
+    "vue-tsc": "3.2.1"
   },
   "peerDependencies": {
     "@cucumber/cucumber": "^10.3.1 || >=11.0.0",
@@ -170,18 +170,18 @@
     }
   },
   "resolutions": {
-    "@cucumber/cucumber": "12.4.0",
-    "@nuxt/schema": "4.2.1",
+    "@cucumber/cucumber": "12.5.0",
+    "@nuxt/schema": "4.2.2",
     "@nuxt/test-utils": "workspace:*",
     "@types/node": "24.10.4",
-    "rollup": "4.53.4",
+    "rollup": "4.54.0",
     "vite": "7.3.0",
     "vite-node": "5.2.0",
     "vitest": "3.2.4",
-    "vue": "^3.5.25"
+    "vue": "^3.5.26"
   },
   "engines": {
     "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
   },
-  "packageManager": "pnpm@10.26.0"
+  "packageManager": "pnpm@10.26.2"
 }