@nuxt/test-utils 3.19.2 → 3.21.0

package/dist/runtime-utils/index.mjs

@@ -1,6 +1,6 @@
 import { defineEventHandler } from 'h3';
 import { mount } from '@vue/test-utils';
-import { reactive, h as h$1, Suspense, nextTick, getCurrentInstance, unref, isReadonly, defineComponent as defineComponent$1, effectScope } from 'vue';
+import { reactive, h as h$1, Suspense, nextTick, getCurrentInstance, effectScope, defineComponent as defineComponent$1 } from 'vue';
 import { defu } from 'defu';
 import { defineComponent, useRouter, h, tryUseNuxtApp } from '#imports';
 import NuxtRoot from '#build/root-component.mjs';
@@ -11,16 +11,25 @@ function registerEndpoint(url, options) {
   if (!app) {
     throw new Error("registerEndpoint() can only be used in a `@nuxt/test-utils` runtime environment");
   }
-  const config = typeof options === "function" ? { handler: options, method: void 0 } : options;
+  const config = typeof options === "function" ? { handler: options, method: void 0, once: false } : options;
   config.handler = defineEventHandler(config.handler);
   const hasBeenRegistered = window.__registry.has(url);
   endpointRegistry[url] ||= [];
   endpointRegistry[url].push(config);
   if (!hasBeenRegistered) {
     window.__registry.add(url);
-    app.use("/_" + url, defineEventHandler((event) => {
+    app.use("/_" + url, defineEventHandler(async (event) => {
       const latestHandler = [...endpointRegistry[url] || []].reverse().find((config2) => config2.method ? event.method === config2.method : true);
-      return latestHandler?.handler(event);
+      if (!latestHandler) return;
+      const result = await latestHandler.handler(event);
+      if (!latestHandler.once) return result;
+      const index = endpointRegistry[url]?.indexOf(latestHandler);
+      if (index === void 0 || index === -1) return result;
+      endpointRegistry[url]?.splice(index, 1);
+      if (endpointRegistry[url]?.length === 0) {
+        window.__registry.delete(url);
+      }
+      return result;
     }), {
       match(_, event) {
         return endpointRegistry[url]?.some((config2) => config2.method ? event?.method === config2.method : true) ?? false;
@@ -34,7 +43,7 @@ function registerEndpoint(url, options) {
     }
   };
 }
-function mockNuxtImport(_name, _factory) {
+function mockNuxtImport(_target, _factory) {
   throw new Error(
     "mockNuxtImport() is a macro and it did not get transpiled. This may be an internal bug of @nuxt/test-utils."
   );
@@ -87,16 +96,48 @@ async function mountSuspended(component, options) {
     route = "/",
     ..._options
   } = options || {};
+  for (const cleanupFunction of globalThis.__cleanup || []) {
+    cleanupFunction();
+  }
   const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, data, computed, methods } = component;
+  const { render, setup, ...componentRest } = component;
+  let wrappedInstance = null;
   let setupContext;
   let setupState;
   const setProps = reactive({});
-  let passedProps;
-  const wrappedSetup = async (props2, setupContext2) => {
-    passedProps = props2;
+  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;
+    }
+  }
+  let componentScope = null;
+  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);
+      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);
+      }
+      if (wrappedInstance?.exposed) {
+        instanceContext.expose(wrappedInstance.exposed);
+      }
       setupState = result && typeof result === "object" ? result : {};
       return result;
     }
@@ -105,15 +146,32 @@ async function mountSuspended(component, options) {
     (resolve) => {
       const vm = mount(
         {
+          __cssModules: componentRest.__cssModules,
+          inheritAttrs: false,
           setup: (props2, ctx) => {
+            patchInstanceAppContext();
+            wrappedInstance = getCurrentInstance();
             setupContext = ctx;
-            return NuxtRoot.setup(props2, {
-              ...ctx,
-              expose: () => {
-              }
-            });
+            if (options?.scoped) {
+              const scope = effectScope();
+              globalThis.__cleanup ||= [];
+              globalThis.__cleanup.push(() => {
+                scope.stop();
+              });
+              return scope.run(() => NuxtRoot.setup(props2, {
+                ...ctx,
+                expose: () => {
+                }
+              }));
+            } else {
+              return NuxtRoot.setup(props2, {
+                ...ctx,
+                expose: () => {
+                }
+              });
+            }
           },
-          render: (renderContext) => h$1(
+          render: () => h$1(
             Suspense,
             {
               onResolve: () => nextTick().then(() => {
@@ -130,66 +188,13 @@ async function mountSuspended(component, options) {
                 async setup() {
                   const router = useRouter();
                   await router.replace(route);
-                  let interceptedEmit = null;
                   const clonedComponent = {
-                    name: "MountSuspendedComponent",
+                    components: {},
                     ...component,
-                    render: render ? function(_ctx, ...args) {
-                      const currentInstance = getCurrentInstance();
-                      if (currentInstance && currentInstance.emit !== interceptedEmit) {
-                        const oldEmit = currentInstance.emit;
-                        interceptedEmit = (event, ...args2) => {
-                          oldEmit(event, ...args2);
-                          setupContext.emit(event, ...args2);
-                        };
-                        currentInstance.emit = interceptedEmit;
-                      }
-                      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;
-                        }
-                        if (key === "props") {
-                          renderContext[key] = cloneProps$1(renderContext[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, value] of Object.entries(methods)) {
-                          renderContext[key] = value.bind(renderContext);
-                        }
-                      }
-                      if (computed && typeof computed === "object") {
-                        for (const [key, value] of Object.entries(computed)) {
-                          if ("get" in value) {
-                            renderContext[key] = value.get.call(renderContext);
-                          } else {
-                            renderContext[key] = value.call(renderContext);
-                          }
-                        }
-                      }
-                      return render.call(this, renderContext, ...args);
-                    } : void 0,
-                    setup: setup ? (props2) => wrappedSetup(props2, setupContext) : void 0
+                    name: "MountSuspendedComponent",
+                    setup: (props2, ctx) => wrappedSetup(props2, setupContext, ctx)
                   };
-                  return () => h$1(clonedComponent, { ...props, ...setProps, ...attrs }, slots);
+                  return () => h$1(clonedComponent, { ...props, ...setProps, ...attrs }, setupContext.slots);
                 }
               })
             }
@@ -198,11 +203,18 @@ async function mountSuspended(component, options) {
         defu(
           _options,
           {
+            props,
             slots,
             attrs,
             global: {
               config: {
-                globalProperties: vueApp.config.globalProperties
+                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,
@@ -219,33 +231,46 @@ async function mountSuspended(component, options) {
     }
   );
 }
-function cloneProps$1(props) {
-  const newProps = reactive({});
-  for (const key in props) {
-    newProps[key] = props[key];
-  }
-  return newProps;
-}
 function wrappedMountedWrapper(wrapper) {
-  const proxy = new Proxy(wrapper, {
-    get: (target, prop, receiver) => {
-      if (prop === "element") {
-        const component = target.findComponent({ name: "MountSuspendedComponent" });
-        return component[prop];
-      } else {
-        return Reflect.get(target, prop, receiver);
-      }
+  const component = wrapper.findComponent({ name: "MountSuspendedComponent" });
+  const wrapperProps = [
+    "setProps",
+    "emitted",
+    "setupState",
+    "unmount"
+  ];
+  return new Proxy(wrapper, {
+    get: (_, prop, receiver) => {
+      if (prop === "getCurrentComponent") return getCurrentComponentPatchedProxy;
+      const target = wrapperProps.includes(prop) ? wrapper : Reflect.has(component, prop) ? component : wrapper;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
     }
   });
-  for (const key of ["props"]) {
-    proxy[key] = new Proxy(wrapper[key], {
-      apply: (target, thisArg, args) => {
-        const component = thisArg.findComponent({ name: "MountSuspendedComponent" });
-        return component[key](...args);
+  function getCurrentComponentPatchedProxy() {
+    const currentComponent = component.getCurrentComponent();
+    return new Proxy(currentComponent, {
+      get: (target, prop, receiver) => {
+        const value = Reflect.get(target, prop, receiver);
+        if (prop === "proxy" && value) {
+          return new Proxy(value, {
+            get(o, p, r) {
+              if (!Reflect.has(currentComponent.props, p)) {
+                const setupState = wrapper.setupState;
+                if (setupState && typeof setupState === "object") {
+                  if (Reflect.has(setupState, p)) {
+                    return Reflect.get(setupState, p, r);
+                  }
+                }
+              }
+              return Reflect.get(o, p, r);
+            }
+          });
+        }
+        return value;
       }
     });
   }
-  return proxy;
 }
 
 const WRAPPER_EL_ID = "test-wrapper";
@@ -259,19 +284,36 @@ async function renderSuspended(component, options) {
   } = options || {};
   const { render: renderFromTestingLibrary } = await import('@testing-library/vue');
   const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, data, computed, methods } = component;
+  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();
-  let passedProps;
-  const wrappedSetup = async (props2, setupContext2) => {
-    passedProps = props2;
+  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;
     }
   };
@@ -284,7 +326,11 @@ async function renderSuspended(component, options) {
   return new Promise((resolve) => {
     const utils = renderFromTestingLibrary(
       {
+        __cssModules: componentRest.__cssModules,
+        inheritAttrs: false,
         setup: (props2, ctx) => {
+          patchInstanceAppContext();
+          wrappedInstance = getCurrentInstance();
           setupContext = ctx;
           const scope = effectScope();
           window.__cleanup ||= [];
@@ -296,7 +342,7 @@ async function renderSuspended(component, options) {
             expose: () => ({})
           }));
         },
-        render: (renderContext) => (
+        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
@@ -309,6 +355,10 @@ async function renderSuspended(component, options) {
                 {
                   onResolve: () => nextTick().then(() => {
                     utils.setupState = setupState;
+                    utils.rerender = async (props2) => {
+                      Object.assign(setProps, props2);
+                      await nextTick();
+                    };
                     resolve(utils);
                   })
                 },
@@ -319,55 +369,13 @@ async function renderSuspended(component, options) {
                       const router = useRouter();
                       await router.replace(route);
                       const clonedComponent = {
-                        name: "RenderSuspendedComponent",
+                        components: {},
                         ...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;
-                            }
-                            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];
-                          }
-                          for (const key in passedProps || {}) {
-                            propsContext[key] = passedProps[key];
-                          }
-                          if (methods && typeof methods === "object") {
-                            for (const [key, value] of Object.entries(methods)) {
-                              renderContext[key] = value.bind(renderContext);
-                            }
-                          }
-                          if (computed && typeof computed === "object") {
-                            for (const [key, value] of Object.entries(computed)) {
-                              if ("get" in value) {
-                                renderContext[key] = value.get.call(renderContext);
-                              } else {
-                                renderContext[key] = value.call(renderContext);
-                              }
-                            }
-                          }
-                          return render.call(this, renderContext, ...args);
-                        } : void 0,
-                        setup: setup ? (props2) => wrappedSetup(props2, setupContext) : void 0
+                        name: "RenderSuspendedComponent",
+                        render,
+                        setup: (props2, ctx) => wrappedSetup(props2, setupContext, ctx)
                       };
-                      return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...attrs }, slots);
+                      return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...setProps, ...attrs }, setupContext.slots);
                     }
                   })
                 }
@@ -377,11 +385,18 @@ async function renderSuspended(component, options) {
         )
       },
       defu(_options, {
+        props,
         slots,
         attrs,
         global: {
           config: {
-            globalProperties: vueApp.config.globalProperties
+            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,
@@ -391,12 +406,5 @@ async function renderSuspended(component, options) {
     );
   });
 }
-function cloneProps(props) {
-  const newProps = reactive({});
-  for (const key in props) {
-    newProps[key] = props[key];
-  }
-  return newProps;
-}
 
 export { mockComponent, mockNuxtImport, mountSuspended, registerEndpoint, renderSuspended };

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

@@ -29,41 +29,41 @@ interface TestOptions {
     fixture: string;
     /**
      * Name of the configuration file.
-     * @default `'nuxt.config`
+     * @default 'nuxt.config'
      */
     configFile: string;
     /**
      * Path to a directory with a Nuxt app to be put under test.
-     * @default `'.'`
+     * @default '.'
      */
     rootDir: string;
     buildDir: string;
     nuxtConfig: NuxtConfig;
     /**
      * Whether to run a separate build step.
-     * @default `true` (`false` if `browser` or `server` is disabled, or if a `host` is provided)
+     * @default true // (`false` if `browser` or `server` is disabled, or if a `host` is provided)
      */
     build: boolean;
     dev: boolean;
     /**
      * The amount of time (in milliseconds) to allow for `setupTest` to complete its work (which could include building or generating files for a Nuxt application, depending on the options that are passed).
-     * @default `120000` or `240000` on windows
+     * @default 120000 // or `240000` on windows
      */
     setupTimeout: number;
     /**
      * The amount of time (in milliseconds) to allow tearing down the test environment, such as closing the browser.
-     * @default `30000`
+     * @default 30000
      */
     teardownTimeout: number;
     waitFor: number;
     /**
      * Under the hood, Nuxt test utils uses [`playwright`](https://playwright.dev) to carry out browser testing. If this option is set, a browser will be launched and can be controlled in the subsequent test suite.
-     * @default `false`
+     * @default false
      */
     browser: boolean;
     /**
      * Specify the runner for the test suite. One of `'vitest' | 'jest' | 'cucumber' | 'bun'`.
-     * @default `vitest`
+     * @default 'vitest'
      */
     runner: TestRunner;
     logLevel: number;
@@ -75,17 +75,17 @@ interface TestOptions {
     };
     /**
      * Whether to launch a server to respond to requests in the test suite.
-     * @default `true` (`false` if a `host` is provided)
+     * @default true // (`false` if a `host` is provided)
      */
     server: boolean;
     /**
      * If provided, a URL to use as the test target instead of building and running a new server. Useful for running "real" end-to-end tests against a deployed version of your application, or against an already running local server.
-     * @default `undefined`
+     * @default undefined
      */
     host?: string;
     /**
      * If provided, set the launched test server port to the value.
-     * @default `undefined`
+     * @default undefined
      */
     port?: number;
     env?: StartServerOptions['env'];
@@ -109,7 +109,7 @@ interface TestHooks {
     afterAll: () => Promise<void>;
     beforeAll: () => Promise<void>;
     /**
-     * @deprecated use `beforeAll` intead
+     * @deprecated use `beforeAll` instead
      */
     setup: () => Promise<void>;
     ctx: TestContext;

package/dist/shared/{test-utils.CT3RJOY3.mjs → test-utils.3NR-so9-.mjs}

@@ -1,8 +1,8 @@
-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 { u as useTestContext, d as url, c as createTestContext, a as startServer, b as stopServer, s as setTestContext } from './test-utils.CtwoJP76.mjs';
 import { existsSync, promises } from 'node:fs';
 import { resolve } from 'node:path';
 import { defu } from 'defu';
-import * as _kit from '@nuxt/kit';
+import { l as loadKit } from './test-utils.G1ew4kEe.mjs';
 
 async function createBrowser() {
   const ctx = useTestContext();
@@ -57,9 +57,8 @@ async function waitForHydration(page, url2, waitUntil) {
   }
 }
 
-const kit = _kit.default || _kit;
 const isNuxtApp = (dir) => {
-  return existsSync(dir) && (existsSync(resolve(dir, "pages")) || existsSync(resolve(dir, "nuxt.config.js")) || existsSync(resolve(dir, "nuxt.config.mjs")) || existsSync(resolve(dir, "nuxt.config.cjs")) || existsSync(resolve(dir, "nuxt.config.ts")));
+  return existsSync(dir) && (existsSync(resolve(dir, "pages")) || existsSync(resolve(dir, "nuxt.config.js")) || existsSync(resolve(dir, "nuxt.config.mjs")) || existsSync(resolve(dir, "nuxt.config.cjs")) || existsSync(resolve(dir, "nuxt.config.ts")) || existsSync(resolve(dir, ".config", "nuxt.js")) || existsSync(resolve(dir, ".config", "nuxt.mjs")) || existsSync(resolve(dir, ".config", "nuxt.cjs")) || existsSync(resolve(dir, ".config", "nuxt.ts")));
 };
 const resolveRootDir = () => {
   const { options } = useTestContext();
@@ -91,7 +90,8 @@ async function loadFixture() {
     });
   }
   if (ctx.options.build) {
-    ctx.nuxt = await kit.loadNuxt({
+    const { loadNuxt } = await loadKit(ctx.options.rootDir);
+    ctx.nuxt = await loadNuxt({
       cwd: ctx.options.rootDir,
       dev: ctx.options.dev,
       overrides: ctx.options.nuxtConfig,
@@ -107,10 +107,11 @@ async function loadFixture() {
 }
 async function buildFixture() {
   const ctx = useTestContext();
-  const prevLevel = kit.logger.level;
-  kit.logger.level = ctx.options.logLevel;
-  await kit.buildNuxt(ctx.nuxt);
-  kit.logger.level = prevLevel;
+  const { buildNuxt, logger } = await loadKit(ctx.options.rootDir);
+  const prevLevel = logger.level;
+  logger.level = ctx.options.logLevel;
+  await buildNuxt(ctx.nuxt);
+  logger.level = prevLevel;
 }
 
 async function setupBun(hooks) {

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

@@ -14,7 +14,7 @@ function createTestContext(options) {
     fixture: "fixture",
     configFile: "nuxt.config",
     setupTimeout: isWindows ? 24e4 : 12e4,
-    teardownTimeout: 3e4,
+    teardownTimeout: isWindows ? 6e4 : 3e4,
     dev: !!JSON.parse(process.env.NUXT_TEST_DEV || "false"),
     logLevel: 1,
     server: true,

package/dist/shared/test-utils.G1ew4kEe.mjs

@@ -0,0 +1,67 @@
+import destr from 'destr';
+import { snakeCase } from 'scule';
+import { pathToFileURL } from 'node:url';
+import { resolveModulePath } from 'exsolve';
+
+function getEnv(key, opts) {
+  const env = opts.env ?? process.env;
+  const envKey = snakeCase(key).toUpperCase();
+  return destr(
+    env[opts.prefix + envKey] ?? env[opts.altPrefix + envKey]
+  );
+}
+function _isObject(input) {
+  return typeof input === "object" && !Array.isArray(input);
+}
+function applyEnv(obj, opts, parentKey = "") {
+  for (const key in obj) {
+    const subKey = parentKey ? `${parentKey}_${key}` : key;
+    const envValue = getEnv(subKey, opts);
+    if (_isObject(obj[key])) {
+      if (_isObject(envValue)) {
+        obj[key] = { ...obj[key], ...envValue };
+        applyEnv(obj[key], opts, subKey);
+      } else if (envValue === void 0) {
+        applyEnv(obj[key], opts, subKey);
+      } else {
+        obj[key] = envValue ?? obj[key];
+      }
+    } else {
+      obj[key] = envValue ?? obj[key];
+    }
+  }
+  return obj;
+}
+async function loadKit(rootDir) {
+  try {
+    const kitPath = resolveModulePath("@nuxt/kit", { from: tryResolveNuxt(rootDir) || rootDir });
+    let kit = await import(pathToFileURL(kitPath).href);
+    if (!kit.writeTypes) {
+      kit = {
+        ...kit,
+        writeTypes: () => {
+          throw new Error("`writeTypes` is not available in this version of `@nuxt/kit`. Please upgrade to v3.7 or newer.");
+        }
+      };
+    }
+    return kit;
+  } 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."
+      );
+    }
+    throw e;
+  }
+}
+function tryResolveNuxt(rootDir) {
+  for (const pkg of ["nuxt-nightly", "nuxt", "nuxt3", "nuxt-edge"]) {
+    const path = resolveModulePath(pkg, { from: rootDir, try: true });
+    if (path) {
+      return path;
+    }
+  }
+  return null;
+}
+
+export { applyEnv as a, loadKit as l };