@nuxt/kit 4.0.2 → 4.1.0

package/dist/index.d.mts

@@ -7,6 +7,7 @@ import { RspackPluginInstance } from '@rspack/core';
 import { Plugin, UserConfig } from 'vite';
 import * as unctx from 'unctx';
 import { NitroRouteConfig, NitroEventHandler, NitroDevEventHandler, Nitro } from 'nitropack/types';
+import { GlobOptions } from 'tinyglobby';
 import * as consola from 'consola';
 import { ConsolaOptions } from 'consola';
 
@@ -19,15 +20,29 @@ declare function defineNuxtModule<TOptions extends ModuleOptions>(): {
     with: <TOptionsDefaults extends Partial<TOptions>>(definition: ModuleDefinition<TOptions, TOptionsDefaults, true> | NuxtModule<TOptions, TOptionsDefaults, true>) => NuxtModule<TOptions, TOptionsDefaults, true>;
 };
 
-/** Installs a module on a Nuxt instance. */
+type ModuleToInstall = string | NuxtModule<ModuleOptions, Partial<ModuleOptions>, false>;
+/**
+ * Installs a set of modules on a Nuxt instance.
+ * @internal
+ */
+declare function installModules(modulesToInstall: Map<ModuleToInstall, Record<string, any>>, resolvedModulePaths: Set<string>, nuxt?: Nuxt): Promise<void>;
+/**
+ * Installs a module on a Nuxt instance.
+ * @deprecated Use module dependencies.
+ */
 declare function installModule<T extends string | NuxtModule, Config extends Extract<NonNullable<NuxtConfig['modules']>[number], [T, any]>>(moduleToInstall: T, inlineOptions?: [Config] extends [never] ? any : Config[1], nuxt?: Nuxt): Promise<void>;
-declare function getDirectory(p: string): string;
-declare const normalizeModuleTranspilePath: (p: string) => string;
+declare function resolveModuleWithOptions(definition: NuxtModule<any> | string | false | undefined | null | [(NuxtModule | string)?, Record<string, any>?], nuxt: Nuxt): {
+    resolvedPath?: string;
+    module: string | NuxtModule<any>;
+    options: Record<string, any>;
+} | undefined;
 declare function loadNuxtModuleInstance(nuxtModule: string | NuxtModule, nuxt?: Nuxt): Promise<{
     nuxtModule: NuxtModule<any>;
     buildTimeModuleMeta: ModuleMeta;
     resolvedModulePath?: string;
 }>;
+declare function getDirectory(p: string): string;
+declare const normalizeModuleTranspilePath: (p: string) => string;
 
 /**
  * Check if a Nuxt module is installed by name.
@@ -63,6 +78,41 @@ interface LoadNuxtOptions extends LoadNuxtConfigOptions {
 declare function loadNuxt(opts: LoadNuxtOptions): Promise<Nuxt>;
 declare function buildNuxt(nuxt: Nuxt): Promise<any>;
 
+interface LayerDirectories {
+    /** Nuxt rootDir (`/` by default) */
+    readonly root: string;
+    /** Nitro source directory (`/server` by default) */
+    readonly server: string;
+    /** Local modules directory (`/modules` by default) */
+    readonly modules: string;
+    /** Shared directory (`/shared` by default) */
+    readonly shared: string;
+    /** Public directory (`/public` by default) */
+    readonly public: string;
+    /** Nuxt srcDir (`/app/` by default) */
+    readonly app: string;
+    /** Layouts directory (`/app/layouts` by default) */
+    readonly appLayouts: string;
+    /** Middleware directory (`/app/middleware` by default) */
+    readonly appMiddleware: string;
+    /** Pages directory (`/app/pages` by default) */
+    readonly appPages: string;
+    /** Plugins directory (`/app/plugins` by default) */
+    readonly appPlugins: string;
+}
+/**
+ * Get the resolved directory paths for all layers in a Nuxt application.
+ *
+ * Returns an array of LayerDirectories objects, ordered by layer priority:
+ * - The first layer is the user/project layer (highest priority)
+ * - Earlier layers override later layers in the array
+ * - Base layers appear last in the array (lowest priority)
+ *
+ * @param nuxt - The Nuxt instance to get layers from. Defaults to the current Nuxt context.
+ * @returns Array of LayerDirectories objects, ordered by priority (user layer first)
+ */
+declare function getLayerDirectories(nuxt?: _nuxt_schema.Nuxt): LayerDirectories[];
+
 declare function addImports(imports: Import | Import[]): void;
 declare function addImportsDir(dirs: string | string[], opts?: {
     prepend?: boolean;
@@ -295,7 +345,12 @@ interface ResolvePathOptions {
     cwd?: string;
     /** An object of aliases. Default is Nuxt configured aliases. */
     alias?: Record<string, string>;
-    /** The file extensions to try. Default is Nuxt configured extensions. */
+    /**
+     * The file extensions to try.
+     * Default is Nuxt configured extensions.
+     *
+     * Isn't considered when `type` is set to `'dir'`.
+     */
     extensions?: string[];
     /**
      * Whether to resolve files that exist in the Nuxt VFS (for example, as a Nuxt template).
@@ -304,21 +359,26 @@ interface ResolvePathOptions {
     virtual?: boolean;
     /**
      * Whether to fallback to the original path if the resolved path does not exist instead of returning the normalized input path.
-     *
      * @default false
      */
     fallbackToOriginal?: boolean;
+    /**
+     * The type of the path to be resolved.
+     * @default 'file'
+     */
+    type?: PathType;
 }
 /**
- * Resolve full path to a file or directory respecting Nuxt alias and extensions options
+ * Resolve the full path to a file or a directory (based on the provided type), respecting Nuxt alias and extensions options.
  *
- * If path could not be resolved, normalized input path will be returned
+ * If a path cannot be resolved, normalized input will be returned unless the `fallbackToOriginal` option is set to `true`,
+ * in which case the original input path will be returned.
  */
 declare function resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
 /**
  * Try to resolve first existing file in paths
  */
-declare function findPath(paths: string | string[], opts?: ResolvePathOptions, pathType?: 'file' | 'dir'): Promise<string | null>;
+declare function findPath(paths: string | string[], opts?: ResolvePathOptions, pathType?: PathType): Promise<string | null>;
 /**
  * Resolve path aliases respecting Nuxt alias options
  */
@@ -332,8 +392,16 @@ interface Resolver {
  */
 declare function createResolver(base: string | URL): Resolver;
 declare function resolveNuxtModule(base: string, paths: string[]): Promise<string[]>;
+type PathType = 'file' | 'dir';
+/**
+ * Resolve absolute file paths in the provided directory with respect to `.nuxtignore` and return them sorted.
+ * @param path path to the directory to resolve files in
+ * @param pattern glob pattern or an array of glob patterns to match files
+ * @param opts options for globbing
+ */
 declare function resolveFiles(path: string, pattern: string | string[], opts?: {
     followSymbolicLinks?: boolean;
+    ignore?: GlobOptions['ignore'];
 }): Promise<string[]>;
 
 /**
@@ -457,5 +525,5 @@ declare function requireModule<T = unknown>(id: string, opts?: ImportModuleOptio
  */
 declare function tryRequireModule<T = unknown>(id: string, opts?: ImportModuleOptions): T | undefined;
 
-export { addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, 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, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
-export type { AddComponentOptions, AddPluginOptions, AddRouteMiddlewareOptions, ExtendConfigOptions, ExtendRouteRulesOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, ImportModuleOptions, LoadNuxtConfigOptions, LoadNuxtOptions, ResolveModuleOptions, ResolvePathOptions, Resolver };
+export { addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getLayerDirectories, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, installModules, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveModuleWithOptions, resolveNuxtModule, resolvePath, runWithNuxtContext, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
+export type { AddComponentOptions, AddPluginOptions, AddRouteMiddlewareOptions, ExtendConfigOptions, ExtendRouteRulesOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, ImportModuleOptions, LayerDirectories, LoadNuxtConfigOptions, LoadNuxtOptions, ResolveModuleOptions, ResolvePathOptions, Resolver };

package/dist/index.d.ts

@@ -7,6 +7,7 @@ import { RspackPluginInstance } from '@rspack/core';
 import { Plugin, UserConfig } from 'vite';
 import * as unctx from 'unctx';
 import { NitroRouteConfig, NitroEventHandler, NitroDevEventHandler, Nitro } from 'nitropack/types';
+import { GlobOptions } from 'tinyglobby';
 import * as consola from 'consola';
 import { ConsolaOptions } from 'consola';
 
@@ -19,15 +20,29 @@ declare function defineNuxtModule<TOptions extends ModuleOptions>(): {
     with: <TOptionsDefaults extends Partial<TOptions>>(definition: ModuleDefinition<TOptions, TOptionsDefaults, true> | NuxtModule<TOptions, TOptionsDefaults, true>) => NuxtModule<TOptions, TOptionsDefaults, true>;
 };
 
-/** Installs a module on a Nuxt instance. */
+type ModuleToInstall = string | NuxtModule<ModuleOptions, Partial<ModuleOptions>, false>;
+/**
+ * Installs a set of modules on a Nuxt instance.
+ * @internal
+ */
+declare function installModules(modulesToInstall: Map<ModuleToInstall, Record<string, any>>, resolvedModulePaths: Set<string>, nuxt?: Nuxt): Promise<void>;
+/**
+ * Installs a module on a Nuxt instance.
+ * @deprecated Use module dependencies.
+ */
 declare function installModule<T extends string | NuxtModule, Config extends Extract<NonNullable<NuxtConfig['modules']>[number], [T, any]>>(moduleToInstall: T, inlineOptions?: [Config] extends [never] ? any : Config[1], nuxt?: Nuxt): Promise<void>;
-declare function getDirectory(p: string): string;
-declare const normalizeModuleTranspilePath: (p: string) => string;
+declare function resolveModuleWithOptions(definition: NuxtModule<any> | string | false | undefined | null | [(NuxtModule | string)?, Record<string, any>?], nuxt: Nuxt): {
+    resolvedPath?: string;
+    module: string | NuxtModule<any>;
+    options: Record<string, any>;
+} | undefined;
 declare function loadNuxtModuleInstance(nuxtModule: string | NuxtModule, nuxt?: Nuxt): Promise<{
     nuxtModule: NuxtModule<any>;
     buildTimeModuleMeta: ModuleMeta;
     resolvedModulePath?: string;
 }>;
+declare function getDirectory(p: string): string;
+declare const normalizeModuleTranspilePath: (p: string) => string;
 
 /**
  * Check if a Nuxt module is installed by name.
@@ -63,6 +78,41 @@ interface LoadNuxtOptions extends LoadNuxtConfigOptions {
 declare function loadNuxt(opts: LoadNuxtOptions): Promise<Nuxt>;
 declare function buildNuxt(nuxt: Nuxt): Promise<any>;
 
+interface LayerDirectories {
+    /** Nuxt rootDir (`/` by default) */
+    readonly root: string;
+    /** Nitro source directory (`/server` by default) */
+    readonly server: string;
+    /** Local modules directory (`/modules` by default) */
+    readonly modules: string;
+    /** Shared directory (`/shared` by default) */
+    readonly shared: string;
+    /** Public directory (`/public` by default) */
+    readonly public: string;
+    /** Nuxt srcDir (`/app/` by default) */
+    readonly app: string;
+    /** Layouts directory (`/app/layouts` by default) */
+    readonly appLayouts: string;
+    /** Middleware directory (`/app/middleware` by default) */
+    readonly appMiddleware: string;
+    /** Pages directory (`/app/pages` by default) */
+    readonly appPages: string;
+    /** Plugins directory (`/app/plugins` by default) */
+    readonly appPlugins: string;
+}
+/**
+ * Get the resolved directory paths for all layers in a Nuxt application.
+ *
+ * Returns an array of LayerDirectories objects, ordered by layer priority:
+ * - The first layer is the user/project layer (highest priority)
+ * - Earlier layers override later layers in the array
+ * - Base layers appear last in the array (lowest priority)
+ *
+ * @param nuxt - The Nuxt instance to get layers from. Defaults to the current Nuxt context.
+ * @returns Array of LayerDirectories objects, ordered by priority (user layer first)
+ */
+declare function getLayerDirectories(nuxt?: _nuxt_schema.Nuxt): LayerDirectories[];
+
 declare function addImports(imports: Import | Import[]): void;
 declare function addImportsDir(dirs: string | string[], opts?: {
     prepend?: boolean;
@@ -295,7 +345,12 @@ interface ResolvePathOptions {
     cwd?: string;
     /** An object of aliases. Default is Nuxt configured aliases. */
     alias?: Record<string, string>;
-    /** The file extensions to try. Default is Nuxt configured extensions. */
+    /**
+     * The file extensions to try.
+     * Default is Nuxt configured extensions.
+     *
+     * Isn't considered when `type` is set to `'dir'`.
+     */
     extensions?: string[];
     /**
      * Whether to resolve files that exist in the Nuxt VFS (for example, as a Nuxt template).
@@ -304,21 +359,26 @@ interface ResolvePathOptions {
     virtual?: boolean;
     /**
      * Whether to fallback to the original path if the resolved path does not exist instead of returning the normalized input path.
-     *
      * @default false
      */
     fallbackToOriginal?: boolean;
+    /**
+     * The type of the path to be resolved.
+     * @default 'file'
+     */
+    type?: PathType;
 }
 /**
- * Resolve full path to a file or directory respecting Nuxt alias and extensions options
+ * Resolve the full path to a file or a directory (based on the provided type), respecting Nuxt alias and extensions options.
  *
- * If path could not be resolved, normalized input path will be returned
+ * If a path cannot be resolved, normalized input will be returned unless the `fallbackToOriginal` option is set to `true`,
+ * in which case the original input path will be returned.
  */
 declare function resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
 /**
  * Try to resolve first existing file in paths
  */
-declare function findPath(paths: string | string[], opts?: ResolvePathOptions, pathType?: 'file' | 'dir'): Promise<string | null>;
+declare function findPath(paths: string | string[], opts?: ResolvePathOptions, pathType?: PathType): Promise<string | null>;
 /**
  * Resolve path aliases respecting Nuxt alias options
  */
@@ -332,8 +392,16 @@ interface Resolver {
  */
 declare function createResolver(base: string | URL): Resolver;
 declare function resolveNuxtModule(base: string, paths: string[]): Promise<string[]>;
+type PathType = 'file' | 'dir';
+/**
+ * Resolve absolute file paths in the provided directory with respect to `.nuxtignore` and return them sorted.
+ * @param path path to the directory to resolve files in
+ * @param pattern glob pattern or an array of glob patterns to match files
+ * @param opts options for globbing
+ */
 declare function resolveFiles(path: string, pattern: string | string[], opts?: {
     followSymbolicLinks?: boolean;
+    ignore?: GlobOptions['ignore'];
 }): Promise<string[]>;
 
 /**
@@ -457,5 +525,5 @@ declare function requireModule<T = unknown>(id: string, opts?: ImportModuleOptio
  */
 declare function tryRequireModule<T = unknown>(id: string, opts?: ImportModuleOptions): T | undefined;
 
-export { addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, 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, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
-export type { AddComponentOptions, AddPluginOptions, AddRouteMiddlewareOptions, ExtendConfigOptions, ExtendRouteRulesOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, ImportModuleOptions, LoadNuxtConfigOptions, LoadNuxtOptions, ResolveModuleOptions, ResolvePathOptions, Resolver };
+export { addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getLayerDirectories, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, installModules, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveModuleWithOptions, resolveNuxtModule, resolvePath, runWithNuxtContext, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
+export type { AddComponentOptions, AddPluginOptions, AddRouteMiddlewareOptions, ExtendConfigOptions, ExtendRouteRulesOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, ImportModuleOptions, LayerDirectories, LoadNuxtConfigOptions, LoadNuxtOptions, ResolveModuleOptions, ResolvePathOptions, Resolver };

package/dist/index.mjs

@@ -8,14 +8,16 @@ import satisfies from 'semver/functions/satisfies.js';
 import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
 import { existsSync, readFileSync, promises, lstatSync } from 'node:fs';
 import { pathToFileURL, fileURLToPath } from 'node:url';
-import { relative, join, resolve, dirname, normalize, isAbsolute, basename, parse } from 'pathe';
+import { resolve, relative, join, dirname, normalize, isAbsolute, basename, parse } from 'pathe';
 import { createJiti } from 'jiti';
 import { interopDefault, parseNodeModulePath, resolveModuleExportNames } from 'mlly';
 import { resolveModulePath, resolveModuleURL } from 'exsolve';
-import { isRelative, withTrailingSlash } from 'ufo';
+import { isRelative, withTrailingSlash as withTrailingSlash$2 } from 'ufo';
+import { read, update } from 'rc9';
+import semver, { gte } from 'semver';
 import { captureStackTrace } from 'errx';
 import { glob } from 'tinyglobby';
-import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
+import { resolveAlias as resolveAlias$1, reverseResolveAlias } from 'pathe/utils';
 import ignore from 'ignore';
 import { loadConfig } from 'c12';
 import process$1 from 'node:process';
@@ -23,7 +25,6 @@ import destr from 'destr';
 import { snakeCase, pascalCase, kebabCase } from 'scule';
 import { klona } from 'klona';
 import { hash } from 'ohash';
-import { gte } from 'semver';
 import { isAbsolute as isAbsolute$1 } from 'node:path';
 
 const logger = consola;
@@ -158,6 +159,12 @@ function _defineNuxtModule(definition) {
     }
     return Promise.resolve(options);
   }
+  function getModuleDependencies(nuxt = useNuxt()) {
+    if (typeof module.moduleDependencies === "function") {
+      return module.moduleDependencies(nuxt);
+    }
+    return module.moduleDependencies;
+  }
   async function normalizedModule(inlineOptions, nuxt = tryUseNuxt()) {
     if (!nuxt) {
       throw new TypeError("Cannot use module outside of Nuxt context");
@@ -208,6 +215,9 @@ ${issues.toString()}`;
   }
   normalizedModule.getMeta = () => Promise.resolve(module.meta);
   normalizedModule.getOptions = getOptions;
+  normalizedModule.getModuleDependencies = getModuleDependencies;
+  normalizedModule.onInstall = module.onInstall;
+  normalizedModule.onUpgrade = module.onUpgrade;
   return normalizedModule;
 }
 
@@ -223,6 +233,7 @@ function tryResolveModule(id, url = import.meta.url) {
 }
 function resolveModule(id, options) {
   return resolveModulePath(id, {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     from: options?.url ?? options?.paths ?? [import.meta.url],
     extensions: [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]
   });
@@ -259,6 +270,39 @@ function tryRequireModule(id, opts) {
   }
 }
 
+const layerMap = /* @__PURE__ */ new WeakMap();
+function getLayerDirectories(nuxt = useNuxt()) {
+  return nuxt.options._layers.map((layer) => {
+    if (layerMap.has(layer)) {
+      return layerMap.get(layer);
+    }
+    const isRoot = withTrailingSlash$1(layer.config.rootDir) === withTrailingSlash$1(nuxt.options.rootDir);
+    const config = isRoot ? nuxt.options : layer.config;
+    const src = withTrailingSlash$1(config.srcDir || layer.cwd);
+    const root = withTrailingSlash$1(config.rootDir || layer.cwd);
+    const directories = {
+      root,
+      shared: withTrailingSlash$1(resolve(root, resolveAlias(config.dir?.shared || "shared", nuxt.options.alias))),
+      // these are resolved relative to root in `@nuxt/schema` for v4+
+      // so resolving relative to `src` covers backward compatibility for v3
+      server: withTrailingSlash$1(resolve(src, resolveAlias(config.serverDir || "server", nuxt.options.alias))),
+      modules: withTrailingSlash$1(resolve(src, resolveAlias(config.dir?.modules || "modules", nuxt.options.alias))),
+      public: withTrailingSlash$1(resolve(src, resolveAlias(config.dir?.public || "public", nuxt.options.alias))),
+      // nuxt app
+      app: src,
+      appLayouts: withTrailingSlash$1(resolve(src, resolveAlias(config.dir?.layouts || "layouts", nuxt.options.alias))),
+      appMiddleware: withTrailingSlash$1(resolve(src, resolveAlias(config.dir?.middleware || "middleware", nuxt.options.alias))),
+      appPages: withTrailingSlash$1(resolve(src, resolveAlias(config.dir?.pages || "pages", nuxt.options.alias))),
+      appPlugins: withTrailingSlash$1(resolve(src, resolveAlias(config.dir?.plugins || "plugins", nuxt.options.alias)))
+    };
+    layerMap.set(layer, directories);
+    return directories;
+  });
+}
+function withTrailingSlash$1(dir) {
+  return dir.replace(/[^/]$/, "$&/");
+}
+
 function createIsIgnored(nuxt = tryUseNuxt()) {
   return (pathname, stats) => isIgnored(pathname, stats, nuxt);
 }
@@ -270,8 +314,8 @@ function isIgnored(pathname, _stats, nuxt = tryUseNuxt()) {
     nuxt._ignore = ignore(nuxt.options.ignoreOptions);
     nuxt._ignore.add(resolveIgnorePatterns());
   }
-  const cwds = nuxt.options._layers?.map((layer2) => layer2.cwd).sort((a, b) => b.length - a.length);
-  const layer = cwds?.find((cwd) => pathname.startsWith(cwd));
+  const cwds = getLayerDirectories(nuxt).map((dirs) => dirs.root).sort((a, b) => b.length - a.length);
+  const layer = cwds.find((cwd) => pathname.startsWith(cwd));
   const relativePath = relative(layer ?? nuxt.options.rootDir, pathname);
   if (relativePath[0] === "." && relativePath[1] === ".") {
     return false;
@@ -331,15 +375,20 @@ const MODE_RE = /\.(server|client)(\.\w+)*$/;
 const distDirURL = new URL(".", import.meta.url);
 
 async function resolvePath(path, opts = {}) {
-  const res = await _resolvePathGranularly(path, opts);
-  if (res.type === "file") {
+  const { type = "file" } = opts;
+  const res = await _resolvePathGranularly(path, { ...opts, type });
+  if (res.type === type) {
     return res.path;
   }
   return opts.fallbackToOriginal ? path : res.path;
 }
 async function findPath(paths, opts, pathType = "file") {
   for (const path of toArray(paths)) {
-    const res = await _resolvePathGranularly(path, opts);
+    const res = await _resolvePathGranularly(path, {
+      ...opts,
+      // TODO: this is for backwards compatibility, remove the `pathType` argument in Nuxt 5
+      type: opts?.type || pathType
+    });
     if (!res.type || pathType && res.type !== pathType) {
       continue;
     }
@@ -410,12 +459,15 @@ async function _resolvePathType(path, opts = {}, skipFs = false) {
     fd?.close();
   }
 }
-async function _resolvePathGranularly(path, opts = {}) {
+function normalizeExtension(ext) {
+  return ext.startsWith(".") ? ext : `.${ext}`;
+}
+async function _resolvePathGranularly(path, opts = { type: "file" }) {
   const _path = path;
   path = normalize(path);
   if (isAbsolute(path)) {
     const res2 = await _resolvePathType(path, opts);
-    if (res2 && res2.type === "file") {
+    if (res2 && res2.type === opts.type) {
       return res2;
     }
   }
@@ -428,36 +480,39 @@ async function _resolvePathGranularly(path, opts = {}) {
     path = resolve(cwd, path);
   }
   const res = await _resolvePathType(path, opts);
-  if (res && res.type === "file") {
+  if (res && res.type === opts.type) {
     return res;
   }
-  for (const ext of extensions) {
-    const extPath = await _resolvePathType(path + ext, opts);
-    if (extPath && extPath.type === "file") {
-      return extPath;
+  if (opts.type === "file") {
+    for (const ext of extensions) {
+      const normalizedExt = normalizeExtension(ext);
+      const extPath = await _resolvePathType(path + normalizedExt, opts);
+      if (extPath && extPath.type === "file") {
+        return extPath;
+      }
+      const indexPath = await _resolvePathType(
+        join(path, "index" + normalizedExt),
+        opts,
+        res?.type !== "dir"
+        /* skip checking if parent is not a directory */
+      );
+      if (indexPath && indexPath.type === "file") {
+        return indexPath;
+      }
     }
-    const indexPath = await _resolvePathType(
-      join(path, "index" + ext),
-      opts,
-      res?.type !== "dir"
-      /* skip checking if parent is not a directory */
-    );
-    if (indexPath && indexPath.type === "file") {
-      return indexPath;
+    const resolvedModulePath = resolveModulePath(_path, {
+      try: true,
+      suffixes: ["", "index"],
+      from: [cwd, ...modulesDir].map((d) => directoryToURL(d))
+    });
+    if (resolvedModulePath) {
+      return {
+        path: resolvedModulePath,
+        type: "file",
+        virtual: false
+      };
     }
   }
-  const resolvedModulePath = resolveModulePath(_path, {
-    try: true,
-    suffixes: ["", "index"],
-    from: [cwd, ...modulesDir].map((d) => directoryToURL(d))
-  });
-  if (resolvedModulePath) {
-    return {
-      path: resolvedModulePath,
-      type: "file",
-      virtual: false
-    };
-  }
   return {
     path
   };
@@ -478,8 +533,7 @@ function existsInVFS(path, nuxt = tryUseNuxt()) {
 }
 async function resolveFiles(path, pattern, opts = {}) {
   const files = [];
-  for (const file of await glob(pattern, { cwd: path, followSymbolicLinks: opts.followSymbolicLinks ?? true })) {
-    const p = resolve(path, file);
+  for (const p of await glob(pattern, { cwd: path, followSymbolicLinks: opts.followSymbolicLinks ?? true, absolute: true, ignore: opts.ignore })) {
     if (!isIgnored(p)) {
       files.push(p);
     }
@@ -488,8 +542,7 @@ async function resolveFiles(path, pattern, opts = {}) {
 }
 
 const NODE_MODULES_RE = /[/\\]node_modules[/\\]/;
-async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
-  const { nuxtModule, buildTimeModuleMeta, resolvedModulePath } = await loadNuxtModuleInstance(moduleToInstall, nuxt);
+async function installModules(modulesToInstall, resolvedModulePaths, nuxt = useNuxt()) {
   const localLayerModuleDirs = [];
   for (const l of nuxt.options._layers) {
     const srcDir = l.config.srcDir || l.cwd;
@@ -497,43 +550,132 @@ async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
       localLayerModuleDirs.push(resolve(srcDir, l.config?.dir?.modules || "modules").replace(/\/?$/, "/"));
     }
   }
-  const res = nuxt.options.experimental?.debugModuleMutation && nuxt._asyncLocalStorageModule ? await nuxt._asyncLocalStorageModule.run(nuxtModule, () => nuxtModule(inlineOptions || {}, nuxt)) ?? {} : await nuxtModule(inlineOptions || {}, nuxt) ?? {};
-  if (res === false) {
-    return;
+  const optionsFunctions = /* @__PURE__ */ new Map();
+  const resolvedModules = [];
+  const inlineConfigKeys = new Set(
+    await Promise.all([...modulesToInstall].map(([mod]) => typeof mod !== "string" && Promise.resolve(mod.getMeta?.())?.then((r) => r?.configKey)))
+  );
+  let error;
+  const dependencyMap = /* @__PURE__ */ new Map();
+  for (const [key, options] of modulesToInstall) {
+    const res = await loadNuxtModuleInstance(key, nuxt).catch((err) => {
+      if (dependencyMap.has(key) && typeof key === "string") {
+        err.cause = `Could not resolve \`${key}\` (specified as a dependency of ${dependencyMap.get(key)}).`;
+      }
+      throw err;
+    });
+    const dependencyMeta = res.nuxtModule.getModuleDependencies?.(nuxt) || {};
+    for (const [name, value] of Object.entries(dependencyMeta)) {
+      if (!value.overrides && !value.defaults && !value.version && value.optional) {
+        continue;
+      }
+      const resolvedModule = resolveModuleWithOptions(name, nuxt);
+      const moduleToAttribute = typeof key === "string" ? `\`${key}\`` : "a module in `nuxt.options`";
+      if (!resolvedModule?.module) {
+        const message = `Could not resolve \`${name}\` (specified as a dependency of ${moduleToAttribute}).`;
+        error = new TypeError(message);
+        continue;
+      }
+      if (value.version) {
+        const resolvePaths = [res.resolvedModulePath, ...nuxt.options.modulesDir].filter(Boolean);
+        const pkg = await readPackageJSON(name, { from: resolvePaths }).catch(() => null);
+        if (pkg?.version && !semver.satisfies(pkg.version, value.version)) {
+          const message = `Module \`${name}\` version (\`${pkg.version}\`) does not satisfy \`${value.version}\` (requested by ${moduleToAttribute}).`;
+          error = new TypeError(message);
+        }
+      }
+      if (value.overrides || value.defaults) {
+        const currentFns = optionsFunctions.get(resolvedModule.module) || [];
+        optionsFunctions.set(resolvedModule.module, [
+          ...currentFns,
+          () => ({ defaults: value.defaults, overrides: value.overrides })
+        ]);
+      }
+      if (value.optional === true) {
+        continue;
+      }
+      if (resolvedModule && !modulesToInstall.has(resolvedModule.module) && (!resolvedModule.resolvedPath || !resolvedModulePaths.has(resolvedModule.resolvedPath))) {
+        if (typeof resolvedModule.module === "string" && inlineConfigKeys.has(resolvedModule.module)) {
+          continue;
+        }
+        modulesToInstall.set(resolvedModule.module, resolvedModule.options);
+        dependencyMap.set(resolvedModule.module, moduleToAttribute);
+        const path = resolvedModule.resolvedPath || resolvedModule.module;
+        if (typeof path === "string") {
+          resolvedModulePaths.add(path);
+        }
+      }
+    }
+    resolvedModules.push({
+      moduleToInstall: key,
+      meta: await res.nuxtModule.getMeta?.(),
+      nuxtModule: res.nuxtModule,
+      buildTimeModuleMeta: res.buildTimeModuleMeta,
+      resolvedModulePath: res.resolvedModulePath,
+      inlineOptions: options
+    });
   }
-  const modulePath = resolvedModulePath || moduleToInstall;
-  if (typeof modulePath === "string") {
-    const parsed = parseNodeModulePath(modulePath);
-    const moduleRoot = parsed.dir ? parsed.dir + parsed.name : await resolvePackageJSON(modulePath, { try: true }).then((r) => r ? dirname(r) : modulePath);
-    nuxt.options.build.transpile.push(normalizeModuleTranspilePath(moduleRoot));
-    const directory = moduleRoot.replace(/\/?$/, "/");
-    if (moduleRoot !== moduleToInstall && !localLayerModuleDirs.some((dir) => directory.startsWith(dir))) {
-      nuxt.options.modulesDir.push(join(moduleRoot, "node_modules"));
+  if (error) {
+    throw error;
+  }
+  for (const { nuxtModule, meta, moduleToInstall, buildTimeModuleMeta, resolvedModulePath, inlineOptions } of resolvedModules) {
+    const configKey = meta?.configKey;
+    if (configKey) {
+      const optionsFns = [
+        ...optionsFunctions.get(moduleToInstall) || [],
+        ...optionsFunctions.get(configKey) || []
+      ];
+      if (optionsFns.length > 0) {
+        const overrides = [];
+        const defaults = [];
+        for (const fn of optionsFns) {
+          const options = fn();
+          overrides.push(options.overrides);
+          defaults.push(options.defaults);
+        }
+        nuxt.options[configKey] = defu(...overrides, nuxt.options[configKey], ...defaults);
+      }
     }
+    await callLifecycleHooks(nuxtModule, meta, inlineOptions, nuxt);
+    await callModule(nuxtModule, meta, inlineOptions, resolvedModulePath, moduleToInstall, localLayerModuleDirs, buildTimeModuleMeta, nuxt);
   }
-  nuxt.options._installedModules ||= [];
-  const entryPath = typeof moduleToInstall === "string" ? resolveAlias(moduleToInstall) : void 0;
-  if (typeof moduleToInstall === "string" && entryPath !== moduleToInstall) {
-    buildTimeModuleMeta.rawPath = moduleToInstall;
+}
+async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
+  const { nuxtModule, buildTimeModuleMeta, resolvedModulePath } = await loadNuxtModuleInstance(moduleToInstall, nuxt);
+  const localLayerModuleDirs = [];
+  for (const dirs of getLayerDirectories(nuxt)) {
+    if (!NODE_MODULES_RE.test(dirs.app)) {
+      localLayerModuleDirs.push(dirs.modules);
+    }
   }
-  nuxt.options._installedModules.push({
-    meta: defu(await nuxtModule.getMeta?.(), buildTimeModuleMeta),
-    module: nuxtModule,
-    timings: res.timings,
-    entryPath
-  });
+  const meta = await nuxtModule.getMeta?.();
+  await callLifecycleHooks(nuxtModule, meta, inlineOptions, nuxt);
+  await callModule(nuxtModule, meta, inlineOptions, resolvedModulePath, moduleToInstall, localLayerModuleDirs, buildTimeModuleMeta, nuxt);
 }
-function getDirectory(p) {
-  try {
-    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
-  } catch {
+function resolveModuleWithOptions(definition, nuxt) {
+  const [module, options = {}] = Array.isArray(definition) ? definition : [definition, {}];
+  if (!module) {
+    return;
   }
-  return p;
+  if (typeof module !== "string") {
+    return {
+      module,
+      options
+    };
+  }
+  const modAlias = resolveAlias(module, nuxt.options.alias);
+  const modPath = resolveModulePath(modAlias, {
+    try: true,
+    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"]
+  });
+  return {
+    module,
+    resolvedPath: modPath || modAlias,
+    options
+  };
 }
-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 = {};
   if (typeof nuxtModule === "function") {
@@ -580,6 +722,71 @@ async function loadNuxtModuleInstance(nuxtModule, nuxt = useNuxt()) {
   }
   throw new TypeError(`Could not load \`${nuxtModule}\`. Is it installed?`);
 }
+function getDirectory(p) {
+  try {
+    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
+  } catch {
+  }
+  return p;
+}
+const normalizeModuleTranspilePath = (p) => {
+  return getDirectory(p).split("node_modules/").pop();
+};
+const MissingModuleMatcher = /Cannot find module\s+['"]?([^'")\s]+)['"]?/i;
+async function callLifecycleHooks(nuxtModule, meta = {}, inlineOptions, nuxt = useNuxt()) {
+  if (!meta.name || !meta.version) {
+    return;
+  }
+  if (!nuxtModule.onInstall && !nuxtModule.onUpgrade) {
+    return;
+  }
+  const rc = read({ dir: nuxt.options.rootDir, name: ".nuxtrc" });
+  const previousVersion = rc?.setups?.[meta.name];
+  try {
+    if (!previousVersion) {
+      await nuxtModule.onInstall?.(nuxt);
+    } else if (semver.gt(meta.version, previousVersion)) {
+      await nuxtModule.onUpgrade?.(inlineOptions, nuxt, previousVersion);
+    }
+    if (previousVersion !== meta.version) {
+      update(
+        { setups: { [meta.name]: meta?.version } },
+        { dir: nuxt.options.rootDir, name: ".nuxtrc" }
+      );
+    }
+  } catch (e) {
+    logger.error(
+      `Error while executing ${!previousVersion ? "install" : "upgrade"} hook for module \`${meta.name}\`: ${e}`
+    );
+  }
+}
+async function callModule(nuxtModule, meta = {}, inlineOptions, resolvedModulePath, moduleToInstall, localLayerModuleDirs, buildTimeModuleMeta, nuxt = useNuxt()) {
+  const res = nuxt.options.experimental?.debugModuleMutation && nuxt._asyncLocalStorageModule ? await nuxt._asyncLocalStorageModule.run(nuxtModule, () => nuxtModule(inlineOptions || {}, nuxt)) ?? {} : await nuxtModule(inlineOptions || {}, nuxt) ?? {};
+  if (res === false) {
+    return;
+  }
+  const modulePath = resolvedModulePath || moduleToInstall;
+  if (typeof modulePath === "string") {
+    const parsed = parseNodeModulePath(modulePath);
+    const moduleRoot = parsed.dir ? parsed.dir + parsed.name : await resolvePackageJSON(modulePath, { try: true }).then((r) => r ? dirname(r) : modulePath);
+    nuxt.options.build.transpile.push(normalizeModuleTranspilePath(moduleRoot));
+    const directory = moduleRoot.replace(/\/?$/, "/");
+    if (moduleRoot !== moduleToInstall && !localLayerModuleDirs.some((dir) => directory.startsWith(dir))) {
+      nuxt.options.modulesDir.push(join(moduleRoot, "node_modules"));
+    }
+  }
+  nuxt.options._installedModules ||= [];
+  const entryPath = typeof moduleToInstall === "string" ? resolveAlias(moduleToInstall, nuxt.options.alias) : void 0;
+  if (typeof moduleToInstall === "string" && entryPath !== moduleToInstall) {
+    buildTimeModuleMeta.rawPath = moduleToInstall;
+  }
+  nuxt.options._installedModules.push({
+    meta: defu(meta, buildTimeModuleMeta),
+    module: nuxtModule,
+    timings: res.timings,
+    entryPath
+  });
+}
 
 function resolveNuxtModuleEntryName(m) {
   if (typeof m === "object" && !Array.isArray(m)) {
@@ -630,7 +837,10 @@ const merger = createDefu((obj, key, value) => {
   }
 });
 async function loadNuxtConfig(opts) {
-  const localLayers = (await glob("layers/*", { onlyDirectories: true, cwd: opts.cwd || process.cwd() })).map((d) => d.endsWith("/") ? d.substring(0, d.length - 1) : d);
+  const localLayers = (await glob("layers/*", {
+    onlyDirectories: true,
+    cwd: opts.cwd || process.cwd()
+  })).map((d) => d.endsWith("/") ? d.substring(0, d.length - 1) : d).sort((a, b) => b.localeCompare(a));
   opts.overrides = defu$1(opts.overrides, { _extends: localLayers });
   const globalSelf = globalThis;
   globalSelf.defineNuxtConfig = (c) => c;
@@ -653,7 +863,7 @@ async function loadNuxtConfig(opts) {
   nuxtConfig.alias ||= {};
   if (meta?.name) {
     const alias = `#layers/${meta.name}`;
-    nuxtConfig.alias[alias] ||= withTrailingSlash(nuxtConfig.rootDir);
+    nuxtConfig.alias[alias] ||= withTrailingSlash$2(nuxtConfig.rootDir);
   }
   const defaultBuildDir = join(nuxtConfig.rootDir, ".nuxt");
   if (!opts.overrides?._prepare && !nuxtConfig.dev && !nuxtConfig.buildDir && existsSync(defaultBuildDir)) {
@@ -687,7 +897,7 @@ async function loadNuxtConfig(opts) {
     }
     if (layer.meta?.name) {
       const alias = `#layers/${layer.meta.name}`;
-      nuxtConfig.alias[alias] ||= withTrailingSlash(layer.config.rootDir || layer.cwd);
+      nuxtConfig.alias[alias] ||= withTrailingSlash$2(layer.config.rootDir || layer.cwd);
     }
     _layers.push(layer);
   }
@@ -1077,6 +1287,13 @@ function addTypeTemplate(_template, context) {
       sharedReferences.push({ path: template.dst });
     });
   }
+  if (!context || context.nuxt || context.shared) {
+    nuxt.options.vite.vue = defu(nuxt.options.vite.vue, {
+      script: {
+        globalTypeFiles: [template.dst]
+      }
+    });
+  }
   if (context?.nitro) {
     nuxt.hook("nitro:prepare:types", ({ references }) => {
       references.push({ path: template.dst });
@@ -1117,11 +1334,11 @@ function normalizeTemplate(template, buildDir) {
 async function updateTemplates(options) {
   return await tryUseNuxt()?.hooks.callHook("builder:generateApp", options);
 }
-function resolveLayerPaths(dir, buildDir, rootDir, srcDir) {
-  const relativeRootDir = relativeWithDot(buildDir, rootDir);
-  const relativeSrcDir = relativeWithDot(buildDir, srcDir);
-  const relativeModulesDir = relativeWithDot(buildDir, resolve(rootDir, dir.modules || "modules"));
-  const relativeSharedDir = relativeWithDot(buildDir, resolve(rootDir, dir.shared || "shared"));
+function resolveLayerPaths(dirs, projectBuildDir) {
+  const relativeRootDir = relativeWithDot(projectBuildDir, dirs.root);
+  const relativeSrcDir = relativeWithDot(projectBuildDir, dirs.app);
+  const relativeModulesDir = relativeWithDot(projectBuildDir, dirs.modules);
+  const relativeSharedDir = relativeWithDot(projectBuildDir, dirs.shared);
   return {
     nuxt: [
       join(relativeSrcDir, "**/*"),
@@ -1173,8 +1390,12 @@ async function _generateTypes(nuxt) {
     include.add(join(relative(nuxt.options.buildDir, nuxt.options.workspaceDir), "**/*"));
     legacyInclude.add(join(relative(nuxt.options.buildDir, nuxt.options.workspaceDir), "**/*"));
   }
+  const layerDirs = getLayerDirectories(nuxt);
+  const sourceDirs = layerDirs.map((layer) => layer.app);
   for (const dir of nuxt.options.modulesDir) {
-    exclude.add(relativeWithDot(nuxt.options.buildDir, dir));
+    if (!sourceDirs.some((srcDir) => dir.startsWith(srcDir))) {
+      exclude.add(relativeWithDot(nuxt.options.buildDir, dir));
+    }
     nodeExclude.add(relativeWithDot(nuxt.options.buildDir, dir));
     legacyExclude.add(relativeWithDot(nuxt.options.buildDir, dir));
   }
@@ -1184,11 +1405,10 @@ async function _generateTypes(nuxt) {
     legacyExclude.add(relativeWithDot(nuxt.options.buildDir, resolve(nuxt.options.rootDir, dir)));
   }
   const rootDirWithSlash = withTrailingSlash(nuxt.options.rootDir);
-  for (const layer of nuxt.options._layers) {
-    const srcOrCwd = withTrailingSlash(layer.config.srcDir ?? layer.cwd);
-    if (!srcOrCwd.startsWith(rootDirWithSlash) || layer.cwd === nuxt.options.rootDir || srcOrCwd.includes("node_modules")) {
-      const rootGlob = join(relativeWithDot(nuxt.options.buildDir, layer.cwd), "**/*");
-      const paths = resolveLayerPaths(defu(layer.config.dir, nuxt.options.dir), nuxt.options.buildDir, layer.cwd, layer.config.srcDir);
+  for (const dirs of layerDirs) {
+    if (!dirs.app.startsWith(rootDirWithSlash) || dirs.root === rootDirWithSlash || dirs.app.includes("node_modules")) {
+      const rootGlob = join(relativeWithDot(nuxt.options.buildDir, dirs.root), "**/*");
+      const paths = resolveLayerPaths(dirs, nuxt.options.buildDir);
       for (const path of paths.nuxt) {
         include.add(path);
         legacyInclude.add(path);
@@ -1544,6 +1764,9 @@ const RELATIVE_WITH_DOT_RE = /^([^.])/;
 function relativeWithDot(from, to) {
   return relative(from, to).replace(RELATIVE_WITH_DOT_RE, "./$1") || ".";
 }
+function withTrailingSlash(dir) {
+  return dir.replace(/[^/]$/, "$&/");
+}
 
 const LAYOUT_RE = /["']/g;
 function addLayout(template, name) {
@@ -1552,9 +1775,9 @@ function addLayout(template, name) {
   const layoutName = kebabCase(name || parse(filename).name).replace(LAYOUT_RE, "");
   nuxt.hook("app:templates", (app) => {
     if (layoutName in app.layouts) {
-      const relativePath = relative(nuxt.options.srcDir, app.layouts[layoutName].file);
+      const relativePath = reverseResolveAlias(app.layouts[layoutName].file, { ...nuxt?.options.alias || {}, ...strippedAtAliases }).pop() || app.layouts[layoutName].file;
       return logger.warn(
-        `Not overriding \`${layoutName}\` (provided by \`~/${relativePath}\`) with \`${src || filename}\`.`
+        `Not overriding \`${layoutName}\` (provided by \`${relativePath}\`) with \`${src || filename}\`.`
       );
     }
     app.layouts[layoutName] = {
@@ -1563,6 +1786,10 @@ function addLayout(template, name) {
     };
   });
 }
+const strippedAtAliases = {
+  "@": "",
+  "@@": ""
+};
 
 function extendPages(cb) {
   useNuxt().hook("pages:extend", cb);
@@ -1643,4 +1870,4 @@ function addPluginTemplate(plugin, opts = {}) {
   return addPlugin(normalizedPlugin, opts);
 }
 
-export { addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, 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, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };
+export { addBuildPlugin, addComponent, addComponentExports, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addRspackPlugin, addServerHandler, addServerImports, addServerImportsDir, addServerPlugin, addServerScanDir, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, createIsIgnored, createResolver, defineNuxtModule, directoryToURL, extendNuxtSchema, extendPages, extendRouteRules, extendRspackConfig, extendViteConfig, extendWebpackConfig, findPath, getDirectory, getLayerDirectories, getNuxtCtx, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, installModules, isIgnored, isNuxt2, isNuxt3, isNuxtMajorVersion, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolveModuleWithOptions, resolveNuxtModule, resolvePath, runWithNuxtContext, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateRuntimeConfig, updateTemplates, useLogger, useNitro, useNuxt, useRuntimeConfig, writeTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/kit",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -23,7 +23,7 @@
     "dist"
   ],
   "dependencies": {
-    "c12": "^3.1.0",
+    "c12": "^3.2.0",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "destr": "^2.0.5",
@@ -32,10 +32,11 @@
     "ignore": "^7.0.5",
     "jiti": "^2.5.1",
     "klona": "^2.0.6",
-    "mlly": "^1.7.4",
+    "mlly": "^1.8.0",
     "ohash": "^2.0.11",
     "pathe": "^2.0.3",
-    "pkg-types": "^2.2.0",
+    "pkg-types": "^2.3.0",
+    "rc9": "^2.1.2",
     "scule": "^1.3.0",
     "semver": "^7.7.2",
     "std-env": "^3.9.0",
@@ -46,15 +47,15 @@
     "untyped": "^2.0.0"
   },
   "devDependencies": {
-    "@rspack/core": "1.4.10",
+    "@rspack/core": "1.5.2",
     "@types/semver": "7.7.0",
     "hookable": "5.5.3",
     "nitropack": "2.12.4",
-    "unbuild": "3.6.0",
-    "vite": "7.0.6",
+    "unbuild": "3.6.1",
+    "vite": "7.1.4",
     "vitest": "3.2.4",
-    "webpack": "5.99.9",
-    "@nuxt/schema": "4.0.2"
+    "webpack": "5.101.3",
+    "@nuxt/schema": "4.1.0"
   },
   "engines": {
     "node": ">=18.12.0"