@nuxt/kit 3.15.3 → 3.16.0

package/README.md

@@ -32,7 +32,6 @@ It provides a number of features that make it easy to build fast, SEO-friendly,
 - 🧩 [Modules](#modules)
 - ❤️  [Contribute](#contribute)
 - 🏠 [Local Development](#local-development)
-- ⛰️ [Nuxt 2](#nuxt-2)
 - 🛟 [Professional Support](#professional-support)
 - 🔗 [Follow Us](#follow-us)
 - ⚖️ [License](#license)
@@ -44,7 +43,7 @@ It provides a number of features that make it easy to build fast, SEO-friendly,
 Use the following command to create a new starter project. This will create a starter project with all the necessary files and dependencies:
 
 ```bash
-npx nuxi@latest init <my-project>
+npm create nuxt <my-project>
 ```
 
 > [!TIP]

package/dist/index.d.mts

@@ -1,10 +1,10 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { ModuleOptions, ModuleDefinition, NuxtModule, NuxtConfig, Nuxt, ModuleMeta, NuxtOptions, SchemaDefinition, ImportPresetWithDeprecation, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtTemplate, NuxtHooks, NuxtMiddleware, NuxtPlugin, NuxtPluginTemplate, ResolvedNuxtTemplate, NuxtServerTemplate, NuxtTypeTemplate } from '@nuxt/schema';
+import { ModuleOptions, ModuleDefinition, NuxtModule, NuxtConfig, Nuxt, ModuleMeta, NuxtOptions, SchemaDefinition, ImportPresetWithDeprecation, NuxtCompatibility, NuxtCompatibilityIssues, Component, ComponentsDir, NuxtTemplate, NuxtMiddleware, NuxtHooks, NuxtPlugin, NuxtPluginTemplate, ResolvedNuxtTemplate, NuxtServerTemplate, NuxtTypeTemplate } from '@nuxt/schema';
 import { LoadConfigOptions } from 'c12';
 import { Import } from 'unimport';
-import { Configuration, WebpackPluginInstance } from 'webpack';
+import { WebpackPluginInstance, Configuration } from 'webpack';
 import { RspackPluginInstance } from '@rspack/core';
-import { UserConfig, Plugin } from 'vite';
+import { Plugin, UserConfig } from 'vite';
 import * as unctx from 'unctx';
 import { NitroRouteConfig, NitroEventHandler, NitroDevEventHandler, Nitro } from 'nitropack';
 import * as consola from 'consola';
@@ -201,8 +201,13 @@ type AddComponentOptions = {
  */
 declare function addComponent(opts: AddComponentOptions): void;
 
-/** Direct access to the Nuxt context - see https://github.com/unjs/unctx. */
+/**
+ * Direct access to the Nuxt global context - see https://github.com/unjs/unctx.
+ * @deprecated Use `getNuxtCtx` instead
+ */
 declare const nuxtCtx: unctx.UseContext<Nuxt>;
+/** Direct access to the Nuxt context with asyncLocalStorage - see https://github.com/unjs/unctx. */
+declare const getNuxtCtx: () => Nuxt | null;
 /**
  * Get access to Nuxt instance.
  *
@@ -226,6 +231,7 @@ declare function useNuxt(): Nuxt;
  * ```
  */
 declare function tryUseNuxt(): Nuxt | null;
+declare function runWithNuxtContext<T extends (...args: any[]) => any>(nuxt: Nuxt, fn: T): ReturnType<T>;
 
 declare function createIsIgnored(nuxt?: _nuxt_schema.Nuxt | null): (pathname: string, stats?: unknown) => boolean;
 /**
@@ -395,8 +401,15 @@ declare function addServerTemplate(template: NuxtServerTemplate): NuxtServerTemp
 /**
  * Renders given types during build to disk in the project `buildDir`
  * and register them as types.
+ *
+ * You can pass a second context object to specify in which context the type should be added.
+ *
+ * If no context object is passed, then it will only be added to the nuxt context.
  */
-declare function addTypeTemplate<T>(_template: NuxtTypeTemplate<T>): ResolvedNuxtTemplate<T>;
+declare function addTypeTemplate<T>(_template: NuxtTypeTemplate<T>, context?: {
+    nitro?: boolean;
+    nuxt?: boolean;
+}): ResolvedNuxtTemplate<T>;
 /**
  * Normalize a nuxt template object
  */
@@ -415,15 +428,20 @@ declare const logger: consola.ConsolaInstance;
 declare function useLogger(tag?: string, options?: Partial<ConsolaOptions>): consola.ConsolaInstance;
 
 interface ResolveModuleOptions {
+    /** @deprecated use `url` with URLs pointing at a file - never a directory */
     paths?: string | string[];
+    url?: URL | URL[];
 }
+declare function directoryToURL(dir: string): URL;
 /**
  * Resolve a module from a given root path using an algorithm patterned on
  * the upcoming `import.meta.resolve`. It returns a file URL
  *
  * @internal
  */
-declare function tryResolveModule(id: string, url?: string | string[]): Promise<string | undefined>;
+declare function tryResolveModule(id: string, url: URL | URL[]): Promise<string | undefined>;
+/** @deprecated pass URLs pointing at files */
+declare function tryResolveModule(id: string, url: string | string[]): Promise<string | undefined>;
 declare function resolveModule(id: string, options?: ResolveModuleOptions): string;
 interface ImportModuleOptions extends ResolveModuleOptions {
     /** Automatically de-default the result of requiring the module. */
@@ -451,4 +469,4 @@ declare const templateUtils: {
     }) => string;
 };
 
-export { type AddComponentOptions, type AddPluginOptions, type AddRouteMiddlewareOptions, type ExtendConfigOptions, type ExtendRouteRulesOptions, type ExtendViteConfigOptions, type ExtendWebpackConfigOptions, type ImportModuleOptions, type LoadNuxtConfigOptions, type LoadNuxtOptions, type ResolveModuleOptions, type ResolvePathOptions, type Resolver, addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createIsIgnored, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveNuxtModule, resolvePath, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
+export { type AddComponentOptions, type AddPluginOptions, type AddRouteMiddlewareOptions, type ExtendConfigOptions, type ExtendRouteRulesOptions, type ExtendViteConfigOptions, type ExtendWebpackConfigOptions, type ImportModuleOptions, type LoadNuxtConfigOptions, type LoadNuxtOptions, type ResolveModuleOptions, type ResolvePathOptions, type Resolver, addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveNuxtModule, resolvePath, runWithNuxtContext, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { ModuleOptions, ModuleDefinition, NuxtModule, NuxtConfig, Nuxt, ModuleMeta, NuxtOptions, SchemaDefinition, ImportPresetWithDeprecation, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtTemplate, NuxtHooks, NuxtMiddleware, NuxtPlugin, NuxtPluginTemplate, ResolvedNuxtTemplate, NuxtServerTemplate, NuxtTypeTemplate } from '@nuxt/schema';
+import { ModuleOptions, ModuleDefinition, NuxtModule, NuxtConfig, Nuxt, ModuleMeta, NuxtOptions, SchemaDefinition, ImportPresetWithDeprecation, NuxtCompatibility, NuxtCompatibilityIssues, Component, ComponentsDir, NuxtTemplate, NuxtMiddleware, NuxtHooks, NuxtPlugin, NuxtPluginTemplate, ResolvedNuxtTemplate, NuxtServerTemplate, NuxtTypeTemplate } from '@nuxt/schema';
 import { LoadConfigOptions } from 'c12';
 import { Import } from 'unimport';
-import { Configuration, WebpackPluginInstance } from 'webpack';
+import { WebpackPluginInstance, Configuration } from 'webpack';
 import { RspackPluginInstance } from '@rspack/core';
-import { UserConfig, Plugin } from 'vite';
+import { Plugin, UserConfig } from 'vite';
 import * as unctx from 'unctx';
 import { NitroRouteConfig, NitroEventHandler, NitroDevEventHandler, Nitro } from 'nitropack';
 import * as consola from 'consola';
@@ -201,8 +201,13 @@ type AddComponentOptions = {
  */
 declare function addComponent(opts: AddComponentOptions): void;
 
-/** Direct access to the Nuxt context - see https://github.com/unjs/unctx. */
+/**
+ * Direct access to the Nuxt global context - see https://github.com/unjs/unctx.
+ * @deprecated Use `getNuxtCtx` instead
+ */
 declare const nuxtCtx: unctx.UseContext<Nuxt>;
+/** Direct access to the Nuxt context with asyncLocalStorage - see https://github.com/unjs/unctx. */
+declare const getNuxtCtx: () => Nuxt | null;
 /**
  * Get access to Nuxt instance.
  *
@@ -226,6 +231,7 @@ declare function useNuxt(): Nuxt;
  * ```
  */
 declare function tryUseNuxt(): Nuxt | null;
+declare function runWithNuxtContext<T extends (...args: any[]) => any>(nuxt: Nuxt, fn: T): ReturnType<T>;
 
 declare function createIsIgnored(nuxt?: _nuxt_schema.Nuxt | null): (pathname: string, stats?: unknown) => boolean;
 /**
@@ -395,8 +401,15 @@ declare function addServerTemplate(template: NuxtServerTemplate): NuxtServerTemp
 /**
  * Renders given types during build to disk in the project `buildDir`
  * and register them as types.
+ *
+ * You can pass a second context object to specify in which context the type should be added.
+ *
+ * If no context object is passed, then it will only be added to the nuxt context.
  */
-declare function addTypeTemplate<T>(_template: NuxtTypeTemplate<T>): ResolvedNuxtTemplate<T>;
+declare function addTypeTemplate<T>(_template: NuxtTypeTemplate<T>, context?: {
+    nitro?: boolean;
+    nuxt?: boolean;
+}): ResolvedNuxtTemplate<T>;
 /**
  * Normalize a nuxt template object
  */
@@ -415,15 +428,20 @@ declare const logger: consola.ConsolaInstance;
 declare function useLogger(tag?: string, options?: Partial<ConsolaOptions>): consola.ConsolaInstance;
 
 interface ResolveModuleOptions {
+    /** @deprecated use `url` with URLs pointing at a file - never a directory */
     paths?: string | string[];
+    url?: URL | URL[];
 }
+declare function directoryToURL(dir: string): URL;
 /**
  * Resolve a module from a given root path using an algorithm patterned on
  * the upcoming `import.meta.resolve`. It returns a file URL
  *
  * @internal
  */
-declare function tryResolveModule(id: string, url?: string | string[]): Promise<string | undefined>;
+declare function tryResolveModule(id: string, url: URL | URL[]): Promise<string | undefined>;
+/** @deprecated pass URLs pointing at files */
+declare function tryResolveModule(id: string, url: string | string[]): Promise<string | undefined>;
 declare function resolveModule(id: string, options?: ResolveModuleOptions): string;
 interface ImportModuleOptions extends ResolveModuleOptions {
     /** Automatically de-default the result of requiring the module. */
@@ -451,4 +469,4 @@ declare const templateUtils: {
     }) => string;
 };
 
-export { type AddComponentOptions, type AddPluginOptions, type AddRouteMiddlewareOptions, type ExtendConfigOptions, type ExtendRouteRulesOptions, type ExtendViteConfigOptions, type ExtendWebpackConfigOptions, type ImportModuleOptions, type LoadNuxtConfigOptions, type LoadNuxtOptions, type ResolveModuleOptions, type ResolvePathOptions, type Resolver, addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createIsIgnored, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveNuxtModule, resolvePath, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
+export { type AddComponentOptions, type AddPluginOptions, type AddRouteMiddlewareOptions, type ExtendConfigOptions, type ExtendRouteRulesOptions, type ExtendViteConfigOptions, type ExtendWebpackConfigOptions, type ImportModuleOptions, type LoadNuxtConfigOptions, type LoadNuxtOptions, type ResolveModuleOptions, type ResolvePathOptions, type Resolver, addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveNuxtModule, resolvePath, runWithNuxtContext, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };

package/dist/index.mjs

@@ -4,27 +4,28 @@ import defu$1, { defu } from 'defu';
 import { applyDefaults } from 'untyped';
 import { dirname, relative, join, resolve, normalize, isAbsolute, basename, parse } from 'pathe';
 import { consola } from 'consola';
-import { getContext } from 'unctx';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { getContext, createContext } from 'unctx';
 import satisfies from 'semver/functions/satisfies.js';
-import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
+import { readPackageJSON } from 'pkg-types';
 import { genSafeVariableName, genDynamicImport, genImport } from 'knitwork';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { pathToFileURL, fileURLToPath } from 'node:url';
 import { createJiti } from 'jiti';
-import { resolvePath as resolvePath$1, parseNodeModulePath, resolve as resolve$1, resolvePathSync, interopDefault } from 'mlly';
+import { interopDefault, parseNodeModulePath } from 'mlly';
+import { resolveModulePath, resolveModuleURL } from 'exsolve';
 import { isRelative, withTrailingSlash } from 'ufo';
 import { globby } from 'globby';
 import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
 import ignore from 'ignore';
 import { loadConfig } from 'c12';
-import { NuxtConfigSchema } from '@nuxt/schema';
 import process$1 from 'node:process';
 import destr from 'destr';
-import { snakeCase, kebabCase, pascalCase } from 'scule';
+import { snakeCase, pascalCase, kebabCase } from 'scule';
 import { klona } from 'klona';
 import { hash } from 'ohash';
 import { gte } from 'semver';
+import { captureStackTrace } from 'errx';
 import { isAbsolute as isAbsolute$1 } from 'node:path';
-import { isWindows } from 'std-env';
 
 const logger = consola;
 function useLogger(tag, options = {}) {
@@ -32,15 +33,23 @@ function useLogger(tag, options = {}) {
 }
 
 const nuxtCtx = getContext("nuxt");
+const asyncNuxtStorage = createContext({
+  asyncContext: true,
+  AsyncLocalStorage
+});
+const getNuxtCtx = () => asyncNuxtStorage.tryUse();
 function useNuxt() {
-  const instance = nuxtCtx.tryUse();
+  const instance = asyncNuxtStorage.tryUse() || nuxtCtx.tryUse();
   if (!instance) {
     throw new Error("Nuxt instance is unavailable!");
   }
   return instance;
 }
 function tryUseNuxt() {
-  return nuxtCtx.tryUse();
+  return asyncNuxtStorage.tryUse() || nuxtCtx.tryUse();
+}
+function runWithNuxtContext(nuxt, fn) {
+  return asyncNuxtStorage.call(nuxt, fn);
 }
 
 const SEMANTIC_VERSION_RE = /-\d+\.[0-9a-f]+/;
@@ -92,12 +101,17 @@ async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
           message: `Not compatible with \`${nuxt.options.builder}\`.`
         });
       } else {
-        const builderVersion = await readPackageJSON(nuxt.options.builder, { url: nuxt.options.modulesDir }).then((r) => r.version).catch(() => undefined);
-        if (builderVersion && !satisfies(normalizeSemanticVersion(builderVersion), constraint, { includePrerelease: true })) {
-          issues.push({
-            name: "builder",
-            message: `Not compatible with \`${builderVersion}\` of \`${currentBuilder}\`. This module requires \`${constraint}\`.`
-          });
+        for (const parent of [nuxt.options.rootDir, nuxt.options.workspaceDir, import.meta.url]) {
+          const builderVersion = await readPackageJSON(nuxt.options.builder, { parent }).then((r) => r.version).catch(() => void 0);
+          if (builderVersion) {
+            if (!satisfies(normalizeSemanticVersion(builderVersion), constraint, { includePrerelease: true })) {
+              issues.push({
+                name: "builder",
+                message: `Not compatible with \`${builderVersion}\` of \`${currentBuilder}\`. This module requires \`${constraint}\`.`
+              });
+            }
+            break;
+          }
         }
       }
     }
@@ -2067,6 +2081,7 @@ function filterInPlace(array, predicate) {
   return array;
 }
 const MODE_RE = /\.(server|client)(\.\w+)*$/;
+const distDirURL = new URL(".", import.meta.url);
 
 async function compileTemplate(template$1, ctx) {
   const data = { ...ctx, options: template$1.options };
@@ -2122,9 +2137,7 @@ function _defineNuxtModule(definition) {
     return Promise.resolve(options);
   }
   async function normalizedModule(inlineOptions, nuxt) {
-    if (!nuxt) {
-      nuxt = tryUseNuxt() || this.nuxt;
-    }
+    nuxt ||= tryUseNuxt() || this.nuxt;
     const uniqueKey = module.meta.name || module.meta.configKey;
     if (uniqueKey) {
       nuxt.options._requiredModules ||= {};
@@ -2152,7 +2165,7 @@ ${issues.toString()}`);
     const setupTime = Math.round(perf * 100) / 100;
     if (setupTime > 5e3 && uniqueKey !== "@nuxt/telemetry") {
       logger.warn(`Slow module \`${uniqueKey || "<no name>"}\` took \`${setupTime}ms\` to setup.`);
-    } else if (nuxt.options.debug) {
+    } else if (nuxt.options.debug && nuxt.options.debug.modules) {
       logger.info(`Module \`${uniqueKey || "<no name>"}\` took \`${setupTime}ms\` to setup.`);
     }
     if (res === false) {
@@ -2209,6 +2222,51 @@ function nuxt2Shims(nuxt) {
   });
 }
 
+function directoryToURL(dir) {
+  return pathToFileURL(dir + "/");
+}
+function tryResolveModule(id, url = import.meta.url) {
+  return Promise.resolve(resolveModulePath(id, {
+    from: url,
+    suffixes: ["", "index"],
+    try: true
+  }));
+}
+function resolveModule(id, options) {
+  return resolveModulePath(id, {
+    from: options?.url ?? options?.paths ?? [import.meta.url],
+    extensions: [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]
+  });
+}
+async function importModule(id, opts) {
+  const resolvedPath = resolveModule(id, opts);
+  return await import(pathToFileURL(resolvedPath).href).then((r) => opts?.interopDefault !== false ? interopDefault(r) : r);
+}
+function tryImportModule(id, opts) {
+  try {
+    return importModule(id, opts).catch(() => void 0);
+  } catch {
+  }
+}
+const warnings = /* @__PURE__ */ new Set();
+function requireModule(id, opts) {
+  if (!warnings.has(id)) {
+    console.warn("[@nuxt/kit] `requireModule` is deprecated. Please use `importModule` instead.");
+    warnings.add(id);
+  }
+  const resolvedPath = resolveModule(id, opts);
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: opts?.interopDefault !== false
+  });
+  return jiti(pathToFileURL(resolvedPath).href);
+}
+function tryRequireModule(id, opts) {
+  try {
+    return requireModule(id, opts);
+  } catch {
+  }
+}
+
 function createIsIgnored(nuxt = tryUseNuxt()) {
   return (pathname, stats) => isIgnored(pathname, stats, nuxt);
 }
@@ -2286,9 +2344,7 @@ async function findPath(paths, opts, pathType = "file") {
   return null;
 }
 function resolveAlias(path, alias) {
-  if (!alias) {
-    alias = tryUseNuxt()?.options.alias || {};
-  }
+  alias ||= tryUseNuxt()?.options.alias || {};
   return resolveAlias$1(path, alias);
 }
 function createResolver(base) {
@@ -2355,7 +2411,7 @@ async function _resolvePathGranularly(path, opts = {}) {
   const cwd = opts.cwd || (nuxt ? nuxt.options.rootDir : process.cwd());
   const extensions = opts.extensions || (nuxt ? nuxt.options.extensions : [".ts", ".mjs", ".cjs", ".json"]);
   const modulesDir = nuxt ? nuxt.options.modulesDir : [];
-  path = resolveAlias(path);
+  path = resolveAlias$1(path, opts.alias ?? nuxt?.options.alias ?? {});
   if (!isAbsolute(path)) {
     path = resolve(cwd, path);
   }
@@ -2378,7 +2434,11 @@ async function _resolvePathGranularly(path, opts = {}) {
       return indexPath;
     }
   }
-  const resolvedModulePath = await resolvePath$1(_path, { url: [cwd, ...modulesDir] }).catch(() => null);
+  const resolvedModulePath = resolveModulePath(_path, {
+    try: true,
+    suffixes: ["", "index"],
+    from: [cwd, ...modulesDir].map((d) => directoryToURL(d))
+  });
   if (resolvedModulePath) {
     return {
       path: resolvedModulePath,
@@ -2425,7 +2485,7 @@ async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
       localLayerModuleDirs.push(resolve(srcDir, l.config?.dir?.modules || "modules").replace(/\/?$/, "/"));
     }
   }
-  const res = (isNuxt2() ? await nuxtModule.call(nuxt.moduleContainer, inlineOptions, nuxt) : await nuxtModule(inlineOptions, nuxt)) ?? {};
+  const res = (isNuxt2() ? await nuxtModule.call(nuxt.moduleContainer, inlineOptions, nuxt) : nuxt.options.experimental?.debugModuleMutation && nuxt._asyncLocalStorageModule ? await nuxt._asyncLocalStorageModule.run(nuxtModule, () => nuxtModule(inlineOptions || {}, nuxt)) : await nuxtModule(inlineOptions || {}, nuxt)) ?? {};
   if (res === false) {
     return;
   }
@@ -2440,12 +2500,13 @@ async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
     }
   }
   nuxt.options._installedModules ||= [];
-  const entryPath = typeof moduleToInstall === "string" ? resolveAlias(moduleToInstall) : undefined;
+  const entryPath = typeof moduleToInstall === "string" ? resolveAlias(moduleToInstall) : void 0;
   if (typeof moduleToInstall === "string" && entryPath !== moduleToInstall) {
     buildTimeModuleMeta.rawPath = moduleToInstall;
   }
   nuxt.options._installedModules.push({
     meta: defu(await nuxtModule.getMeta?.(), buildTimeModuleMeta),
+    module: nuxtModule,
     timings: res.timings,
     entryPath
   });
@@ -2460,46 +2521,52 @@ function getDirectory(p) {
 const normalizeModuleTranspilePath = (p) => {
   return getDirectory(p).split("node_modules/").pop();
 };
+const MissingModuleMatcher = /Cannot find module\s+['"]?([^'")\s]+)['"]?/i;
 async function loadNuxtModuleInstance(nuxtModule, nuxt = useNuxt()) {
   let buildTimeModuleMeta = {};
-  let resolvedModulePath;
+  if (typeof nuxtModule === "function") {
+    return {
+      nuxtModule,
+      buildTimeModuleMeta
+    };
+  }
+  if (typeof nuxtModule !== "string") {
+    throw new TypeError(`Nuxt module should be a function or a string to import. Received: ${nuxtModule}.`);
+  }
   const jiti = createJiti(nuxt.options.rootDir, { alias: nuxt.options.alias });
-  if (typeof nuxtModule === "string") {
-    const paths = /* @__PURE__ */ new Set();
-    nuxtModule = resolveAlias(nuxtModule, nuxt.options.alias);
-    if (isRelative(nuxtModule)) {
-      nuxtModule = resolve(nuxt.options.rootDir, nuxtModule);
-    }
-    paths.add(join(nuxtModule, "nuxt"));
-    paths.add(join(nuxtModule, "module"));
-    paths.add(nuxtModule);
-    for (const path of paths) {
-      try {
-        const src = isAbsolute(path) ? pathToFileURL(await resolvePath(path, { fallbackToOriginal: false, extensions: nuxt.options.extensions })).href : await resolve$1(path, { url: nuxt.options.modulesDir.map((m) => pathToFileURL(m.replace(/\/node_modules\/?$/, ""))), extensions: nuxt.options.extensions });
-        nuxtModule = await jiti.import(src, { default: true });
-        resolvedModulePath = fileURLToPath(new URL(src));
-        const moduleMetadataPath = new URL("module.json", src);
-        if (existsSync(moduleMetadataPath)) {
-          buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
-        }
-        break;
-      } catch (error) {
-        const code = error.code;
-        if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
-          continue;
-        }
-        logger.error(`Error while importing module \`${nuxtModule}\`: ${error}`);
-        throw error;
+  nuxtModule = resolveAlias(nuxtModule, nuxt.options.alias);
+  if (isRelative(nuxtModule)) {
+    nuxtModule = resolve(nuxt.options.rootDir, nuxtModule);
+  }
+  try {
+    const src = resolveModuleURL(nuxtModule, {
+      from: nuxt.options.modulesDir.map((m) => directoryToURL(m.replace(/\/node_modules\/?$/, "/"))),
+      suffixes: ["nuxt", "nuxt/index", "module", "module/index", "", "index"],
+      extensions: [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]
+    });
+    const resolvedModulePath = fileURLToPath(src);
+    const resolvedNuxtModule = await jiti.import(src, { default: true });
+    if (typeof resolvedNuxtModule !== "function") {
+      throw new TypeError(`Nuxt module should be a function: ${nuxtModule}.`);
+    }
+    const moduleMetadataPath = new URL("module.json", src);
+    if (existsSync(moduleMetadataPath)) {
+      buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
+    }
+    return { nuxtModule: resolvedNuxtModule, buildTimeModuleMeta, resolvedModulePath };
+  } catch (error) {
+    const code = error.code;
+    if (code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
+      throw new TypeError(`Could not load \`${nuxtModule}\`. Is it installed?`);
+    }
+    if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+      const module = MissingModuleMatcher.exec(error.message)?.[1];
+      if (module && !module.includes(nuxtModule)) {
+        throw new TypeError(`Error while importing module \`${nuxtModule}\`: ${error}`);
       }
     }
   }
-  if (typeof nuxtModule === "string") {
-    throw new TypeError(`Could not load \`${nuxtModule}\`. Is it installed?`);
-  }
-  if (typeof nuxtModule !== "function") {
-    throw new TypeError("Nuxt module should be a function: " + nuxtModule);
-  }
-  return { nuxtModule, buildTimeModuleMeta, resolvedModulePath };
+  throw new TypeError(`Could not load \`${nuxtModule}\`. Is it installed?`);
 }
 
 function resolveNuxtModuleEntryName(m) {
@@ -2544,22 +2611,11 @@ async function getNuxtModuleVersion(module, nuxt = useNuxt()) {
   return false;
 }
 
-const layerSchemaKeys = ["future", "srcDir", "rootDir", "serverDir", "dir"];
-const layerSchema = /* @__PURE__ */ Object.create(null);
-for (const key of layerSchemaKeys) {
-  if (key in NuxtConfigSchema) {
-    layerSchema[key] = NuxtConfigSchema[key];
-  }
-}
 async function loadNuxtConfig(opts) {
-  opts.overrides = defu$1(opts.overrides, {
-    _extends: await globby("layers/*", {
-      onlyDirectories: true,
-      cwd: opts.cwd || process.cwd()
-    })
-  });
+  const localLayers = await globby("layers/*", { onlyDirectories: true, cwd: opts.cwd || process.cwd() });
+  opts.overrides = defu$1(opts.overrides, { _extends: localLayers });
   globalThis.defineNuxtConfig = (c) => c;
-  const result = await loadConfig({
+  const { configFile, layers = [], cwd, config: nuxtConfig, meta } = await loadConfig({
     name: "nuxt",
     configFile: "nuxt.config",
     rcFile: ".nuxtrc",
@@ -2569,20 +2625,31 @@ async function loadNuxtConfig(opts) {
     ...opts
   });
   delete globalThis.defineNuxtConfig;
-  const { configFile, layers = [], cwd } = result;
-  const nuxtConfig = result.config;
-  nuxtConfig.rootDir = nuxtConfig.rootDir || cwd;
+  nuxtConfig.rootDir ||= cwd;
   nuxtConfig._nuxtConfigFile = configFile;
   nuxtConfig._nuxtConfigFiles = [configFile];
+  nuxtConfig.alias ||= {};
+  if (meta?.name) {
+    const alias = `#layers/${meta.name}`;
+    nuxtConfig.alias[alias] ||= nuxtConfig.rootDir;
+  }
   const defaultBuildDir = join(nuxtConfig.rootDir, ".nuxt");
   if (!opts.overrides?._prepare && !nuxtConfig.dev && !nuxtConfig.buildDir && nuxtConfig.future?.compatibilityVersion === 4 && existsSync(defaultBuildDir)) {
     nuxtConfig.buildDir = join(nuxtConfig.rootDir, "node_modules/.cache/nuxt/.nuxt");
   }
+  const NuxtConfigSchema = await loadNuxtSchema(nuxtConfig.rootDir || cwd || process.cwd());
+  const layerSchemaKeys = ["future", "srcDir", "rootDir", "serverDir", "dir"];
+  const layerSchema = /* @__PURE__ */ Object.create(null);
+  for (const key of layerSchemaKeys) {
+    if (key in NuxtConfigSchema) {
+      layerSchema[key] = NuxtConfigSchema[key];
+    }
+  }
   const _layers = [];
   const processedLayers = /* @__PURE__ */ new Set();
   for (const layer of layers) {
     layer.config ||= {};
-    layer.config.rootDir = layer.config.rootDir ?? layer.cwd;
+    layer.config.rootDir ??= layer.cwd;
     if (processedLayers.has(layer.config.rootDir)) {
       continue;
     }
@@ -2591,6 +2658,14 @@ async function loadNuxtConfig(opts) {
     if (!layer.configFile || layer.configFile.endsWith(".nuxtrc")) {
       continue;
     }
+    if (layer.cwd && cwd && localLayers.includes(relative(cwd, layer.cwd))) {
+      layer.meta ||= {};
+      layer.meta.name ||= basename(layer.cwd);
+    }
+    if (layer.meta?.name) {
+      const alias = `#layers/${layer.meta.name}`;
+      nuxtConfig.alias[alias] ||= layer.config.rootDir || layer.cwd;
+    }
     _layers.push(layer);
   }
   nuxtConfig._layers = _layers;
@@ -2605,6 +2680,16 @@ async function loadNuxtConfig(opts) {
   }
   return await applyDefaults(NuxtConfigSchema, nuxtConfig);
 }
+async function loadNuxtSchema(cwd) {
+  const url = directoryToURL(cwd);
+  const urls = [url];
+  const nuxtPath = resolveModuleURL("nuxt", { try: true, from: url }) ?? resolveModuleURL("nuxt-nightly", { try: true, from: url });
+  if (nuxtPath) {
+    urls.unshift(pathToFileURL(nuxtPath));
+  }
+  const schemaPath = resolveModuleURL("@nuxt/schema", { try: true, from: urls }) ?? "@nuxt/schema";
+  return await import(schemaPath).then((r) => r.NuxtConfigSchema);
+}
 
 function extendNuxtSchema(def) {
   const nuxt = useNuxt();
@@ -2613,61 +2698,23 @@ function extendNuxtSchema(def) {
   });
 }
 
-async function tryResolveModule(id, url = import.meta.url) {
-  try {
-    return await resolvePath$1(id, { url });
-  } catch {
-  }
-}
-function resolveModule(id, options) {
-  return resolvePathSync(id, { url: options?.paths ?? [import.meta.url] });
-}
-async function importModule(id, opts) {
-  const resolvedPath = await resolveModule(id, opts);
-  return import(pathToFileURL(resolvedPath).href).then((r) => opts?.interopDefault !== false ? interopDefault(r) : r);
-}
-function tryImportModule(id, opts) {
-  try {
-    return importModule(id, opts).catch(() => void 0);
-  } catch {
-  }
-}
-const warnings = /* @__PURE__ */ new Set();
-function requireModule(id, opts) {
-  if (!warnings.has(id)) {
-    console.warn("[@nuxt/kit] `requireModule` is deprecated. Please use `importModule` instead.");
-    warnings.add(id);
-  }
-  const resolvedPath = resolveModule(id, opts);
-  const jiti = createJiti(import.meta.url, {
-    interopDefault: opts?.interopDefault !== false
-  });
-  return jiti(pathToFileURL(resolvedPath).href);
-}
-function tryRequireModule(id, opts) {
-  try {
-    return requireModule(id, opts);
-  } catch {
-  }
-}
-
 async function loadNuxt(opts) {
-  opts.cwd = opts.cwd || opts.rootDir;
+  opts.cwd ||= opts.rootDir;
   opts.overrides ||= opts.config || {};
   opts.overrides.dev = !!opts.dev;
-  const nearestNuxtPkg = await Promise.all(["nuxt-nightly", "nuxt3", "nuxt", "nuxt-edge"].map((pkg2) => resolvePackageJSON(pkg2, { url: opts.cwd }).catch(() => null))).then((r) => r.filter(Boolean).sort((a, b) => b.length - a.length)[0]);
-  if (!nearestNuxtPkg) {
+  const resolvedPath = ["nuxt-nightly", "nuxt3", "nuxt", "nuxt-edge"].map((pkg2) => resolveModulePath(pkg2, { try: true, from: [directoryToURL(opts.cwd)] })).filter((p) => !!p).sort((a, b) => b.length - a.length)[0];
+  if (!resolvedPath) {
     throw new Error(`Cannot find any nuxt version from ${opts.cwd}`);
   }
-  const pkg = await readPackageJSON(nearestNuxtPkg);
+  const pkg = await readPackageJSON(resolvedPath);
   const majorVersion = pkg.version ? Number.parseInt(pkg.version.split(".")[0]) : "";
-  const rootDir = pathToFileURL(opts.cwd || process.cwd()).href;
   if (majorVersion && majorVersion >= 3) {
-    const { loadNuxt: loadNuxt3 } = await importModule(pkg._name || pkg.name, { paths: rootDir });
+    const { loadNuxt: loadNuxt3 } = await import(pathToFileURL(resolvedPath).href).then((r) => interopDefault(r));
     const nuxt2 = await loadNuxt3(opts);
     return nuxt2;
   }
-  const { loadNuxt: loadNuxt2 } = await tryImportModule("nuxt-edge", { paths: rootDir }) || await importModule("nuxt", { paths: rootDir });
+  const rootURL = directoryToURL(opts.cwd);
+  const { loadNuxt: loadNuxt2 } = await tryImportModule("nuxt-edge", { url: rootURL }) || await importModule("nuxt", { url: rootURL });
   const nuxt = await loadNuxt2({
     rootDir: opts.cwd,
     for: opts.dev ? "dev" : "build",
@@ -2689,13 +2736,13 @@ async function loadNuxt(opts) {
   return nuxt;
 }
 async function buildNuxt(nuxt) {
-  const rootDir = pathToFileURL(nuxt.options.rootDir).href;
+  const rootURL = directoryToURL(nuxt.options.rootDir);
   if (nuxt.options._majorVersion === 3) {
-    const { build: build2 } = await tryImportModule("nuxt-nightly", { paths: rootDir }) || await tryImportModule("nuxt3", { paths: rootDir }) || await importModule("nuxt", { paths: rootDir });
-    return build2(nuxt);
+    const { build: build2 } = await tryImportModule("nuxt-nightly", { url: rootURL }) || await tryImportModule("nuxt3", { url: rootURL }) || await importModule("nuxt", { url: rootURL });
+    return runWithNuxtContext(nuxt, () => build2(nuxt));
   }
-  const { build } = await tryImportModule("nuxt-edge", { paths: rootDir }) || await importModule("nuxt", { paths: rootDir });
-  return build(nuxt);
+  const { build } = await tryImportModule("nuxt-edge", { url: rootURL }) || await importModule("nuxt", { url: rootURL });
+  return runWithNuxtContext(nuxt, () => build(nuxt));
 }
 
 function addImports(imports) {
@@ -2723,7 +2770,7 @@ function addImportsSources(presets) {
 
 const HANDLER_METHOD_RE = /\.(get|head|patch|post|put|delete|connect|options|trace)(\.\w+)*$/;
 function normalizeHandlerMethod(handler) {
-  const [, method = undefined] = handler.handler.match(HANDLER_METHOD_RE) || [];
+  const [, method = void 0] = handler.handler.match(HANDLER_METHOD_RE) || [];
   return {
     method,
     ...handler,
@@ -2820,7 +2867,7 @@ function applyEnv(obj, opts, parentKey = "") {
       if (_isObject(envValue)) {
         obj[key] = { ...obj[key], ...envValue };
         applyEnv(obj[key], opts, subKey);
-      } else if (envValue === undefined) {
+      } else if (envValue === void 0) {
         applyEnv(obj[key], opts, subKey);
       } else {
         obj[key] = envValue ?? obj[key];
@@ -2981,6 +3028,17 @@ function addTemplate(_template) {
   const nuxt = useNuxt();
   const template = normalizeTemplate(_template);
   filterInPlace(nuxt.options.build.templates, (p) => normalizeTemplate(p).dst !== template.dst);
+  try {
+    const distDir = distDirURL.toString();
+    const { source } = captureStackTrace().find((e) => e.source && !e.source.startsWith(distDir)) ?? {};
+    if (source) {
+      const path = normalize(fileURLToPath(source));
+      if (existsSync(path)) {
+        template._path = path;
+      }
+    }
+  } catch {
+  }
   nuxt.options.build.templates.push(template);
   return template;
 }
@@ -2990,15 +3048,22 @@ function addServerTemplate(template) {
   nuxt.options.nitro.virtual[template.filename] = template.getContents;
   return template;
 }
-function addTypeTemplate(_template) {
+function addTypeTemplate(_template, context) {
   const nuxt = useNuxt();
   const template = addTemplate(_template);
   if (!template.filename.endsWith(".d.ts")) {
     throw new Error(`Invalid type template. Filename must end with .d.ts : "${template.filename}"`);
   }
-  nuxt.hook("prepare:types", ({ references }) => {
-    references.push({ path: template.dst });
-  });
+  if (!context || context.nuxt) {
+    nuxt.hook("prepare:types", ({ references }) => {
+      references.push({ path: template.dst });
+    });
+  }
+  if (context?.nitro) {
+    nuxt.hook("nitro:prepare:types", ({ references }) => {
+      references.push({ path: template.dst });
+    });
+  }
   return template;
 }
 function normalizeTemplate(template, buildDir) {
@@ -3028,15 +3093,13 @@ function normalizeTemplate(template, buildDir) {
   if (template.filename.endsWith(".d.ts")) {
     template.write = true;
   }
-  if (!template.dst) {
-    template.dst = resolve(buildDir ?? useNuxt().options.buildDir, template.filename);
-  }
+  template.dst ||= resolve(buildDir ?? useNuxt().options.buildDir, template.filename);
   return template;
 }
 async function updateTemplates(options) {
   return await tryUseNuxt()?.hooks.callHook("builder:generateApp", options);
 }
-const EXTENSION_RE = /\b\.\w+$/g;
+const EXTENSION_RE = /\b(?:\.d\.[cm]?ts|\.\w+)$/g;
 const excludedAlias = [/^@vue\/.*$/, /^#internal\/nuxt/];
 async function _generateTypes(nuxt) {
   const rootDirWithSlash = withTrailingSlash(nuxt.options.rootDir);
@@ -3080,7 +3143,19 @@ async function _generateTypes(nuxt) {
     exclude.add(join(relative2, "dist/runtime/server"));
   }
   const isV4 = nuxt.options.future?.compatibilityVersion === 4;
-  const hasTypescriptVersionWithModulePreserve = await readPackageJSON("typescript", { url: nuxt.options.modulesDir }).then((r) => r?.version && gte(r.version, "5.4.0")).catch(() => isV4);
+  const nestedModulesDirs = [];
+  for (const dir of [...nuxt.options.modulesDir].sort()) {
+    const withSlash = withTrailingSlash(dir);
+    if (nestedModulesDirs.every((d) => !d.startsWith(withSlash))) {
+      nestedModulesDirs.push(withSlash);
+    }
+  }
+  let hasTypescriptVersionWithModulePreserve;
+  for (const parent of nestedModulesDirs) {
+    hasTypescriptVersionWithModulePreserve ??= await readPackageJSON("typescript", { parent }).then((r) => r?.version && gte(r.version, "5.4.0")).catch(() => void 0);
+  }
+  hasTypescriptVersionWithModulePreserve ??= isV4;
+  const useDecorators = Boolean(nuxt.options.experimental?.decorators);
   const tsConfig = defu(nuxt.options.typescript?.tsConfig, {
     compilerOptions: {
       /* Base options: */
@@ -3097,12 +3172,17 @@ async function _generateTypes(nuxt) {
       noUncheckedIndexedAccess: isV4,
       forceConsistentCasingInFileNames: true,
       noImplicitOverride: true,
+      /* Decorator support */
+      ...useDecorators ? {
+        experimentalDecorators: false
+      } : {},
       /* If NOT transpiling with TypeScript: */
       module: hasTypescriptVersionWithModulePreserve ? "preserve" : "ESNext",
       noEmit: true,
       /* If your code runs in the DOM: */
       lib: [
         "ESNext",
+        ...useDecorators ? ["esnext.decorators"] : [],
         "dom",
         "dom.iterable",
         "webworker"
@@ -3131,6 +3211,7 @@ async function _generateTypes(nuxt) {
   tsConfig.compilerOptions ||= {};
   tsConfig.compilerOptions.paths ||= {};
   tsConfig.include ||= [];
+  const importPaths = nuxt.options.modulesDir.map((d) => directoryToURL(d));
   for (const alias in aliases) {
     if (excludedAlias.some((re) => re.test(alias))) {
       continue;
@@ -3141,7 +3222,11 @@ async function _generateTypes(nuxt) {
       /* file does not exist */
     );
     if (!stats) {
-      const resolvedModule = await tryResolveModule(aliases[alias], nuxt.options.modulesDir);
+      const resolvedModule = resolveModulePath(aliases[alias], {
+        try: true,
+        from: importPaths,
+        extensions: [...nuxt.options.extensions, ".d.ts", ".d.mts", ".d.cts"]
+      });
       if (resolvedModule) {
         absolutePath = resolvedModule;
         stats = await promises.stat(resolvedModule).catch(() => null);
@@ -3167,8 +3252,14 @@ async function _generateTypes(nuxt) {
     if (typeof id !== "string") {
       return;
     }
-    const pkg = await readPackageJSON(id, { url: nuxt.options.modulesDir }).catch(() => null);
-    references.push({ types: pkg?.name || id });
+    for (const parent of nestedModulesDirs) {
+      const pkg = await readPackageJSON(id, { parent }).catch(() => null);
+      if (pkg) {
+        references.push({ types: pkg.name ?? id });
+        return;
+      }
+    }
+    references.push({ types: id });
   }));
   const declarations = [];
   await nuxt.callHook("prepare:types", { references, declarations, tsConfig });
@@ -3330,7 +3421,9 @@ function normalizePlugin(plugin) {
   plugin.src = normalize(resolveAlias(plugin.src));
   if (!existsSync(plugin.src) && isAbsolute$1(plugin.src)) {
     try {
-      plugin.src = resolvePathSync(isWindows ? pathToFileURL(plugin.src).href : plugin.src, { extensions: tryUseNuxt()?.options.extensions });
+      plugin.src = resolveModulePath(plugin.src, {
+        extensions: tryUseNuxt()?.options.extensions ?? [".js", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"]
+      });
     } catch {
     }
   }
@@ -3356,4 +3449,4 @@ function addPluginTemplate(plugin, opts = {}) {
   return addPlugin(normalizedPlugin, opts);
 }
 
-export { addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createIsIgnored, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveNuxtModule, resolvePath, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
+export { addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveNuxtModule, resolvePath, runWithNuxtContext, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/kit",
-  "version": "3.15.3",
+  "version": "3.16.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -23,38 +23,40 @@
     "dist"
   ],
   "dependencies": {
-    "c12": "^2.0.1",
+    "c12": "^3.0.2",
     "consola": "^3.4.0",
     "defu": "^6.1.4",
     "destr": "^2.0.3",
-    "globby": "^14.0.2",
+    "errx": "^0.1.0",
+    "exsolve": "^1.0.2",
+    "globby": "^14.1.0",
     "ignore": "^7.0.3",
     "jiti": "^2.4.2",
     "klona": "^2.0.6",
     "knitwork": "^1.2.0",
     "mlly": "^1.7.4",
-    "ohash": "^1.1.4",
-    "pathe": "^2.0.2",
-    "pkg-types": "^1.3.1",
+    "ohash": "^2.0.11",
+    "pathe": "^2.0.3",
+    "pkg-types": "^2.1.0",
     "scule": "^1.3.0",
-    "semver": "^7.6.3",
-    "std-env": "^3.8.0",
+    "semver": "^7.7.1",
+    "std-env": "^3.8.1",
     "ufo": "^1.5.4",
     "unctx": "^2.4.1",
-    "unimport": "^4.0.0",
-    "untyped": "^1.5.2",
-    "@nuxt/schema": "3.15.3"
+    "unimport": "^4.1.2",
+    "untyped": "^2.0.0"
   },
   "devDependencies": {
-    "@rspack/core": "1.2.2",
+    "@rspack/core": "1.2.7",
     "@types/lodash-es": "4.17.12",
     "@types/semver": "7.5.8",
     "lodash-es": "4.17.21",
-    "nitropack": "2.10.4",
+    "nitropack": "2.11.5",
     "unbuild": "latest",
-    "vite": "6.0.11",
-    "vitest": "3.0.4",
-    "webpack": "5.96.1"
+    "vite": "6.2.1",
+    "vitest": "3.0.8",
+    "webpack": "5.98.0",
+    "@nuxt/schema": "3.16.0"
   },
   "engines": {
     "node": ">=18.12.0"