@nuxt/test-utils 3.17.2 → 3.19.0

package/README.md

@@ -11,7 +11,7 @@ Nuxt Test Utils is currently powering [the tests we use on Nuxt itself](https://
 You can find out more about how to use Nuxt Test Utils:
 
 - in [a general overview](https://nuxt.com/docs/getting-started/testing)
-- in [an in-depth guide for module authors](https://nuxt.com/docs/guide/going-further/modules/#testing)
+- in [an in-depth guide for module authors](https://nuxt.com/docs/guide/going-further/modules#testing)
 
 ## License
 

package/dist/config.d.mts

@@ -1,23 +1,25 @@
-import * as vite from 'vite';
-import { InlineConfig } from 'vite';
+import * as vitest_config_js from 'vitest/config.js';
 import { NuxtConfig, Nuxt } from '@nuxt/schema';
-import { InlineConfig as InlineConfig$1 } from 'vitest/node';
+import { InlineConfig } from 'vitest/node';
+import { TestProjectInlineConfiguration } from 'vitest/config';
 import { DotenvOptions } from 'c12';
+import { UserConfig } from 'vite';
 
 interface GetVitestConfigOptions {
     nuxt: Nuxt;
-    viteConfig: InlineConfig;
+    viteConfig: UserConfig;
 }
 interface LoadNuxtOptions {
     dotenv?: Partial<DotenvOptions>;
     overrides?: Partial<NuxtConfig>;
 }
-declare function getVitestConfigFromNuxt(options?: GetVitestConfigOptions, loadNuxtOptions?: LoadNuxtOptions): Promise<InlineConfig & {
-    test: InlineConfig$1;
+declare function getVitestConfigFromNuxt(options?: GetVitestConfigOptions, loadNuxtOptions?: LoadNuxtOptions): Promise<UserConfig & {
+    test: InlineConfig;
 }>;
-declare function defineVitestConfig(config?: InlineConfig & {
-    test?: InlineConfig$1;
-}): vite.UserConfig & Promise<vite.UserConfig> & vite.UserConfigFnObject & vite.UserConfigFnPromise & vite.UserConfigFn;
+declare function defineVitestProject(config: TestProjectInlineConfiguration): Promise<TestProjectInlineConfiguration>;
+declare function defineVitestConfig(config?: UserConfig & {
+    test?: InlineConfig;
+}): vitest_config_js.UserConfigExport;
 interface NuxtEnvironmentOptions {
     rootDir?: string;
     /**
@@ -61,4 +63,5 @@ declare module 'vitest' {
     }
 }
 
-export { defineVitestConfig, getVitestConfigFromNuxt };
+export { defineVitestConfig, defineVitestProject, getVitestConfigFromNuxt };
+export type { NuxtEnvironmentOptions };

package/dist/config.mjs

@@ -1,7 +1,8 @@
-import { defineConfig } from 'vite';
+import process$1 from 'node:process';
+import { defineConfig } from 'vitest/config';
 import { setupDotenv } from 'c12';
 import { defu } from 'defu';
-import { createResolver } from '@nuxt/kit';
+import { createResolver, findPath, loadNuxt, buildNuxt } from '@nuxt/kit';
 import destr from 'destr';
 import { snakeCase } from 'scule';
 
@@ -35,8 +36,7 @@ function applyEnv(obj, opts, parentKey = "") {
   return obj;
 }
 
-async function startNuxtAndGetViteConfig(rootDir = process.cwd(), options = {}) {
-  const { loadNuxt, buildNuxt } = await import('@nuxt/kit');
+async function startNuxtAndGetViteConfig(rootDir = process$1.cwd(), options = {}) {
   const nuxt = await loadNuxt({
     cwd: rootDir,
     dev: false,
@@ -85,7 +85,7 @@ const excludedPlugins = [
   "vite-plugin-checker"
 ];
 async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
-  const { rootDir = process.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
+  const { rootDir = process$1.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
   if (!options) {
     options = await startNuxtAndGetViteConfig(rootDir, {
       dotenv: loadNuxtOptions.dotenv,
@@ -100,10 +100,13 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
     // overrides
     {
       define: {
-        ["process.env.NODE_ENV"]: "process.env.NODE_ENV"
+        "process.env.NODE_ENV": '"test"'
+      },
+      optimizeDeps: {
+        noDiscovery: true
       },
       test: {
-        dir: process.cwd(),
+        dir: process$1.cwd(),
         environmentOptions: {
           nuxtRuntimeConfig: applyEnv(structuredClone(options.nuxt.options.runtimeConfig), {
             prefix: "NUXT_",
@@ -118,10 +121,6 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
             options.nuxt.options.nitro?.routeRules
           )
         },
-        environmentMatchGlobs: [
-          ["**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}", "nuxt"],
-          ["{test,tests}/nuxt/**.*", "nuxt"]
-        ],
         server: {
           deps: {
             inline: [
@@ -152,6 +151,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
       server: { middlewareMode: false },
       plugins: [
         {
+          // TODO: prefix with 'nuxt:test-utils:' in next major version
           name: "disable-auto-execute",
           enforce: "pre",
           transform(code, id) {
@@ -162,6 +162,17 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
               );
             }
           }
+        },
+        {
+          name: "nuxt:test-utils:browser-conditions",
+          enforce: "pre",
+          config() {
+            return {
+              resolve: {
+                conditions: ["web", "import", "module", "default"]
+              }
+            };
+          }
         }
       ]
     },
@@ -188,25 +199,84 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
     resolvedConfig.test.setupFiles = [resolvedConfig.test.setupFiles].filter(Boolean);
   }
   const resolver = createResolver(import.meta.url);
-  resolvedConfig.test.setupFiles.unshift(resolver.resolve("./runtime/entry"));
+  const entryPath = resolver.resolve("./runtime/entry");
+  resolvedConfig.test.setupFiles.unshift(await findPath(entryPath) ?? entryPath);
+  return resolvedConfig;
+}
+async function defineVitestProject(config) {
+  if (process$1.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 overrides = config.test?.environmentOptions?.nuxt?.overrides || {};
-    overrides.rootDir = config.test?.environmentOptions?.nuxt?.rootDir;
-    if (config.test?.setupFiles && !Array.isArray(config.test.setupFiles)) {
-      config.test.setupFiles = [config.test.setupFiles].filter(Boolean);
+    if (process$1.env.__NUXT_VITEST_RESOLVED__) return config;
+    const resolvedConfig = await resolveConfig(config);
+    if (resolvedConfig.test.browser?.enabled) {
+      return resolvedConfig;
     }
-    return defu(
-      config,
-      await getVitestConfigFromNuxt(void 0, {
-        dotenv: config.test?.environmentOptions?.nuxt?.dotenv,
-        overrides: structuredClone(overrides)
-      })
-    );
+    if ("workspace" in resolvedConfig.test) {
+      throw new Error(
+        "The `workspace` option is not supported with `defineVitestConfig`. Instead, use `defineVitestProject` to define each workspace project that uses the Nuxt environment."
+      );
+    }
+    const defaultEnvironment = resolvedConfig.test.environment || "node";
+    if (defaultEnvironment !== "nuxt") {
+      resolvedConfig.test.workspace = [];
+      resolvedConfig.test.workspace.push({
+        extends: true,
+        test: {
+          name: "nuxt",
+          environment: "nuxt",
+          include: [
+            "**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}",
+            "{test,tests}/nuxt/**.*"
+          ]
+        }
+      });
+    }
+    return resolvedConfig;
   });
 }
+async function resolveConfig(config) {
+  const overrides = config.test?.environmentOptions?.nuxt?.overrides || {};
+  overrides.rootDir = config.test?.environmentOptions?.nuxt?.rootDir;
+  if (config.test?.setupFiles && !Array.isArray(config.test.setupFiles)) {
+    config.test.setupFiles = [config.test.setupFiles].filter(Boolean);
+  }
+  const resolvedConfig = defu(
+    config,
+    await getVitestConfigFromNuxt(void 0, {
+      dotenv: config.test?.environmentOptions?.nuxt?.dotenv,
+      overrides: structuredClone(overrides)
+    })
+  );
+  const PLUGIN_NAME = "nuxt:vitest:nuxt-environment-options";
+  const STUB_ID = "nuxt-vitest-environment-options";
+  resolvedConfig.plugins.push({
+    name: PLUGIN_NAME,
+    enforce: "pre",
+    resolveId(id) {
+      if (id.endsWith(STUB_ID)) {
+        return STUB_ID;
+      }
+    },
+    load(id) {
+      if (id.endsWith(STUB_ID)) {
+        return `export default ${JSON.stringify(resolvedConfig.test.environmentOptions || {})}`;
+      }
+    }
+  });
+  if (resolvedConfig.test.browser?.enabled) {
+    if (resolvedConfig.test.environment === "nuxt") {
+      resolvedConfig.test.setupFiles = Array.isArray(resolvedConfig.test.setupFiles) ? resolvedConfig.test.setupFiles : [resolvedConfig.test.setupFiles].filter(Boolean);
+      const resolver = createResolver(import.meta.url);
+      const browserEntry = await findPath(resolver.resolve("./runtime/browser-entry")) || resolver.resolve("./runtime/browser-entry");
+      resolvedConfig.test.setupFiles.unshift(browserEntry);
+    }
+  }
+  return resolvedConfig;
+}
 
-export { defineVitestConfig, getVitestConfigFromNuxt };
+export { defineVitestConfig, defineVitestProject, getVitestConfigFromNuxt };

package/dist/e2e.d.mts

@@ -1,5 +1,5 @@
-import { T as TestOptions, a as TestContext, b as TestHooks } from './shared/test-utils.DgnIK8xl.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.DgnIK8xl.mjs';
+import { T as TestOptions, a as TestContext, b as TestHooks } from './shared/test-utils.DtJCg4f3.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.DtJCg4f3.mjs';
 import { LogType } from 'consola';
 import 'playwright-core';
 import '@nuxt/schema';
@@ -19,6 +19,8 @@ declare function mockLogger(): Record<LogType, (...args: unknown[]) => void>;
 declare function loadFixture(): Promise<void>;
 declare function buildFixture(): Promise<void>;
 
+declare function setupBun(hooks: TestHooks): Promise<void>;
+
 declare function setupCucumber(hooks: TestHooks): Promise<void>;
 
 declare function setupJest(hooks: TestHooks): Promise<void>;
@@ -26,6 +28,7 @@ declare function setupJest(hooks: TestHooks): Promise<void>;
 declare function setupVitest(hooks: TestHooks): Promise<void>;
 
 declare const setupMaps: {
+    bun: typeof setupBun;
     cucumber: typeof setupCucumber;
     jest: typeof setupJest;
     vitest: typeof setupVitest;
@@ -42,4 +45,5 @@ interface RunTestOptions {
 }
 declare function runTests(opts: RunTestOptions): Promise<void>;
 
-export { type RunTestOptions, TestContext, TestHooks, TestOptions, buildFixture, createTest, createTestContext, exposeContextToEnv, isDev, loadFixture, mockFn, mockLogger, recoverContextFromEnv, runTests, setTestContext, setup, setupMaps, useTestContext };
+export { TestContext, TestHooks, TestOptions, buildFixture, createTest, createTestContext, exposeContextToEnv, isDev, loadFixture, mockFn, mockLogger, recoverContextFromEnv, runTests, setTestContext, setup, setupMaps, useTestContext };
+export type { RunTestOptions };

package/dist/e2e.mjs

@@ -1,6 +1,6 @@
-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.BIDY1MqP.mjs';
-import { u as useTestContext } from './shared/test-utils.CHPAu7TP.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.CHPAu7TP.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.CT3RJOY3.mjs';
+import { u as useTestContext } from './shared/test-utils.B8qEdk9k.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.B8qEdk9k.mjs';
 import { consola } from 'consola';
 import { resolve } from 'pathe';
 import { distDir } from '#dirs';

package/dist/experimental.mjs

@@ -1,6 +1,6 @@
 import { resolve } from 'pathe';
 import { stringifyQuery } from 'ufo';
-import { $ as $fetch, u as useTestContext } from './shared/test-utils.CHPAu7TP.mjs';
+import { $ as $fetch, u as useTestContext } from './shared/test-utils.B8qEdk9k.mjs';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/module.d.mts

@@ -8,4 +8,5 @@ interface NuxtVitestOptions {
 }
 declare const _default: _nuxt_schema.NuxtModule<NuxtVitestOptions, NuxtVitestOptions, false>;
 
-export { type NuxtVitestOptions, _default as default };
+export { _default as default };
+export type { NuxtVitestOptions };

package/dist/module.mjs

@@ -12,6 +12,8 @@ import MagicString from 'magic-string';
 import { createUnplugin } from 'unplugin';
 import { readFileSync } from 'node:fs';
 import { extname, join, dirname } from 'pathe';
+import 'node:process';
+import 'vitest/config';
 import 'c12';
 import 'destr';
 import 'scule';
@@ -364,6 +366,11 @@ const module = defineNuxtModule({
       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 = {

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.DgnIK8xl.mjs';
+import { T as TestOptions$1, G as GotoOptions, b as TestHooks } from './shared/test-utils.DtJCg4f3.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
 
@@ -35,4 +35,5 @@ type TestOptions = {
  */
 declare const test: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & TestOptions, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions & WorkerOptions & ConfigOptions>;
 
-export { type ConfigOptions, test };
+export { test };
+export type { ConfigOptions };

package/dist/playwright.mjs

@@ -1,14 +1,14 @@
 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.BIDY1MqP.mjs';
+import { w as waitForHydration, d as createTest } from './shared/test-utils.CT3RJOY3.mjs';
 import 'node:path';
 import 'ufo';
 import 'std-env';
 import 'consola';
 import 'node:fs';
 import '@nuxt/kit';
-import { d as url } from './shared/test-utils.CHPAu7TP.mjs';
+import { d as url } from './shared/test-utils.B8qEdk9k.mjs';
 import 'pathe';
 import '#dirs';
 import 'tinyexec';
@@ -21,7 +21,7 @@ const test = test$1.extend({
   _nuxtHooks: [
     async ({ nuxt, defaults }, use) => {
       const hooks = createTest(defu(nuxt || {}, defaults.nuxt || {}));
-      await hooks.setup();
+      await hooks.beforeAll();
       await use(hooks);
       await hooks.afterAll();
     },

package/dist/runtime/browser-entry.d.ts

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

package/dist/runtime/browser-entry.mjs

@@ -0,0 +1,8 @@
+import environmentOptions from "nuxt-vitest-environment-options";
+import { setupNuxt } from "./shared/nuxt.mjs";
+import { setupWindow } from "./shared/environment.mjs";
+const el = document.querySelector(environmentOptions.nuxt.rootId || "nuxt-test");
+if (!el) {
+  await setupWindow(window, environmentOptions);
+  await setupNuxt();
+}

package/dist/runtime/entry.mjs

@@ -1,10 +1,7 @@
 import { vi } from "vitest";
+import { setupNuxt } from "./shared/nuxt.mjs";
 if (typeof window !== "undefined" && window.__NUXT_VITEST_ENVIRONMENT__) {
-  const { useRouter } = await import("#app/composables/router");
-  await import("#app/nuxt-vitest-app-entry").then((r) => r.default());
-  const nuxtApp = useNuxtApp();
-  await nuxtApp.callHook("page:finish");
-  useRouter().afterEach(() => nuxtApp.callHook("page:finish"));
+  await setupNuxt();
   vi.resetModules();
 }
 export {};

package/dist/runtime/global-setup.mjs

@@ -5,7 +5,7 @@ const options = JSON.parse(process.env.NUXT_TEST_OPTIONS || "{}");
 const hooks = createTest(options);
 export const setup = async () => {
   kit.logger.info("Building Nuxt app...");
-  await hooks.setup();
+  await hooks.beforeAll();
   exposeContextToEnv();
   kit.logger.info("Running tests...");
 };

package/dist/runtime/shared/environment.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtWindow } from '../../vitest-environment';
+import type { NuxtEnvironmentOptions } from '../../config';
+export declare function setupWindow(win: NuxtWindow, environmentOptions: {
+    nuxt: NuxtEnvironmentOptions;
+    nuxtRuntimeConfig?: Record<string, any>;
+    nuxtRouteRules?: Record<string, any>;
+}): Promise<() => void>;

package/dist/runtime/shared/environment.mjs

@@ -0,0 +1,123 @@
+import { createFetch } from "ofetch";
+import { joinURL } from "ufo";
+import { createApp, defineEventHandler, toNodeListener } from "h3";
+import { createRouter as createRadixRouter, exportMatcher, toRouteMatcher } from "radix3";
+import { fetchNodeRequestHandler } from "node-mock-http";
+export async function setupWindow(win, environmentOptions) {
+  win.__NUXT_VITEST_ENVIRONMENT__ = true;
+  win.__NUXT__ = {
+    serverRendered: false,
+    config: {
+      public: {},
+      app: { baseURL: "/" },
+      ...environmentOptions?.nuxtRuntimeConfig
+    },
+    data: {},
+    state: {}
+  };
+  const rootId = environmentOptions.nuxt.rootId || "nuxt-test";
+  let el;
+  try {
+    el = win.document.querySelector(rootId);
+  } catch {
+  }
+  if (el) {
+    return () => {
+    };
+  }
+  const consoleInfo = console.info;
+  console.info = (...args) => {
+    if (args[0] === "<Suspense> is an experimental feature and its API will likely change.") {
+      return;
+    }
+    return consoleInfo(...args);
+  };
+  const app = win.document.createElement("div");
+  app.id = rootId;
+  win.document.body.appendChild(app);
+  const h3App = createApp();
+  if (!win.fetch) {
+    await import("node-fetch-native/polyfill");
+    win.URLSearchParams = globalThis.URLSearchParams;
+  }
+  const nodeHandler = toNodeListener(h3App);
+  const registry = /* @__PURE__ */ new Set();
+  win.fetch = async (url, init) => {
+    if (typeof url === "string") {
+      const base = url.split("?")[0];
+      if (registry.has(base) || registry.has(url)) {
+        url = "/_" + url;
+      }
+      if (url.startsWith("/")) {
+        const response = await fetchNodeRequestHandler(nodeHandler, url, init);
+        return normalizeFetchResponse(response);
+      }
+    }
+    return fetch(url, init);
+  };
+  win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
+  win.__registry = registry;
+  win.__app = h3App;
+  const timestamp = Date.now();
+  const routeRulesMatcher = toRouteMatcher(
+    createRadixRouter({ routes: environmentOptions.nuxtRouteRules || {} })
+  );
+  const matcher = exportMatcher(routeRulesMatcher);
+  const manifestOutputPath = joinURL(
+    environmentOptions?.nuxtRuntimeConfig?.app?.baseURL || "/",
+    environmentOptions?.nuxtRuntimeConfig?.app?.buildAssetsDir || "_nuxt",
+    "builds"
+  );
+  const manifestBaseRoutePath = joinURL("/_", manifestOutputPath);
+  const buildId = win.__NUXT__.config?.app.buildId || "test";
+  h3App.use(
+    `${manifestBaseRoutePath}/latest.json`,
+    defineEventHandler(() => ({
+      id: buildId,
+      timestamp
+    }))
+  );
+  h3App.use(
+    `${manifestBaseRoutePath}/meta/${buildId}.json`,
+    defineEventHandler(() => ({
+      id: buildId,
+      timestamp,
+      matcher,
+      prerendered: []
+    }))
+  );
+  registry.add(`${manifestOutputPath}/latest.json`);
+  registry.add(`${manifestOutputPath}/meta/${buildId}.json`);
+  return () => {
+    console.info = consoleInfo;
+  };
+}
+function normalizeFetchResponse(response) {
+  if (!response.headers.has("set-cookie")) {
+    return response;
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: normalizeCookieHeaders(response.headers)
+  });
+}
+function normalizeCookieHeader(header = "") {
+  return splitCookiesString(joinHeaders(header));
+}
+function normalizeCookieHeaders(headers) {
+  const outgoingHeaders = new Headers();
+  for (const [name, header] of headers) {
+    if (name === "set-cookie") {
+      for (const cookie of normalizeCookieHeader(header)) {
+        outgoingHeaders.append("set-cookie", cookie);
+      }
+    } else {
+      outgoingHeaders.set(name, joinHeaders(header));
+    }
+  }
+  return outgoingHeaders;
+}
+function joinHeaders(value) {
+  return Array.isArray(value) ? value.join(", ") : String(value);
+}

package/dist/runtime/shared/nuxt.d.ts

@@ -0,0 +1 @@
+export declare function setupNuxt(): Promise<void>;

package/dist/runtime/shared/nuxt.mjs

@@ -0,0 +1,7 @@
+export async function setupNuxt() {
+  const { useRouter } = await import("#app/composables/router");
+  await import("#app/nuxt-vitest-app-entry").then((r) => r.default());
+  const nuxtApp = useNuxtApp();
+  await nuxtApp.callHook("page:finish");
+  useRouter().afterEach(() => nuxtApp.callHook("page:finish"));
+}

package/dist/runtime-utils/index.mjs

@@ -296,70 +296,73 @@ async function renderSuspended(component, options) {
           // because there's no root element while Suspense is resolving
           h$1(
             WrapperComponent,
-            h$1(
-              Suspense,
-              {
-                onResolve: () => nextTick().then(() => {
-                  utils.setupState = setupState;
-                  resolve(utils);
-                })
-              },
-              {
-                default: () => h$1({
-                  name: "RenderHelper",
-                  async setup() {
-                    const router = useRouter();
-                    await router.replace(route);
-                    const clonedComponent = {
-                      name: "RenderSuspendedComponent",
-                      ...component,
-                      render: render ? function(_ctx, ...args) {
-                        if (data && typeof data === "function") {
-                          const dataObject = data();
-                          for (const key in dataObject) {
-                            renderContext[key] = dataObject[key];
+            {},
+            {
+              default: () => h$1(
+                Suspense,
+                {
+                  onResolve: () => nextTick().then(() => {
+                    utils.setupState = setupState;
+                    resolve(utils);
+                  })
+                },
+                {
+                  default: () => h$1({
+                    name: "RenderHelper",
+                    async setup() {
+                      const router = useRouter();
+                      await router.replace(route);
+                      const clonedComponent = {
+                        name: "RenderSuspendedComponent",
+                        ...component,
+                        render: render ? function(_ctx, ...args) {
+                          if (data && typeof data === "function") {
+                            const dataObject = data();
+                            for (const key in dataObject) {
+                              renderContext[key] = dataObject[key];
+                            }
                           }
-                        }
-                        for (const key in setupState || {}) {
-                          const warn = console.warn;
-                          console.warn = () => {
-                          };
-                          try {
-                            renderContext[key] = isReadonly(setupState[key]) ? unref(setupState[key]) : setupState[key];
-                          } catch {
-                          } finally {
-                            console.warn = warn;
+                          for (const key in setupState || {}) {
+                            const warn = console.warn;
+                            console.warn = () => {
+                            };
+                            try {
+                              renderContext[key] = isReadonly(setupState[key]) ? unref(setupState[key]) : setupState[key];
+                            } catch {
+                            } finally {
+                              console.warn = warn;
+                            }
+                            if (key === "props") {
+                              renderContext[key] = cloneProps(renderContext[key]);
+                            }
                           }
-                          if (key === "props") {
-                            renderContext[key] = cloneProps(renderContext[key]);
+                          const propsContext = "props" in renderContext ? renderContext.props : renderContext;
+                          for (const key in props || {}) {
+                            propsContext[key] = _ctx[key];
                           }
-                        }
-                        const propsContext = "props" in renderContext ? renderContext.props : renderContext;
-                        for (const key in props || {}) {
-                          propsContext[key] = _ctx[key];
-                        }
-                        for (const key in passedProps || {}) {
-                          propsContext[key] = passedProps[key];
-                        }
-                        if (methods && typeof methods === "object") {
-                          for (const key in methods) {
-                            renderContext[key] = methods[key].bind(renderContext);
+                          for (const key in passedProps || {}) {
+                            propsContext[key] = passedProps[key];
                           }
-                        }
-                        if (computed && typeof computed === "object") {
-                          for (const key in computed) {
-                            renderContext[key] = computed[key].call(renderContext);
+                          if (methods && typeof methods === "object") {
+                            for (const key in methods) {
+                              renderContext[key] = methods[key].bind(renderContext);
+                            }
                           }
-                        }
-                        return render.call(this, renderContext, ...args);
-                      } : void 0,
-                      setup: setup ? (props2) => wrappedSetup(props2, setupContext) : void 0
-                    };
-                    return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...attrs }, slots);
-                  }
-                })
-              }
-            )
+                          if (computed && typeof computed === "object") {
+                            for (const key in computed) {
+                              renderContext[key] = computed[key].call(renderContext);
+                            }
+                          }
+                          return render.call(this, renderContext, ...args);
+                        } : void 0,
+                        setup: setup ? (props2) => wrappedSetup(props2, setupContext) : void 0
+                      };
+                      return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...attrs }, slots);
+                    }
+                  })
+                }
+              )
+            }
           )
         )
       },

package/dist/shared/{test-utils.CHPAu7TP.mjs → test-utils.B8qEdk9k.mjs}

@@ -5,7 +5,7 @@ import { resolve as resolve$1 } from 'pathe';
 import { withTrailingSlash, joinURL } from 'ufo';
 import { resolve } from 'node:path';
 import { defu } from 'defu';
-import { isWindows } from 'std-env';
+import { isWindows, isBun } from 'std-env';
 
 let currentContext;
 function createTestContext(options) {
@@ -39,6 +39,8 @@ function createTestContext(options) {
     _options.runner ||= "vitest";
   } else if (process.env.JEST_WORKER_ID) {
     _options.runner ||= "jest";
+  } else if (isBun) {
+    _options.runner ||= "bun";
   }
   return setTestContext({
     options: _options,

package/dist/shared/{test-utils.BIDY1MqP.mjs → test-utils.CT3RJOY3.mjs}

@@ -1,4 +1,4 @@
-import { u as useTestContext, d as url, c as createTestContext, a as startServer, b as stopServer, s as setTestContext } from './test-utils.CHPAu7TP.mjs';
+import { u as useTestContext, d as url, c as createTestContext, a as startServer, b as stopServer, s as setTestContext } from './test-utils.B8qEdk9k.mjs';
 import { existsSync, promises } from 'node:fs';
 import { resolve } from 'node:path';
 import { defu } from 'defu';
@@ -113,9 +113,18 @@ async function buildFixture() {
   kit.logger.level = prevLevel;
 }
 
+async function setupBun(hooks) {
+  const bunTest = await import('bun:test');
+  hooks.ctx.mockFn = bunTest.mock;
+  bunTest.beforeAll(hooks.beforeAll);
+  bunTest.beforeEach(hooks.beforeEach);
+  bunTest.afterEach(hooks.afterEach);
+  bunTest.afterAll(hooks.afterAll);
+}
+
 async function setupCucumber(hooks) {
   const { After, AfterAll, Before, BeforeAll } = await import('@cucumber/cucumber');
-  BeforeAll({ timeout: hooks.ctx.options.setupTimeout }, hooks.setup);
+  BeforeAll({ timeout: hooks.ctx.options.setupTimeout }, hooks.beforeAll);
   Before(hooks.beforeEach);
   After(hooks.afterEach);
   AfterAll(hooks.afterAll);
@@ -124,7 +133,7 @@ async function setupCucumber(hooks) {
 async function setupJest(hooks) {
   const { jest, test, beforeEach, afterAll, afterEach } = await import('@jest/globals');
   hooks.ctx.mockFn = jest.fn;
-  test("setup", hooks.setup, hooks.ctx.options.setupTimeout);
+  test("setup", hooks.beforeAll, hooks.ctx.options.setupTimeout);
   beforeEach(hooks.beforeEach);
   afterEach(hooks.afterEach);
   afterAll(hooks.afterAll, hooks.ctx.options.teardownTimeout);
@@ -133,13 +142,14 @@ async function setupJest(hooks) {
 async function setupVitest(hooks) {
   const vitest = await import('vitest');
   hooks.ctx.mockFn = vitest.vi.fn;
-  vitest.beforeAll(hooks.setup, hooks.ctx.options.setupTimeout);
+  vitest.beforeAll(hooks.beforeAll, hooks.ctx.options.setupTimeout);
   vitest.beforeEach(hooks.beforeEach);
   vitest.afterEach(hooks.afterEach);
   vitest.afterAll(hooks.afterAll, hooks.ctx.options.teardownTimeout);
 }
 
 const setupMaps = {
+  bun: setupBun,
   cucumber: setupCucumber,
   jest: setupJest,
   vitest: setupVitest
@@ -166,7 +176,7 @@ function createTest(options) {
     }
     await Promise.all(!ctx.teardown ? [] : ctx.teardown.map((fn) => fn()));
   };
-  const setup2 = async () => {
+  const beforeAll = async () => {
     if (ctx.options.fixture) {
       await loadFixture();
     }
@@ -187,7 +197,8 @@ function createTest(options) {
     beforeEach,
     afterEach,
     afterAll,
-    setup: setup2,
+    beforeAll,
+    setup: beforeAll,
     ctx
   };
 }

package/dist/shared/{test-utils.DgnIK8xl.d.mts → test-utils.DtJCg4f3.d.mts}

@@ -23,7 +23,7 @@ declare function fetch(path: string, options?: RequestInit): Promise<Response>;
 declare const $fetch: (typeof globalThis)["$fetch"];
 declare function url(path: string): string;
 
-type TestRunner = 'vitest' | 'jest' | 'cucumber';
+type TestRunner = 'vitest' | 'jest' | 'cucumber' | 'bun';
 interface TestOptions {
     testDir: string;
     fixture: string;
@@ -62,7 +62,7 @@ interface TestOptions {
      */
     browser: boolean;
     /**
-     * Specify the runner for the test suite. One of `'vitest' | 'jest' | 'cucumber'`.
+     * Specify the runner for the test suite. One of `'vitest' | 'jest' | 'cucumber' | 'bun'`.
      * @default `vitest`
      */
     runner: TestRunner;
@@ -107,8 +107,13 @@ interface TestHooks {
     beforeEach: () => void;
     afterEach: () => void;
     afterAll: () => Promise<void>;
+    beforeAll: () => Promise<void>;
+    /**
+     * @deprecated use `beforeAll` intead
+     */
     setup: () => Promise<void>;
     ctx: TestContext;
 }
 
-export { $fetch as $, type GotoOptions as G, type NuxtPage as N, type StartServerOptions as S, type TestOptions as T, type TestContext as a, type TestHooks as b, createBrowser as c, createPage as d, stopServer as e, fetch as f, getBrowser as g, type TestRunner as h, startServer as s, url as u, waitForHydration as w };
+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 };

package/dist/vitest-environment.d.mts

@@ -25,4 +25,5 @@ type EnvironmentNuxt = (global: typeof globalThis, options: EnvironmentNuxtOptio
     teardown(): void;
 }>;
 
-export { type EnvironmentNuxt, type EnvironmentNuxtOptions, type NuxtBuiltinEnvironment, type NuxtWindow, _default as default };
+export { _default as default };
+export type { EnvironmentNuxt, EnvironmentNuxtOptions, NuxtBuiltinEnvironment, NuxtWindow };

package/dist/vitest-environment.mjs

@@ -1,13 +1,132 @@
-import { createFetch } from 'ofetch';
 import { indexedDB } from 'fake-indexeddb';
 import { joinURL } from 'ufo';
-import { createApp, toNodeListener, defineEventHandler, splitCookiesString } from 'h3';
 import defu from 'defu';
-import { toRouteMatcher, createRouter, exportMatcher } from 'radix3';
 import { populateGlobal } from 'vitest/environments';
+import { createFetch } from 'ofetch';
+import { createApp, toNodeListener, defineEventHandler } from 'h3';
+import { toRouteMatcher, createRouter, exportMatcher } from 'radix3';
 import { fetchNodeRequestHandler } from 'node-mock-http';
 import { importModule } from 'local-pkg';
 
+async function setupWindow(win, environmentOptions) {
+  win.__NUXT_VITEST_ENVIRONMENT__ = true;
+  win.__NUXT__ = {
+    serverRendered: false,
+    config: {
+      public: {},
+      app: { baseURL: "/" },
+      ...environmentOptions?.nuxtRuntimeConfig
+    },
+    data: {},
+    state: {}
+  };
+  const rootId = environmentOptions.nuxt.rootId || "nuxt-test";
+  let el;
+  try {
+    el = win.document.querySelector(rootId);
+  } catch {
+  }
+  if (el) {
+    return () => {
+    };
+  }
+  const consoleInfo = console.info;
+  console.info = (...args) => {
+    if (args[0] === "<Suspense> is an experimental feature and its API will likely change.") {
+      return;
+    }
+    return consoleInfo(...args);
+  };
+  const app = win.document.createElement("div");
+  app.id = rootId;
+  win.document.body.appendChild(app);
+  const h3App = createApp();
+  if (!win.fetch) {
+    await import('node-fetch-native/polyfill');
+    win.URLSearchParams = globalThis.URLSearchParams;
+  }
+  const nodeHandler = toNodeListener(h3App);
+  const registry = /* @__PURE__ */ new Set();
+  win.fetch = async (url, init) => {
+    if (typeof url === "string") {
+      const base = url.split("?")[0];
+      if (registry.has(base) || registry.has(url)) {
+        url = "/_" + url;
+      }
+      if (url.startsWith("/")) {
+        const response = await fetchNodeRequestHandler(nodeHandler, url, init);
+        return normalizeFetchResponse(response);
+      }
+    }
+    return fetch(url, init);
+  };
+  win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
+  win.__registry = registry;
+  win.__app = h3App;
+  const timestamp = Date.now();
+  const routeRulesMatcher = toRouteMatcher(
+    createRouter({ routes: environmentOptions.nuxtRouteRules || {} })
+  );
+  const matcher = exportMatcher(routeRulesMatcher);
+  const manifestOutputPath = joinURL(
+    environmentOptions?.nuxtRuntimeConfig?.app?.baseURL || "/",
+    environmentOptions?.nuxtRuntimeConfig?.app?.buildAssetsDir || "_nuxt",
+    "builds"
+  );
+  const manifestBaseRoutePath = joinURL("/_", manifestOutputPath);
+  const buildId = win.__NUXT__.config?.app.buildId || "test";
+  h3App.use(
+    `${manifestBaseRoutePath}/latest.json`,
+    defineEventHandler(() => ({
+      id: buildId,
+      timestamp
+    }))
+  );
+  h3App.use(
+    `${manifestBaseRoutePath}/meta/${buildId}.json`,
+    defineEventHandler(() => ({
+      id: buildId,
+      timestamp,
+      matcher,
+      prerendered: []
+    }))
+  );
+  registry.add(`${manifestOutputPath}/latest.json`);
+  registry.add(`${manifestOutputPath}/meta/${buildId}.json`);
+  return () => {
+    console.info = consoleInfo;
+  };
+}
+function normalizeFetchResponse(response) {
+  if (!response.headers.has("set-cookie")) {
+    return response;
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: normalizeCookieHeaders(response.headers)
+  });
+}
+function normalizeCookieHeader(header = "") {
+  return splitCookiesString(joinHeaders(header));
+}
+function normalizeCookieHeaders(headers) {
+  const outgoingHeaders = new Headers();
+  for (const [name, header] of headers) {
+    if (name === "set-cookie") {
+      for (const cookie of normalizeCookieHeader(header)) {
+        outgoingHeaders.append("set-cookie", cookie);
+      }
+    } else {
+      outgoingHeaders.set(name, joinHeaders(header));
+    }
+  }
+  return outgoingHeaders;
+}
+function joinHeaders(value) {
+  return Array.isArray(value) ? value.join(", ") : String(value);
+}
+
 const happyDom = (async function(_, { happyDom = {} }) {
   const { Window, GlobalWindow } = await importModule("happy-dom");
   const window = new (GlobalWindow || Window)(happyDom);
@@ -58,33 +177,12 @@ const index = {
       environmentOptions?.nuxt.url ?? "http://localhost:3000",
       environmentOptions?.nuxtRuntimeConfig.app?.baseURL || "/"
     );
-    const consoleInfo = console.info;
-    console.info = (...args) => {
-      if (args[0] === "<Suspense> is an experimental feature and its API will likely change.") {
-        return;
-      }
-      return consoleInfo(...args);
-    };
     const environmentName = environmentOptions.nuxt.domEnvironment;
     const environment = environmentMap[environmentName] || environmentMap["happy-dom"];
     const { window: win, teardown } = await environment(global, defu(environmentOptions, {
       happyDom: { url },
       jsdom: { url }
     }));
-    win.__NUXT_VITEST_ENVIRONMENT__ = true;
-    win.__NUXT__ = {
-      serverRendered: false,
-      config: {
-        public: {},
-        app: { baseURL: "/" },
-        ...environmentOptions?.nuxtRuntimeConfig
-      },
-      data: {},
-      state: {}
-    };
-    const app = win.document.createElement("div");
-    app.id = environmentOptions.nuxt.rootId;
-    win.document.body.appendChild(app);
     if (environmentOptions?.nuxt?.mock?.intersectionObserver) {
       win.IntersectionObserver = win.IntersectionObserver || class IntersectionObserver {
         observe() {
@@ -98,101 +196,20 @@ const index = {
     if (environmentOptions?.nuxt?.mock?.indexedDb) {
       win.indexedDB = indexedDB;
     }
-    const h3App = createApp();
-    if (!win.fetch) {
-      await import('node-fetch-native/polyfill');
-      win.URLSearchParams = globalThis.URLSearchParams;
-    }
-    const nodeHandler = toNodeListener(h3App);
-    const registry = /* @__PURE__ */ new Set();
-    win.fetch = async (url2, init) => {
-      if (typeof url2 === "string") {
-        const base = url2.split("?")[0];
-        if (registry.has(base) || registry.has(url2)) {
-          url2 = "/_" + url2;
-        }
-        if (url2.startsWith("/")) {
-          const response = await fetchNodeRequestHandler(nodeHandler, url2, init);
-          return normalizeFetchResponse(response);
-        }
-      }
-      return fetch(url2, init);
-    };
-    win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
-    win.__registry = registry;
-    win.__app = h3App;
+    const teardownWindow = await setupWindow(win, environmentOptions);
     const { keys, originals } = populateGlobal(global, win, {
       bindFunctions: true
     });
-    const timestamp = Date.now();
-    const routeRulesMatcher = toRouteMatcher(
-      createRouter({ routes: environmentOptions.nuxtRouteRules || {} })
-    );
-    const matcher = exportMatcher(routeRulesMatcher);
-    const manifestOutputPath = joinURL(
-      "/",
-      environmentOptions?.nuxtRuntimeConfig.app?.buildAssetsDir || "_nuxt",
-      "builds"
-    );
-    const manifestBaseRoutePath = joinURL("/_", manifestOutputPath);
-    const buildId = win.__NUXT__.config.app.buildId || "test";
-    h3App.use(
-      `${manifestBaseRoutePath}/latest.json`,
-      defineEventHandler(() => ({
-        id: buildId,
-        timestamp
-      }))
-    );
-    h3App.use(
-      `${manifestBaseRoutePath}/meta/${buildId}.json`,
-      defineEventHandler(() => ({
-        id: buildId,
-        timestamp,
-        matcher,
-        prerendered: []
-      }))
-    );
-    registry.add(`${manifestOutputPath}/latest.json`);
-    registry.add(`${manifestOutputPath}/meta/${buildId}.json`);
     return {
       // called after all tests with this env have been run
       teardown() {
         keys.forEach((key) => delete global[key]);
-        console.info = consoleInfo;
+        teardownWindow();
         originals.forEach((v, k) => global[k] = v);
         teardown();
       }
     };
   }
 };
-function normalizeFetchResponse(response) {
-  if (!response.headers.has("set-cookie")) {
-    return response;
-  }
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: normalizeCookieHeaders(response.headers)
-  });
-}
-function normalizeCookieHeader(header = "") {
-  return splitCookiesString(joinHeaders(header));
-}
-function normalizeCookieHeaders(headers) {
-  const outgoingHeaders = new Headers();
-  for (const [name, header] of headers) {
-    if (name === "set-cookie") {
-      for (const cookie of normalizeCookieHeader(header)) {
-        outgoingHeaders.append("set-cookie", cookie);
-      }
-    } else {
-      outgoingHeaders.set(name, joinHeaders(header));
-    }
-  }
-  return outgoingHeaders;
-}
-function joinHeaders(value) {
-  return Array.isArray(value) ? value.join(", ") : String(value);
-}
 
 export { index as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/test-utils",
-  "version": "3.17.2",
+  "version": "3.19.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/test-utils.git"
@@ -63,16 +63,16 @@
     "dev:prepare": "nuxi prepare && unbuild --stub && pnpm -r dev:prepare"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.16.0",
-    "@nuxt/schema": "^3.16.0",
-    "c12": "^3.0.2",
-    "consola": "^3.4.0",
+    "@nuxt/kit": "^3.17.3",
+    "@nuxt/schema": "^3.17.3",
+    "c12": "^3.0.3",
+    "consola": "^3.4.2",
     "defu": "^6.1.4",
-    "destr": "^2.0.3",
+    "destr": "^2.0.5",
     "estree-walker": "^3.0.3",
-    "fake-indexeddb": "^6.0.0",
+    "fake-indexeddb": "^6.0.1",
     "get-port-please": "^3.1.2",
-    "h3": "^1.15.1",
+    "h3": "^1.15.3",
     "local-pkg": "^1.1.1",
     "magic-string": "^0.30.17",
     "node-fetch-native": "^1.6.5",
@@ -82,43 +82,44 @@
     "perfect-debounce": "^1.0.0",
     "radix3": "^1.1.2",
     "scule": "^1.3.0",
-    "std-env": "^3.8.1",
-    "tinyexec": "^0.3.2",
-    "ufo": "^1.5.4",
-    "unplugin": "^2.2.0",
-    "vite": "^6.2.1",
+    "std-env": "^3.9.0",
+    "tinyexec": "^1.0.1",
+    "ufo": "^1.6.1",
+    "unplugin": "^2.3.3",
+    "vite": "^6.3.5",
     "vitest-environment-nuxt": "^1.0.1",
     "vue": "^3.5.13"
   },
   "devDependencies": {
     "@cucumber/cucumber": "11.2.0",
     "@jest/globals": "29.7.0",
-    "@nuxt/devtools-kit": "2.2.1",
-    "@nuxt/eslint-config": "1.1.0",
-    "@playwright/test": "1.51.0",
+    "@nuxt/devtools-kit": "2.4.0",
+    "@nuxt/eslint-config": "1.3.1",
+    "@playwright/test": "1.52.0",
     "@testing-library/vue": "8.1.0",
-    "@types/estree": "1.0.6",
+    "@types/bun": "1.2.13",
+    "@types/estree": "1.0.7",
     "@types/jsdom": "21.1.7",
-    "@types/node": "22.13.10",
-    "@types/semver": "7.5.8",
+    "@types/node": "22.15.17",
+    "@types/semver": "7.7.0",
     "@vue/test-utils": "2.4.6",
     "changelogen": "0.6.1",
-    "compatx": "0.1.8",
-    "eslint": "9.22.0",
+    "compatx": "0.2.0",
+    "eslint": "9.26.0",
     "installed-check": "9.3.0",
-    "knip": "5.45.0",
-    "nitropack": "2.11.5",
-    "nuxt": "3.16.0",
-    "pkg-pr-new": "0.0.40",
-    "playwright-core": "1.51.0",
-    "rollup": "4.35.0",
-    "semver": "7.7.1",
-    "typescript": "5.8.2",
+    "knip": "5.55.1",
+    "nitropack": "2.11.11",
+    "nuxt": "3.17.3",
+    "pkg-pr-new": "0.0.44",
+    "playwright-core": "1.52.0",
+    "rollup": "4.40.2",
+    "semver": "7.7.2",
+    "typescript": "5.8.3",
     "unbuild": "latest",
-    "unimport": "4.1.2",
-    "vitest": "3.0.8",
-    "vue-router": "4.5.0",
-    "vue-tsc": "2.2.8"
+    "unimport": "5.0.1",
+    "vitest": "3.1.3",
+    "vue-router": "4.5.1",
+    "vue-tsc": "2.2.10"
   },
   "peerDependencies": {
     "@cucumber/cucumber": "^10.3.1 || ^11.0.0",
@@ -166,22 +167,25 @@
   "resolutions": {
     "@cucumber/cucumber": "11.2.0",
     "@nuxt/devtools": "1.0.8",
-    "@nuxt/kit": "^3.16.0",
-    "@nuxt/schema": "^3.16.0",
+    "@nuxt/kit": "^3.17.3",
+    "@nuxt/schema": "^3.17.3",
     "@nuxt/test-utils": "workspace:*",
-    "rollup": "4.35.0",
-    "vite": "^6.2.1",
-    "vite-node": "3.0.8",
-    "vitest": "3.0.8",
+    "rollup": "4.40.2",
+    "vite": "^6.3.5",
+    "vite-node": "3.1.3",
+    "vitest": "3.1.3",
     "vue": "^3.5.13"
   },
   "engines": {
     "node": "^18.20.5 || ^20.9.0 || ^22.0.0 || >=23.0.0"
   },
-  "packageManager": "pnpm@10.6.1",
+  "packageManager": "pnpm@10.10.0",
   "pnpm": {
     "onlyBuiltDependencies": [
       "better-sqlite3"
+    ],
+    "ignoredBuiltDependencies": [
+      "esbuild"
     ]
   }
 }