packages/kit/src/index.ts (1)

13-15: Also export the LayerDirectories type for ergonomics.

Most consumers will want both the function and its result type.

Apply this diff:

 // Layers
-export { getLayerDirectories } from './layers'
+export { getLayerDirectories } from './layers'
+export type { LayerDirectories } from './layers'

packages/kit/src/ignore.ts (1)

25-31: Normalise pathname before prefix checks to avoid false negatives with relative paths.

Ensures consistent behaviour across platforms and call sites that pass relative paths.

Apply this diff:

-  const cwds = getLayerDirectories(nuxt)?.map(layer => layer.rootDir).sort((a, b) => b.length - a.length)
-  const layer = cwds?.find(cwd => pathname.startsWith(cwd))
-  const relativePath = relative(layer ?? nuxt.options.rootDir, pathname)
+  const absPath = pathname.startsWith('/') ? pathname : resolve(nuxt.options.rootDir, pathname)
+  const cwds = getLayerDirectories(nuxt)?.map(layer => layer.rootDir).sort((a, b) => b.length - a.length)
+  const layer = cwds?.find(cwd => absPath.startsWith(cwd))
+  const relativePath = relative(layer ?? nuxt.options.rootDir, absPath)

packages/kit/src/module/install.ts (1)

29-32: Deduplicate local module dirs and simplify collection.

Avoid repeated entries when multiple layers resolve to the same modules dir.

Apply this diff:

-  const localLayerModuleDirs: string[] = []
-  for (const l of getLayerDirectories(nuxt)) {
-    if (!NODE_MODULES_RE.test(l.srcDir)) {
-      localLayerModuleDirs.push(l.dir.modules)
-    }
-  }
+  const localLayerModuleDirs = [...new Set(
+    getLayerDirectories(nuxt)
+      .filter(l => !NODE_MODULES_RE.test(l.srcDir))
+      .map(l => l.dir.modules)
+  )]

packages/nuxt/src/pages/utils.ts (1)

50-51: Verify layer precedence when de-duplicating pages across layers.
You sort by relativePath and then uniqueBy keeps the first occurrence. With stable sort this implicitly depends on getLayerDirectories(nuxt) order. Please confirm root-layer pages correctly override upstream layers for duplicate relative paths. If not, prefer “keep last” semantics:

-  const allRoutes = generateRoutesFromFiles(uniqueBy(scannedFiles, 'relativePath'), {
+  const deduped = Array.from(new Map(scannedFiles.map(f => [f.relativePath, f])).values())
+  const allRoutes = generateRoutesFromFiles(deduped, {
     shouldUseServerComponents: !!nuxt.options.experimental.componentIslands,
   })

packages/nuxt/src/imports/module.ts (1)

117-117: Normalise paths before priority matching; double-check priority direction.
startsWith comparisons can fail cross‑platform if not normalised. Also confirm that Unimport interprets more-negative priorities as higher precedence as intended.

-    const priorities = getLayerDirectories(nuxt).map((layer, i) => [layer.srcDir, -i] as const).sort(([a], [b]) => b.length - a.length)
+    const priorities = getLayerDirectories(nuxt)
+      .map((layer, i) => [normalize(layer.srcDir), -i] as const)
+      .sort(([a], [b]) => b.length - a.length)

And when assigning:

-            i.priority ||= priorities.find(([dir]) => i.from.startsWith(dir))?.[1]
+            const from = normalize(i.from)
+            i.priority ||= priorities.find(([dir]) => from.startsWith(dir))?.[1]

packages/kit/test/generate-types.spec.ts (1)

118-119: Nice: exercising resolveLayerPaths with LayerDirectories.
Consider adding a quick assertion that getLayerDirectories preserves the expected layer order (root last) to guard precedence-sensitive behaviour elsewhere.

packages/nuxt/src/core/builder.ts (1)

105-105: Deduplicate watched srcDirs to avoid redundant watchers.
Not critical, but a Set can prevent duplicate entries.

-  const watcher = chokidarWatch(getLayerDirectories(nuxt).map(i => i.srcDir), {
+  const watcher = chokidarWatch([...new Set(getLayerDirectories(nuxt).map(i => i.srcDir))], {

packages/vite/src/vite.ts (1)

174-177: Prefer withTrailingSlash for robustness.
String concatenation may miss normalisation on Windows or double slashes.

-    const delimitedRootDir = nuxt.options.rootDir + '/'
+    const delimitedRootDir = withTrailingSlash(nuxt.options.rootDir)

packages/nuxt/src/core/schema.ts (1)

67-77: Parcel watch ignore negations unsupported – filter in callback instead
ignore only accepts positive globs (no !-style negation), so ignore: ['!nuxt.schema.*'] won’t work. Subscribe on the root (omit ignore) and invoke onChange only for matching events:

- for (const layer of layerDirs) {
-   const subscription = await subscribe(layer.rootDir, onChange, {
-     ignore: ['!nuxt.schema.*'],
-   })
+ const SCHEMA_RE = /(?:^|\/)nuxt\.schema\.\w+$/
+ for (const layer of layerDirs) {
+   const subscription = await subscribe(layer.rootDir, (_err, events) => {
+     if (events.some(e => SCHEMA_RE.test(e.path))) onChange()
+   })
   nuxt.hook('close', () => subscription.unsubscribe())
 }

packages/nuxt/src/core/app.ts (2)

137-139: Call getLayerDirectories once and derive others from it.

Avoid recomputation and guarantee ordering alignment with _layers.

-  const layerSrcs = getLayerDirectories(nuxt).map(l => l.srcDir)
+  const layerDirs = getLayerDirectories(nuxt)
+  const layerSrcs = layerDirs.map(l => l.srcDir)
...
-  const layerConfigs = nuxt.options._layers.map(layer => layer.config)
-  const reversedConfigs = layerConfigs.slice().reverse()
-  const layerDirs = getLayerDirectories(nuxt)
-  const reversedLayerDirs = [...layerDirs].reverse()
+  const layerConfigs = nuxt.options._layers.map(layer => layer.config)
+  const reversedConfigs = [...layerConfigs].reverse()
+  const reversedLayerDirs = [...layerDirs].reverse()

Also applies to: 154-159

---

195-205: Keep config/plugins and directory plugins in lockstep.

Index-based pairing of reversedConfigs[i] with reversedLayerDirs[i] assumes identical lengths/order. Add a quick invariant check or guard to prevent subtle misalignment.

Example guard:

+  if (reversedConfigs.length !== reversedLayerDirs.length) {
+    logger.warn('Layer configs and directories length mismatch; plugin resolution order may be off.')
+  }

packages/kit/src/template.ts (2)

171-211: resolveLayerPaths(layer, projectBuildDir): solid refactor; one micro-tweak.

Great consolidation. Consider adding globalDeclarations for nested layer roots beyond one level if you intend to support deeper nesting in future.

---

171-211: Potential public API break (signature change).

resolveLayerPaths changed its signature; if external consumers import it, this is breaking. Consider an overload/deprecation shim to accept the old parameters for one minor cycle.

Would you like a backward-compatible overload implementation?

packages/nuxt/src/core/nuxt.ts (4)

162-163: Cache and reuse layerDirs within initNuxt

You compute layerDirs once here; later you recompute via getLayerDirectories in the watcher. Prefer using this cached value for clarity and to avoid redundant calls (even if memoised).

Apply this diff near the watcher to reuse the cached array:

-    const layerRelativePaths = new Set(getLayerDirectories(nuxt).map(l => relative(l.srcDir, path)))
+    const layerRelativePaths = new Set(layerDirs.map(l => relative(l.srcDir, path)))

---

419-421: Transpile selection for node_modules-backed layers looks good; consider deduping

Pushing many paths can introduce duplicates. Optional: dedupe nuxt.options.build.transpile after population to keep config lean.

   nuxt.options.build.transpile.push(
     ...layerDirs.filter(i => i.rootDir.includes('node_modules')).map(i => i.rootDir),
   )
+  // Optional: dedupe
+  nuxt.options.build.transpile = [...new Set(nuxt.options.build.transpile)]

---

423-431: Modules dir injection: path prefix check is OK; add trailing-slash normalisation for robustness

The startsWith check is string-based. Guard against accidental partial matches by ensuring both sides are normalised with a trailing slash.

-  const locallyScannedLayersDirs = layerDirs.map(l => join(l.rootDir, 'layers/'))
+  const locallyScannedLayersDirs = layerDirs.map(l => withTrailingSlash(join(l.rootDir, 'layers')))
   for (const layer of layerDirs) {
-    if (locallyScannedLayersDirs.every(dir => !layer.rootDir.startsWith(dir))) {
+    const layerRoot = withTrailingSlash(layer.rootDir)
+    if (locallyScannedLayersDirs.every(dir => !layerRoot.startsWith(dir))) {
       nuxt.options.modulesDir.push(join(layer.rootDir, 'node_modules'))
     }
   }

---

685-699: Reuse cached layerDirs in watcher

Small nit: use the earlier layerDirs variable to avoid recomputation and keep intent clear.

-    const layerRelativePaths = new Set(getLayerDirectories(nuxt).map(l => relative(l.srcDir, path)))
+    const layerRelativePaths = new Set(layerDirs.map(l => relative(l.srcDir, path)))

packages/nuxt/src/core/nitro.ts (3)

158-160: Reuse cached layerDirs instead of recomputing

Minor tidy-up to avoid repeated getLayerDirectories calls.

-          ...getLayerDirectories(nuxt).map(layer =>
+          ...layerDirs.map(layer =>
             relativeWithDot(nuxt.options.buildDir, join(layer.dir.shared, '**/*.d.ts')),
           ),

---

177-181: Reuse cached layerDirs for public assets

Avoid repeated getLayerDirectories calls.

-      ...getLayerDirectories(nuxt)
-        .map(layer => layer.dir.public)
+      ...layerDirs
+        .map(layer => layer.dir.public)
         .filter(dir => existsSync(dir))
         .map(dir => ({ dir })),

---

206-207: Reuse cached layerDirs for externals inline

Same tidy-up here.

-        ...getLayerDirectories(nuxt).map(layer => join(layer.srcDir, 'app.config')),
+        ...layerDirs.map(layer => join(layer.srcDir, 'app.config')),

packages/nuxt/src/pages/module.ts (1)

307-312: Template regeneration watch set: good coverage of pages/layouts/middleware

Optional: dedupe directories to avoid redundant startsWith checks when multiple layers point to the same path.

-    const updateTemplatePaths = getLayerDirectories(nuxt)
-      .flatMap(l => [
-        l.dir.pages,
-        l.dir.layouts,
-        l.dir.middleware,
-      ])
+    const updateTemplatePaths = Array.from(new Set(
+      getLayerDirectories(nuxt).flatMap(l => [
+        l.dir.pages,
+        l.dir.layouts,
+        l.dir.middleware,
+      ]),
+    ))

packages/kit/src/layers.ts (5)

21-21: Add an explicit return type for the public API.

This is part of the public kit surface; make the return type explicit to avoid accidental breaking changes due to inference shifts.

-export function getLayerDirectories (nuxt = useNuxt()) {
+export function getLayerDirectories (nuxt = useNuxt()): LayerDirectories[] {

---

52-54: Use a more robust trailing-slash helper (optional).

Local regex is fine, but we already rely on pathe. Consider a shared utility (or at least guard the empty-string case) to avoid subtle edge cases.

-function withTrailingSlash (dir: string) {
-  return dir.replace(/[^/]$/, '$&/')
-}
+function withTrailingSlash (dir: string) {
+  return dir.endsWith('/') ? dir : (dir ? `${dir}/` : '/`)
+}

---

19-25: Cache invalidation note (FYI).

WeakMap caching is good. If any code mutates layer config at runtime (rare), results may become stale. If that’s possible in dev mode, consider an explicit invalidateLayerDirectories(layer) or clearing the cache on nuxt.hook('restart', ...).

---

5-18: Consider including other commonly used directories (optional).

Depending on adoption plans, assets and components are frequent lookups. Including them up-front can reduce repeated ad-hoc resolutions in consumers.

---

37-45: Document rootDir-relative keys in dir or lift them out
dir.modules, dir.shared and dir.public are all resolved from rootDir, whereas other dir.* entries use srcDir. This asymmetry is intentional and consistently handled across the codebase, but may confuse consumers. Consider either:

• Extracting modules, shared, and public into dedicated top-level options (e.g. modulesDir, sharedDir, publicDir), or
• Adding clear documentation/comments that these specific entries are rootDir-relative.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: GalacticHypernova
PR: nuxt/nuxt#26468
File: packages/nuxt/src/components/plugins/loader.ts:24-24
Timestamp: 2024-11-05T15:22:54.759Z
Learning: In `packages/nuxt/src/components/plugins/loader.ts`, the references to `resolve` and `distDir` are legacy code from before Nuxt used the new unplugin VFS and will be removed.

Learnt from: CR
PR: nuxt/nuxt#0
File: .github/copilot-instructions.md:0-0
Timestamp: 2025-07-18T16:46:07.446Z
Learning: Applies to **/*.{test,spec}.{ts,tsx,js,jsx} : Write unit tests for core functionality using `vitest`

Learnt from: CR
PR: nuxt/nuxt#0
File: .github/copilot-instructions.md:0-0
Timestamp: 2025-07-18T16:46:07.446Z
Learning: Applies to **/e2e/**/*.{ts,js} : Write end-to-end tests using Playwright and `nuxt/test-utils`

Learnt from: huang-julien
PR: nuxt/nuxt#29366
File: packages/nuxt/src/app/components/nuxt-root.vue:16-19
Timestamp: 2024-12-12T12:36:34.871Z
Learning: In `packages/nuxt/src/app/components/nuxt-root.vue`, when optimizing bundle size by conditionally importing components based on route metadata, prefer using inline conditional imports like:

```js
const IsolatedPage = route?.meta?.isolate ? defineAsyncComponent(() => import('#build/isolated-page.mjs')) : null
```

instead of wrapping the import in a computed property or importing the component unconditionally.

packages/nuxt/src/core/app.ts (1)

188-194: Avoid positional coupling between two reversed arrays.

Indexing reversedLayers[i] alongside reversedLayerDirs[i] is brittle. Build a zipped structure for clarity and safety.

Example refactor:

-  for (let i = 0; i < reversedLayerDirs.length; i++) {
-    const config = reversedLayers[i]!.config
-    const layer = reversedLayerDirs[i]!
+  const reversed = reversedLayers.map((l, i) => ({ layer: reversedLayerDirs[i]!, config: l.config }))
+  for (const { layer, config } of reversed) {

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: GalacticHypernova
PR: nuxt/nuxt#26468
File: packages/nuxt/src/components/plugins/loader.ts:24-24
Timestamp: 2024-11-05T15:22:54.759Z
Learning: In `packages/nuxt/src/components/plugins/loader.ts`, the references to `resolve` and `distDir` are legacy code from before Nuxt used the new unplugin VFS and will be removed.

packages/nuxt/src/core/app.ts (3)

150-150: Prefer user error component over base layers.

Use reversedLayerDirs so the project’s error.vue takes precedence.

Apply this diff:

-app.errorComponent ||= (await findPath(layerDirs.map(d => join(d.src, 'error')))) ?? resolve(nuxt.options.appDir, 'components/nuxt-error-page.vue')
+app.errorComponent ||= (await findPath(reversedLayerDirs.map(d => join(d.src, 'error')))) ?? resolve(nuxt.options.appDir, 'components/nuxt-error-page.vue')

---

171-175: Middleware precedence regression: double-reverse makes base win.

Scan base→user so the existing de-dupe at Line 212 preserves user copies.

Apply this diff:

-for (const dirs of reversedLayerDirs) {
+for (const dirs of layerDirs) {

---

143-143: Fix layer precedence for app.vue: user/project layer should win.

Search currently prefers base layers. Reverse the search order.

Apply this diff:

-app.mainComponent ||= await findPath(layerDirs.flatMap(d => [join(d.src, 'App'), join(d.src, 'app')]),)
+app.mainComponent ||= await findPath(reversedLayerDirs.flatMap(d => [join(d.src, 'App'), join(d.src, 'app')]))

packages/kit/src/layers.ts (3)

36-38: Fix brittle root-layer detection (normalise and compare absolute paths).

Comparing raw config.rootDir strings can mis-detect the root layer due to relative paths, trailing slashes, or case differences. Resolve against cwd and normalise both sides before comparing.

Apply this diff:

-    const isRoot = layer.config.rootDir === nuxt.options.rootDir
-    const config = isRoot ? nuxt.options : (layer.config as NuxtOptions)
+    const layerRootAbs = resolve(layer.cwd, layer.config.rootDir || '.')
+    const nuxtRootAbs = resolve(nuxt.options.rootDir || '.')
+    const isRoot = normalize(layerRootAbs) === normalize(nuxtRootAbs)
+    const config = isRoot ? nuxt.options : (layer.config as NuxtOptions)

---

39-41: Resolve rootDir relative to the layer root and derive srcDir from that.

Current code may treat relative rootDir/srcDir incorrectly and can also keep Windows backslashes in src/root. Resolve first to stabilise outcomes across platforms.

Apply this diff:

-    const src = withTrailingSlash(config.srcDir || layer.cwd)
-    const root = withTrailingSlash(config.rootDir || layer.cwd)
+    const root = withTrailingSlash(resolve(layer.cwd, config.rootDir || '.'))
+    const src = withTrailingSlash(resolve(root, config.srcDir || '.'))

---

1-3: Import normalize from pathe for the root-layer comparison.

Apply this diff:

-import { resolve } from 'pathe'
+import { resolve, normalize } from 'pathe'

packages/kit/src/template.ts (1)

171-211: Exclude current layer’s server directory from app TS includes, and validate nested layer src defaults.

• nitro globs don’t exclude dirs.server for the current layer; when server sits under src (v3-style), server files can leak into app TS. Add it explicitly.
• Nested layer globs assume app/ as src; custom srcDir in nested layers may be missed.

Apply this diff to exclude the current layer’s server:

 export function resolveLayerPaths (dirs: LayerDirectories, projectBuildDir: string) {
   const relativeRootDir = relativeWithDot(projectBuildDir, dirs.root)
   const relativeSrcDir = relativeWithDot(projectBuildDir, dirs.src)
   const relativeModulesDir = relativeWithDot(projectBuildDir, dirs.modules)
   const relativeSharedDir = relativeWithDot(projectBuildDir, dirs.shared)
+  const relativeServerDir = relativeWithDot(projectBuildDir, dirs.server)
   return {
     nuxt: [
       join(relativeSrcDir, '**/*'),
       join(relativeModulesDir, `*/runtime/**/*`),
       join(relativeRootDir, `layers/*/app/**/*`),
       join(relativeRootDir, `layers/*/modules/*/runtime/**/*`),
     ],
     nitro: [
+      join(relativeServerDir, `**/*`),
       join(relativeModulesDir, `*/runtime/server/**/*`),
       join(relativeRootDir, `layers/*/server/**/*`),
       join(relativeRootDir, `layers/*/modules/*/runtime/server/**/*`),
     ],

If you want to support nested layers with custom srcDir in the globs, we can extend resolveLayerPaths or rely solely on getLayerDirectories in _generateTypes instead of hard-coded app paths.

packages/kit/src/layers.ts (3)

28-35: Cache invalidation for HMR/config changes.

WeakMap avoids leaks but cached paths can become stale if a layer’s config mutates in place (e.g. via hooks). Consider clearing cache on config extension or derive a cache key from resolved root/src.

Example addition (outside this hunk) to expose an invalidator:

// near layerMap
export function invalidateLayerDirectoriesCache () {
  layerMap && (layerMap as WeakMap<any, any>).clear?.()
}

And optionally hook once:

// when you have access to nuxt instance
nuxt.hooks.hook('config:extend', () => invalidateLayerDirectoriesCache())

---

62-64: Make withTrailingSlash simpler and robust post-normalisation.

After switching to pathe.resolve, inputs are POSIX-style. A fast endsWith is clearer.

Apply this diff:

-function withTrailingSlash (dir: string) {
-  return dir.replace(/[^/]$/, '$&/')
-}
+function withTrailingSlash (dir: string) {
+  return dir.endsWith('/') ? dir : (dir + '/')
+}

---

5-26: Naming shape: consider explicit app vs src to mirror config discussion.

To match the proposed clarity (root/server/modules/shared/public vs app-local), consider adding app and appLayouts/appMiddleware/appPages/appPlugins (keep src as alias for back-compat).

Possible type tweak:

 export interface LayerDirectories {
-  readonly src: string
+  /** App directory (`/app/` by default). Alias: `src` for back-compat. */
+  readonly app: string
+  /** Back-compat alias for `app`. */
+  readonly src: string
-  readonly layouts: string
-  readonly middleware: string
-  readonly pages: string
-  readonly plugins: string
+  readonly appLayouts: string
+  readonly appMiddleware: string
+  readonly appPages: string
+  readonly appPlugins: string
 }

And map properties accordingly while still populating the old names for transition.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: nuxt/nuxt#0
File: .github/copilot-instructions.md:0-0
Timestamp: 2025-07-18T16:46:07.446Z
Learning: Applies to **/*.{test,spec}.{ts,tsx,js,jsx} : Write unit tests for core functionality using `vitest`

Learnt from: CR
PR: nuxt/nuxt#0
File: .github/copilot-instructions.md:0-0
Timestamp: 2025-07-18T16:46:07.446Z
Learning: Applies to **/*.vue : Use `<script setup lang="ts">` and the composition API when creating Vue components

Learnt from: GalacticHypernova
PR: nuxt/nuxt#26468
File: packages/nuxt/src/components/plugins/loader.ts:24-24
Timestamp: 2024-11-05T15:22:54.759Z
Learning: In `packages/nuxt/src/components/plugins/loader.ts`, the references to `resolve` and `distDir` are legacy code from before Nuxt used the new unplugin VFS and will be removed.

Learnt from: huang-julien
PR: nuxt/nuxt#29366
File: packages/nuxt/src/app/components/nuxt-root.vue:16-19
Timestamp: 2024-12-12T12:36:34.871Z
Learning: In `packages/nuxt/src/app/components/nuxt-root.vue`, when optimizing bundle size by conditionally importing components based on route metadata, prefer using inline conditional imports like:

```js
const IsolatedPage = route?.meta?.isolate ? defineAsyncComponent(() => import('#build/isolated-page.mjs')) : null
```

instead of wrapping the import in a computed property or importing the component unconditionally.

packages/nuxt/src/core/nuxt.ts (2)

262-269: Optional: also look for declarations in src as a fallback

Some layers may historically place index.d.ts under srcDir. Consider checking dirs.src as a fallback for smoother v3→v4 transitions.

Proposed change:

-    for (const dirs of layerDirs) {
-      const declaration = join(dirs.root, 'index.d.ts')
-      if (existsSync(declaration)) {
-        opts.references.push({ path: declaration })
-        opts.nodeReferences.push({ path: declaration })
-        opts.sharedReferences.push({ path: declaration })
-      }
-    }
+    for (const dirs of layerDirs) {
+      const candidates = [join(dirs.root, 'index.d.ts'), join(dirs.src, 'index.d.ts')]
+      for (const declaration of candidates) {
+        if (existsSync(declaration)) {
+          opts.references.push({ path: declaration })
+          opts.nodeReferences.push({ path: declaration })
+          opts.sharedReferences.push({ path: declaration })
+          break
+        }
+      }
+    }

---

681-696: Nit: reuse cached layerDirs and normalise string patterns

• Reuse the already computed layerDirs instead of re-calling getLayerDirectories(nuxt); it’s cached, but avoiding the call is cleaner.
• Normalise string watch patterns before comparing, to be resilient to path separator differences.

Suggested tweak:

-    const layerRelativePaths = new Set(getLayerDirectories(nuxt).map(l => relative(l.src, path)))
+    const normalizedPath = normalize(path)
+    const layerRelativePaths = new Set(layerDirs.map(l => relative(l.src, normalizedPath)))
     for (const pattern of nuxt.options.watch) {
       if (typeof pattern === 'string') {
-        // Test (normalized) strings against absolute path and relative path to any layer `srcDir`
-        if (pattern === path || layerRelativePaths.has(pattern)) { return nuxt.callHook('restart') }
+        const p = normalize(pattern)
+        // Test normalised strings against absolute path and relative path to any layer `srcDir`
+        if (p === normalizedPath || layerRelativePaths.has(p)) { return nuxt.callHook('restart') }
         continue
       }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: GalacticHypernova
PR: nuxt/nuxt#26468
File: packages/nuxt/src/components/plugins/loader.ts:24-24
Timestamp: 2024-11-05T15:22:54.759Z
Learning: In `packages/nuxt/src/components/plugins/loader.ts`, the references to `resolve` and `distDir` are legacy code from before Nuxt used the new unplugin VFS and will be removed.

docs/3.api/5.kit/16.layers.md (5)

103-125: Example 1: Prefer layer.app and minor ESM nit

Use layer.app (if that’s the final field name), and consider node:-prefixed built-ins elsewhere for consistency.

-      const files = await globby('**/*.vue', {
-        cwd: resolve(layer.src, 'components'),
+      const files = await globby('**/*.vue', {
+        cwd: resolve(layer.app, 'components'),
         absolute: true
       })

---

130-147: Example 2: Use layer.app and prefer node:fs

Align with the API and Node ESM import style.

-import { existsSync } from 'fs'
+import { existsSync } from 'node:fs'
@@
-      const configPath = resolve(layer.src, 'my-module.config.ts')
+      const configPath = resolve(layer.app, 'my-module.config.ts')

---

155-186: Example 3: Avoid mutating with reverse() and use app fields

• reverse() mutates; prefer a non-mutating approach.
• Update to layer.app and Node ESM imports.

-import { existsSync, readFileSync } from 'fs'
+import { existsSync, readFileSync } from 'node:fs'
@@
-      const configPath = resolve(layer.src, 'my-config.json')
+      const configPath = resolve(layer.app, 'my-config.json')
@@
-    for (const layer of layerDirs.reverse()) { // Process from lowest to highest priority
-      const configPath = resolve(layer.src, 'my-config.json')
+    for (const layer of [...layerDirs].reverse()) { // Process from lowest to highest priority
+      const configPath = resolve(layer.app, 'my-config.json')

---

191-207: Example 4: Use layer.app and prefer node:fs

-import { existsSync } from 'fs'
+import { existsSync } from 'node:fs'
@@
-    const layersWithAssets = layerDirs.filter(layer => {
-      return existsSync(resolve(layer.src, 'assets'))
-    })
+    const layersWithAssets = layerDirs.filter(layer => {
+      return existsSync(resolve(layer.app, 'assets'))
+    })

---

17-37: Add a brief note on call context

Clarify that getLayerDirectories should be called within a Nuxt context (e.g., inside defineNuxtModule setup) or with an explicit nuxt instance.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

packages/nuxt/src/core/nuxt.ts (1)

422-430: Fix local layers detection and root comparison normalisation

Using all layers’ layers/ paths can misclassify non-local layers, and comparing dirs.root (trailing slash) to nuxt.options.rootDir can fail. Restrict to the project’s ./layers/ and normalise with trailing slashes.

-  const locallyScannedLayersDirs = layerDirs.map(l => join(l.root, 'layers/'))
-  for (const dirs of layerDirs) {
-    if (normalize(dirs.root) === normalize(nuxt.options.rootDir)) {
-      continue
-    }
-    if (locallyScannedLayersDirs.every(dir => !dirs.root.startsWith(dir))) {
-      nuxt.options.modulesDir.push(join(dirs.root, 'node_modules'))
-    }
-  }
+  const locallyScannedLayersDir = withTrailingSlash(join(nuxt.options.rootDir, 'layers'))
+  for (const dirs of layerDirs) {
+    // Skip the project root layer
+    if (withTrailingSlash(dirs.root) === withTrailingSlash(nuxt.options.rootDir)) {
+      continue
+    }
+    // Only add node_modules for layers not under the project's ./layers/*
+    if (!withTrailingSlash(dirs.root).startsWith(locallyScannedLayersDir)) {
+      nuxt.options.modulesDir.push(join(dirs.root, 'node_modules'))
+    }
+  }

Optional: deduplicate afterwards.

nuxt.options.modulesDir = Array.from(new Set(nuxt.options.modulesDir))

packages/kit/src/layers.ts (2)

49-51: Make root-layer detection robust (normalise cwd vs rootDir).

Comparing config.rootDir to nuxt.options.rootDir can be brittle; use layer.cwd normalised (and compare to nuxt.options.rootDir) to avoid trailing-slash/relative differences.

Apply this diff:

-    const isRoot = normalize(layer.config.rootDir) === normalize(nuxt.options.rootDir)
+    const isRoot = normalize(layer.cwd) === normalize(nuxt.options.rootDir)

---

52-54: Resolve rootDir/srcDir relative to the layer root.

Relative rootDir/srcDir should be resolved against layer.cwd. Also compute root before src so src can be relative to root.

Apply this diff:

-    const src = withTrailingSlash(config.srcDir || layer.cwd)
-    const root = withTrailingSlash(config.rootDir || layer.cwd)
+    const root = withTrailingSlash(resolve(layer.cwd, config.rootDir || '.'))
+    const src = withTrailingSlash(resolve(root, config.srcDir || '.'))

docs/3.api/5.kit/16.layers.md (1)

85-97: Document resolution base nuances (v3 vs v4) for directories

Server/modules/public are resolved relative to srcDir for v3 back-compat in code; v4 leans root-relative. Add a note to reduce confusion.

 | `public`     | `string` | The public directory for static assets                                         |
 | `layouts`    | `string` | The layouts directory for Vue layout components                                |
 | `middleware` | `string` | The middleware directory for route middleware                                  |
 | `pages`      | `string` | The pages directory for file-based routing                                    |
 | `plugins`    | `string` | The plugins directory for Nuxt plugins                                        |
+
+> Note
+> For Nuxt 3 compatibility, `server`, `modules` and `public` are currently resolved relative to `srcDir`. In Nuxt 4 they are treated as root-relative by default. `getLayerDirectories` resolves paths accordingly for each layer.

packages/nuxt/src/core/nuxt.ts (1)

681-683: Optional: avoid recomputing layer dirs on every event

If layers don’t change during a watch session, reuse layerDirs for this handler. Not critical.

-    const layerRelativePaths = new Set(getLayerDirectories(nuxt).map(l => relative(l.src, path)))
+    const layerRelativePaths = new Set(layerDirs.map(l => relative(l.src, path)))

packages/kit/src/template.ts (1)

256-260: Remove unused rootGlob or include it intentionally.

rootGlob is computed but never added to any include/exclude set; the conditional if (path !== rootGlob) will always be true. Either drop the variable and condition or add rootGlob to paths.nuxt.

Apply this diff to simplify:

-    if (!dirs.src.startsWith(rootDirWithSlash) || normalize(dirs.root) === normalize(nuxt.options.rootDir) || dirs.src.includes('node_modules')) {
-      const rootGlob = join(relativeWithDot(nuxt.options.buildDir, dirs.root), '**/*')
+    if (!dirs.src.startsWith(rootDirWithSlash) || normalize(dirs.root) === normalize(nuxt.options.rootDir) || dirs.src.includes('node_modules')) {
       const paths = resolveLayerPaths(dirs, nuxt.options.buildDir)
       for (const path of paths.nuxt) {
         include.add(path)
         legacyInclude.add(path)
-        if (path !== rootGlob) {
-          nodeExclude.add(path)
-        }
+        nodeExclude.add(path)
       }

packages/kit/src/layers.ts (1)

75-77: Reuse ufo’s withTrailingSlash instead of a local helper.

The local regex doesn’t handle edge cases (e.g. empty strings, backslashes). ufo is already used elsewhere and is cross-platform.

Apply these diffs:

@@
-import type { NuxtConfigLayer, NuxtOptions } from '@nuxt/schema'
-import { normalize, resolve } from 'pathe'
+import type { NuxtConfigLayer, NuxtOptions } from '@nuxt/schema'
+import { normalize, resolve } from 'pathe'
+import { withTrailingSlash } from 'ufo'
@@
-function withTrailingSlash (dir: string) {
-  return dir.replace(/[^/]$/, '$&/')
-}
+// use `ufo`'s withTrailingSlash for consistent behaviour

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: huang-julien
PR: nuxt/nuxt#29366
File: packages/nuxt/src/app/components/nuxt-root.vue:16-19
Timestamp: 2024-12-12T12:36:34.871Z
Learning: In `packages/nuxt/src/app/components/nuxt-root.vue`, when optimizing bundle size by conditionally importing components based on route metadata, prefer using inline conditional imports like:

```js
const IsolatedPage = route?.meta?.isolate ? defineAsyncComponent(() => import('#build/isolated-page.mjs')) : null
```

instead of wrapping the import in a computed property or importing the component unconditionally.

Learnt from: GalacticHypernova
PR: nuxt/nuxt#26468
File: packages/nuxt/src/components/plugins/loader.ts:24-24
Timestamp: 2024-11-05T15:22:54.759Z
Learning: In `packages/nuxt/src/components/plugins/loader.ts`, the references to `resolve` and `distDir` are legacy code from before Nuxt used the new unplugin VFS and will be removed.

packages/nuxt/src/core/nuxt.ts (2)

422-430: Normalise root comparison and simplify local layers exclusion.
Use a single locally-scanned layers path and normalise with trailing slashes to skip the project root reliably.

-  const locallyScannedLayersDirs = layerDirs.map(l => join(l.root, 'layers/'))
-  for (const dirs of layerDirs) {
-    if (normalize(dirs.root) === normalize(nuxt.options.rootDir)) {
-      continue
-    }
-    if (locallyScannedLayersDirs.every(dir => !dirs.root.startsWith(dir))) {
-      nuxt.options.modulesDir.push(join(dirs.root, 'node_modules'))
-    }
-  }
+  const locallyScannedLayersDir = join(withTrailingSlash(nuxt.options.rootDir), 'layers/')
+  for (const dirs of layerDirs) {
+    if (withTrailingSlash(dirs.root) === withTrailingSlash(nuxt.options.rootDir)) { continue }
+    if (!dirs.root.startsWith(locallyScannedLayersDir)) {
+      nuxt.options.modulesDir.push(join(dirs.root, 'node_modules'))
+    }
+  }

---

921-926: Normalise root comparison when resolving modulesDir.
Prevents choosing the wrong base dir.

-    const modulesDir = resolve(config.srcDir, (config.rootDir === nuxt.options.rootDir ? nuxt.options.dir : config.dir)?.modules || 'modules')
+    const isRootLayer = normalize(config.rootDir) === normalize(nuxt.options.rootDir)
+    const baseDir = (isRootLayer ? nuxt.options.dir : config.dir)?.modules || 'modules'
+    const modulesDir = resolve(config.srcDir, baseDir)

packages/kit/src/layers.ts (3)

49-51: Root-layer detection should use cwd (normalised).
Comparing config.rootDir can be brittle; prefer layer.cwd vs nuxt.options.rootDir.

-    const isRoot = normalize(layer.config.rootDir) === normalize(nuxt.options.rootDir)
+    const isRoot = normalize(layer.cwd) === normalize(nuxt.options.rootDir)

---

52-54: Resolve root/src relative to the layer root.
Relative values should be resolved from layer.cwd, and src from the resolved root.

-    const src = withTrailingSlash(config.srcDir || layer.cwd)
-    const root = withTrailingSlash(config.rootDir || layer.cwd)
+    const root = withTrailingSlash(resolve(layer.cwd, config.rootDir || '.'))
+    const src = withTrailingSlash(resolve(root, config.srcDir || '.'))

---

55-63: Bug: server should be based on root (Nuxt v4 semantics).
Using src can misplace the server dir when srcDir ≠ rootDir.

-      // these are resolved relative to root in `@nuxt/schema` for v4+
-      // so resolving relative to `src` covers backward compatibility for v3
-      server: withTrailingSlash(resolve(src, resolveAlias(config.serverDir || 'server', nuxt.options.alias))),
+      // In v4, serverDir is resolved from root
+      server: withTrailingSlash(resolve(root, resolveAlias(config.serverDir || 'server', nuxt.options.alias))),

packages/vite/src/vite.ts (2)

37-41: Normalise paths to avoid duplicate or missed pruning due to trailing slashes.

getLayerDirectories().map(d => d.root) returns paths with a trailing slash, while others (e.g. modulesDir, workspaceDir) may not. The subsequent startsWith pruning is order- and slash-sensitive and may leave near-duplicates (e.g. /a vs /a/). Normalise before pruning.

   let allowDirs = [
     nuxt.options.appDir,
     nuxt.options.workspaceDir,
     ...nuxt.options.modulesDir,
-    ...getLayerDirectories(nuxt).map(d => d.root),
+    ...getLayerDirectories(nuxt).map(d => d.root),
     ...Object.values(nuxt.apps).flatMap(app => [
       ...app.components.map(c => dirname(c.filePath)),
       ...app.plugins.map(p => dirname(p.src)),
       ...app.middleware.map(m => dirname(m.path)),
       ...Object.values(app.layouts || {}).map(l => dirname(l.file)),
       dirname(nuxt.apps.default!.rootComponent!),
       dirname(nuxt.apps.default!.errorComponent!),
     ]),
   ].filter(d => d && existsSync(d))
 
+  // Ensure consistent comparison (remove trailing slash, normalise separators)
+  allowDirs = allowDirs.map(d => normalize(d).replace(/\/$/, ''))
+
   for (const dir of allowDirs) {
     allowDirs = allowDirs.filter(d => !d.startsWith(dir) || d === dir)
   }

Also applies to: 50-55

---

169-177: Make root/app comparisons robust; drop redundant equality check.

dirs.app is normalised with a trailing slash; nuxt.options.srcDir typically is not. The equality check can be dropped; the startsWith(delimitedRootDir) guard already excludes the root layer. Also normalise both sides for cross-platform safety.

-  const delimitedRootDir = nuxt.options.rootDir + '/'
-  for (const dirs of getLayerDirectories(nuxt)) {
-    if (dirs.app !== nuxt.options.srcDir && !dirs.app.startsWith(delimitedRootDir)) {
-      layerDirs.push(dirs.app)
-    }
-  }
+  const delimitedRootDir = withTrailingSlash(normalize(nuxt.options.rootDir))
+  for (const dirs of getLayerDirectories(nuxt)) {
+    const appDir = withTrailingSlash(normalize(dirs.app))
+    if (!appDir.startsWith(delimitedRootDir)) {
+      layerDirs.push(appDir)
+    }
+  }

packages/nuxt/src/pages/module.ts (2)

88-89: Consider de-duplicating pagesDirs.

Multiple layers can point to the same appPages directory (e.g. symlinks). It’s harmless but easy to dedupe.

-    const pagesDirs = getLayerDirectories(nuxt).map(dirs => dirs.appPages)
+    const pagesDirs = Array.from(new Set(getLayerDirectories(nuxt).map(dirs => dirs.appPages)))

---

307-313: Use a Set to avoid redundant checks and tiny perf win.

Flattened array may include duplicates across layers. Using a Set reduces repeated startsWith checks during rebuilds.

-    const updateTemplatePaths = getLayerDirectories(nuxt)
-      .flatMap(dirs => [
-        dirs.appPages,
-        dirs.appLayouts,
-        dirs.appMiddleware,
-      ])
+    const updateTemplatePaths = new Set(
+      getLayerDirectories(nuxt).flatMap(dirs => [
+        dirs.appPages,
+        dirs.appLayouts,
+        dirs.appMiddleware,
+      ]),
+    )

And adjust the usage below:

-      if (shouldAlwaysRegenerate || updateTemplatePaths.some(dir => path.startsWith(dir))) {
+      if (shouldAlwaysRegenerate || Array.from(updateTemplatePaths).some(dir => path.startsWith(dir))) {

packages/nuxt/src/core/builder.ts (2)

27-29: Path check is fine; consider normalisation for safety.

relative(dirs.app, path) is robust, but given dirs.app has a trailing slash, normalising both occasionally avoids edge cases on Windows or unusual separators.

-          const relativePath = relative(dirs.app, path)
+          const relativePath = relative(normalize(dirs.app), normalize(path))

---

248-254: Skip ignored app dirs early and normalise paths.

Good to use isIgnored(dirs.app); add normalisation to avoid platform-specific mismatches and keep the set canonical.

-  for (const dirs of getLayerDirectories(nuxt)) {
-    if (!dirs.app || isIgnored(dirs.app)) { continue }
-    pathsToWatch.add(dirs.app)
+  for (const dirs of getLayerDirectories(nuxt)) {
+    const appDir = normalize(dirs.app)
+    if (!appDir || isIgnored(appDir)) { continue }
+    pathsToWatch.add(appDir)
   }

packages/nuxt/src/core/nitro.ts (3)

158-159: Reuse layerDirs instead of recomputing

Avoids extra calls (even if cached).

-          ...getLayerDirectories(nuxt).map(dirs => relativeWithDot(nuxt.options.buildDir, join(dirs.shared, '**/*.d.ts'))),
+          ...layerDirs.map(dirs => relativeWithDot(nuxt.options.buildDir, join(dirs.shared, '**/*.d.ts'))),

---

175-178: Reuse layerDirs here as well

Minor micro-optimisation.

-      ...getLayerDirectories(nuxt)
-        .filter(dirs => existsSync(dirs.public))
-        .map(dirs => ({ dir: dirs.public })),
+      ...layerDirs
+        .filter(dirs => existsSync(dirs.public))
+        .map(dirs => ({ dir: dirs.public })),

---

203-204: And reuse layerDirs here

Keeps things consistent.

-        ...getLayerDirectories(nuxt).map(dirs => join(dirs.app, 'app.config')),
+        ...layerDirs.map(dirs => join(dirs.app, 'app.config')),

packages/kit/src/template.ts (1)

255-259: Normalise paths for cross‑platform checks

startsWith/includes can misfire on Windows due to backslashes.

-  const rootDirWithSlash = withTrailingSlash(nuxt.options.rootDir)
+  const rootDirWithSlash = withTrailingSlash(normalize(nuxt.options.rootDir))
   for (const dirs of layerDirs) {
-    if (!dirs.app.startsWith(rootDirWithSlash) || normalize(dirs.root) === normalize(nuxt.options.rootDir) || dirs.app.includes('node_modules')) {
+    const appPosix = normalize(dirs.app)
+    if (!appPosix.startsWith(rootDirWithSlash) || normalize(dirs.root) === normalize(nuxt.options.rootDir) || appPosix.includes('/node_modules/')) {
       const rootGlob = join(relativeWithDot(nuxt.options.buildDir, dirs.root), '**/*')
       const paths = resolveLayerPaths(dirs, nuxt.options.buildDir)

packages/nuxt/src/core/nuxt.ts (2)

418-419: Harden node_modules detection to avoid false positives.
Use a normalised path and a bounded match.

-  ...layerDirs.filter(i => i.root.includes('node_modules')).map(i => i.root),
+  ...layerDirs
+    .filter(i => normalize(i.root).includes('/node_modules/'))
+    .map(i => i.root),

---

681-687: Avoid recomputing layer dirs in the watch callback.
Reuse the existing layerDirs; compute relatives against those.

-    const layerRelativePaths = new Set(getLayerDirectories(nuxt).map(l => relative(l.app, path)))
+    const layerRelativePaths = new Set(layerDirs.map(l => relative(l.app, path)))

If desired, precompute once:

const layerApps = layerDirs.map(l => l.app)
// …
const layerRelativePaths = new Set(layerApps.map(app => relative(app, path)))

Also applies to: 690-695

packages/kit/src/layers.ts (2)

61-63: Confirm intended base for modules/public.
PR text says these are root-relative by default; code resolves from src. Please confirm and align.

Possible adjustment (if root-relative intended):

-      modules: withTrailingSlash(resolve(src, resolveAlias(config.dir?.modules || 'modules', nuxt.options.alias))),
-      public: withTrailingSlash(resolve(src, resolveAlias(config.dir?.public || 'public', nuxt.options.alias))),
+      modules: withTrailingSlash(resolve(root, resolveAlias(config.dir?.modules || 'modules', nuxt.options.alias))),
+      public: withTrailingSlash(resolve(root, resolveAlias(config.dir?.public || 'public', nuxt.options.alias))),

---

75-77: Prefer shared helper rather than custom withTrailingSlash.
Use ufo.withTrailingSlash for consistency and edge cases.

-function withTrailingSlash (dir: string) {
-  return dir.replace(/[^/]$/, '$&/')
-}
+// Prefer: import { withTrailingSlash } from 'ufo'

Add import:

import { withTrailingSlash } from 'ufo'

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.