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

124-127: Consider using undefined assignment instead of delete operator

The static analysis tool correctly flagged a potential performance issue with the delete operator. While functionally correct, this approach may impact performance.

-    if(!vite.rolldownVersion) {
-      // @ts-ignore Rolldown has no support for `output.manualChunks`
-      delete serverConfig.build.rollupOptions.output.manualChunks
-    }
+    if(!vite.rolldownVersion) {
+      // Rolldown has no support for `output.manualChunks`
+      serverConfig.build.rollupOptions.output.manualChunks = undefined
+    }

🧰 Tools

🪛 Biome (1.9.4)

[error] 126-126: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

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

50-76: Potential accumulation of identical hooks

addComponents() registers a new components:extend hook every time it is called.
If an extension repeatedly calls addComponent/addComponentExports in a loop, dozens of identical hooks will be attached, slightly degrading performance and making stack‑traces noisy.

Consider caching the list of addedComponents per‑Nuxt‑instance (e.g. with a WeakMap) and registering only a single hook that merges all queued components.

packages/kit/test/components.spec.ts (1)

25-38: Great test coverage – one tiny robustness improvement

The test thoroughly exercises the new helper.
You might additionally assert the component count to make the intention explicit and guard against regressions where extra exports are accidentally picked up:

-    expect(components).toMatchInlineSnapshot(`
+    expect(components).toHaveLength(2)
+    expect(components).toMatchInlineSnapshot(`

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

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

124-127: Consider using assignment instead of delete operator

The conditional check for Rolldown is correctly implemented. However, the static analysis tool suggests avoiding the delete operator for performance reasons.

if(!vite.rolldownVersion) {
  // @ts-ignore Rolldown has no support for `output.manualChunks`
-  delete serverConfig.build.rollupOptions.output.manualChunks
+  serverConfig.build.rollupOptions.output.manualChunks = undefined
}

🧰 Tools

🪛 Biome (1.9.4)

[error] 126-126: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

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

123-126: Improve performance by avoiding the delete operator

Using the delete operator can impact performance. Instead of deleting the property, consider assigning undefined for better performance while achieving the same effect.

if(!vite.rolldownVersion) {
  // @ts-ignore Rolldown has no support for `output.manualChunks`
-  delete serverConfig.build.rollupOptions.output.manualChunks
+  serverConfig.build.rollupOptions.output.manualChunks = undefined
}

The type safety issue with rolldownVersion also exists here and should be addressed.

🧰 Tools

🪛 Biome (1.9.4)

[error] 125-125: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

🪛 GitHub Check: build

[failure] 123-123:
Property 'rolldownVersion' does not exist on type 'typeof import("/home/runner/work/nuxt/nuxt/node_modules/.pnpm/vite@6.3.0_@types+node@22.14.1_jiti@2.4.2_sass@1.78.0_terser@5.32.0_tsx@4.19.2_yaml@2.7.1/node_modules/vite/dist/node/index")'. Did you mean 'rollupVersion'?

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

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

93-101: Good addition of Rolldown compatibility checks

The conditional application of Rollup options when not using Rolldown is well-implemented. This correctly avoids using unsupported options like preserveModules and generatedCode with Rolldown.

However, there's a type safety issue with vite.rolldownVersion since this property isn't defined in Vite's type definitions.

Consider adding a proper type definition rather than using @ts-ignore for improved type safety and code maintainability. You could create or extend type definitions in a .d.ts file:

declare module 'vite' {
  interface ViteDevServer {
    rolldownVersion?: string
  }
}

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

124-128: Consider an alternative to the delete operator

The conditional deletion of manualChunks is correctly implemented to ensure compatibility with Rolldown. However, using the delete operator can have a minor performance impact.

Consider using an assignment to undefined instead, which accomplishes the same goal with slightly better performance:

- delete serverConfig.build.rollupOptions.output.manualChunks
+ serverConfig.build.rollupOptions.output.manualChunks = undefined

🧰 Tools

🪛 Biome (1.9.4)

[error] 127-127: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

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

124-133: Conditional chunk configuration based on bundler type

The code handles different chunk configurations based on the bundler:

• For Rollup (non-Rolldown): Delete manualChunks
• For Rolldown: Delete advancedChunks instead

The TypeScript suppression is appropriate since rolldownVersion and advancedChunks aren't in standard type definitions.

Consider using property assignment to undefined instead of the delete operator for better performance:

-      delete serverConfig.build.rollupOptions.output.manualChunks
+      serverConfig.build.rollupOptions.output.manualChunks = undefined

-      delete serverConfig.build.rollupOptions.output.advancedChunks
+      serverConfig.build.rollupOptions.output.advancedChunks = undefined

🧰 Tools

🪛 Biome (1.9.4)

[error] 127-127: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

---

[error] 131-131: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.734Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.734Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.734Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.734Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

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

127-137: Good handling of chunk configuration between Rollup and Rolldown

The conditional logic correctly handles the different chunking capabilities between Rollup and Rolldown, removing the appropriate properties based on which bundler is in use.

However, the delete operator usage flagged by static analysis could be replaced with undefined assignments for better performance:

- delete serverConfig.build.rollupOptions.output.manualChunks
+ serverConfig.build.rollupOptions.output.manualChunks = undefined

and

- delete serverConfig.build.rollupOptions.output.advancedChunks
+ serverConfig.build.rollupOptions.output.advancedChunks = undefined

🧰 Tools

🪛 Biome (1.9.4)

[error] 131-131: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

---

[error] 136-136: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.734Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.734Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

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

126-136: Proper handling of chunking options for Rollup/Rolldown compatibility

Good implementation of the conditional logic to handle different chunking behaviors between Rollup and Rolldown. One minor improvement would be to replace the delete operator with undefined assignments for better performance, as flagged by static analysis.

-      delete serverConfig.build.rollupOptions.output.manualChunks
+      serverConfig.build.rollupOptions.output.manualChunks = undefined

-      delete serverConfig.build.rollupOptions.output.advancedChunks
+      serverConfig.build.rollupOptions.output.advancedChunks = undefined

🧰 Tools

🪛 Biome (1.9.4)

[error] 130-130: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

---

[error] 135-135: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

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

101-102: Document rolldown-vite watch mode limitations

The TODO comment is correct but could be more informative about the current limitations.

Consider expanding the TODO comment to provide more context:

-                  // TODO: Find equivalent for rolldown-vite here
+                  // TODO: Watch mode for the `build` command is not implemented in rolldown-vite yet

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

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

93-136: 🛠️ Refactor suggestion

Document the Rolldown compatibility status and limitations

The code adds conditional handling for Rolldown compatibility, but lacks comprehensive documentation about the current state of Rolldown support and its limitations.

Add a descriptive comment at the top of this section to clarify:

1. That this is experimental support for Rolldown
2. What features are working vs. not working
3. Any known issues or compatibility concerns

For example:

// Experimental Rolldown support
// Current limitations:
// - No support for generatedCode options
// - Different chunking mechanism (advancedChunks vs manualChunks)
// - See https://github.com/rolldown/rolldown/issues/206 for more details

This will help future maintainers understand the reasoning behind these conditional checks.

🧰 Tools

🪛 Biome (1.9.4)

[error] 130-130: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

---

[error] 135-135: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

packages/vite/src/server.ts (3)

93-103: Improve type safety for Rolldown detection

The conditional handling for Rolldown vs. Rollup is implemented correctly, but the use of @ts-ignore creates technical debt. Since this is an experimental feature that will likely remain, it would be better to properly type the rolldownVersion property.

Consider creating proper type declarations for Rolldown-specific properties as suggested in previous reviews. This will provide better type safety and improve maintainability:

- // eslint-disable-next-line @typescript-eslint/ban-ts-comment
- // @ts-ignore Rolldown-Vite specific - https://github.com/rolldown/rolldown/issues/206
- ...vite.rolldownVersion
+ ...(vite as any).rolldownVersion

Or better yet, create a type declaration file to properly extend Vite's types.

---

128-136: Refactor delete operations to use undefined assignment

The use of the delete operator can impact runtime performance as flagged by static analysis. While the performance impact is likely minimal in this build-time code, it's still good practice to follow recommended patterns.

Consider using undefined assignment instead of delete operations:

- // If Rolldown is used, remove all chunk settings (mirror behavior for rollup for now)
- // eslint-disable-next-line @typescript-eslint/ban-ts-comment
- // @ts-ignore Rolldown-only option
- delete serverConfig.build.rollupOptions.output.advancedChunks
+ // If Rolldown is used, remove all chunk settings (mirror behavior for rollup for now)
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+ // @ts-ignore Rolldown-only option
+ serverConfig.build.rollupOptions.output.advancedChunks = undefined

And similarly for the manualChunks deletion.

🧰 Tools

🪛 Biome (1.9.4)

[error] 130-130: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

---

[error] 135-135: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

---

93-97: Consider using a constant or utility function for Rolldown detection

The check for vite.rolldownVersion is used multiple times and might be needed in other files as well. This could lead to inconsistent detection or repetition.

Extract the Rolldown detection logic into a utility function:

+ /**
+  * Determines if the current Vite instance is using Rolldown
+  */
+ function isUsingRolldown(vite: any): boolean {
+   return !!vite.rolldownVersion
+ }

// Then use it in your conditional logic:
- ...vite.rolldownVersion
+ ...isUsingRolldown(vite)
-    ? {}
+    ? {}

This would centralise the detection logic, making it easier to maintain and adapt if the detection method changes in future.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

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

58-65: Handle esbuild configuration for rolldown-vite

The code correctly removes esbuild configuration when rolldown-vite is detected, as esbuild options aren't needed in rolldown-vite environments. However, there's a performance concern with using the delete operator.

Consider using nullish assignment instead of delete for better performance:

if (vite.rolldownVersion) {
-  if (viteConfig.esbuild) {
-    delete viteConfig.esbuild
-  }
-  if (viteConfig.optimizeDeps?.esbuildOptions) {
-    delete viteConfig.optimizeDeps.esbuildOptions
-  }
+  if (viteConfig.esbuild) {
+    viteConfig.esbuild = undefined
+  }
+  if (viteConfig.optimizeDeps?.esbuildOptions) {
+    viteConfig.optimizeDeps.esbuildOptions = undefined
+  }
}

🧰 Tools

🪛 Biome (1.9.4)

[error] 60-60: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

---

[error] 63-63: Avoid the delete operator which can impact performance.

Unsafe fix: Use an undefined assignment instead.

(lint/performance/noDelete)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

packages/nuxt/test/component-loader.test.ts (1)

215-220: Same here: cast Vue plugins instead of using @ts-ignore

Reuse the casting approach to avoid suppressions and keep typings intact.

Diff within the selected lines:

-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore Rolldown-vite type error
-      vuePlugin(),
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore Rolldown-vite type error
-      vuePluginJsx(),
+      vuePlugin() as unknown as RollupPlugin,
+      vuePluginJsx() as unknown as RollupPlugin,

Ensure this file also imports:

import type { Plugin as RollupPlugin } from 'rollup'

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

30-32: Remove suppression and cast the visualizer to a Vite Plugin

The TS ignore is brittle. Cast the Rollup plugin to Vite’s Plugin (structurally compatible) and drop the suppression.

Apply this diff:

-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore Rolldown-vite type error
-    visualizer({
+    visualizer({
       ...analyzeOptions,
       filename: 'filename' in analyzeOptions ? analyzeOptions.filename!.replace('{name}', 'client') : undefined,
       title: 'Client bundle stats',
       gzipSize: true,
       brotliSize: true,
-    }),
+    }) as unknown as Plugin,

Alternatively (cleaner), inject it via the plugin’s config hook under build.rollupOptions.plugins to avoid any casts:

{
  name: 'nuxt:analyze-visualizer',
  config() {
    return {
      build: {
        rollupOptions: {
          plugins: [visualizer({ ...analyzeOptions, filename: 'filename' in analyzeOptions ? analyzeOptions.filename!.replace('{name}', 'client') : undefined, title: 'Client bundle stats', gzipSize: true, brotliSize: true })]
        }
      }
    }
  }
}

packages/nuxt/test/lazy-hydration-macro-transform.test.ts (1)

167-172: Prefer typed interop over blanket @ts-ignore for Vue plugins

Suppressing types is fine short-term, but you can keep tests type-safe without ignores by casting the Vue plugins to Rollup’s Plugin interface.

Apply this diff locally within the selected lines:

-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore Rolldown-vite type error
-      vuePlugin(),
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore Rolldown-vite type error
-      vuePluginJsx(),
+      vuePlugin() as unknown as RollupPlugin,
+      vuePluginJsx() as unknown as RollupPlugin,

And add this import near the top (outside the selected lines):

import type { Plugin as RollupPlugin } from 'rollup'

This removes the need for TS/ESLint suppressions while maintaining correct runtime 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: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

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: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

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

56-66: Use @ts-expect-error (not @ts-ignore) for intentional rolldown detection

The use of vite.rolldownVersion is intentional (per team learnings), but prefer @ts-expect-error so the suppression is revisited when types catch up. Keep the one-line ESLint disable if needed.

-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore Rolldown-check
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error - rolldownVersion exists at runtime when using rolldown-vite but is not in types yet
   if (vite.rolldownVersion) {
     // Delete unused esbuild settings
     if (viteConfig.esbuild) {
       delete viteConfig.esbuild
     }
     if (viteConfig.optimizeDeps?.esbuildOptions) {
       delete viteConfig.optimizeDeps.esbuildOptions
     }
   }

---

132-144: Consistent TS suppression and minor watch note

• Align with the earlier comment: use @ts-expect-error instead of @ts-ignore.
• Note: rolldown’s build watch is not fully implemented yet; this conditional shape is fine for now.

-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore Rolldown-check
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-expect-error - rolldownVersion exists at runtime when using rolldown-vite but is not in types yet
           watch: (vite.rolldownVersion
             ? {
               // TODO: https://github.com/rolldown/rolldown/issues/5799 for ignored fn
               exclude: [...nuxt.options.ignore, /[\\/]node_modules[\\/]/],
             }
             : {
               chokidar: { ...nuxt.options.watchers.chokidar, ignored: [isIgnored, /[\\/]node_modules[\\/]/] },
               exclude: nuxt.options.ignore,
             }
           ),

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: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

Learnt from: TheAlexLichter
PR: nuxt/nuxt#31812
File: packages/nuxt/src/components/plugins/islands-transform.ts:202-202
Timestamp: 2025-04-18T18:33:41.753Z
Learning: In Nuxt, using `rolldownVersion` (not `rollupVersion`) is intentional when detecting if rolldown-vite is being used, even though TypeScript may show an error because the property isn't in standard type definitions yet.

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.