packages/nuxt/src/components/templates.ts (1)

124-135: Minor: tighten LazyComponent generic constraint.
Constraining T to DefineComponent improves inference and prevents accidental widening when T is not a component type.

-type LazyComponent<T> = (T & DefineComponent<HydrationStrategies, {}, {}, {}, {}, {}, {}, { hydrated: () => void }>)
+type LazyComponent<T extends DefineComponent> = (T & DefineComponent<HydrationStrategies, {}, {}, {}, {}, {}, {}, { hydrated: () => void }>)

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

8-42: Great end-to-end coverage for the reported regression; consider adding a multi-template and shared-context case.

• This test proves globalTypeFiles exposure for a single addTypeTemplate call. The common real-world case is multiple calls (from Nuxt core + modules) and shared-context templates.

You can extend the spec with an additional test to catch array-merging regressions and shared exposure:

 describe('addTypeTemplate', () => {
   it('should add type templates to vue global files', async () => {
@@
     await nuxt.close()
   })
+
+  it('should merge multiple global type files and support shared context', async () => {
+    const repoRoot = await findWorkspaceDir()
+    const rootDir = resolve(repoRoot, 'node_modules/.fixture', randomUUID())
+    await mkdir(rootDir, { recursive: true })
+    await writeFile(resolve(rootDir, 'app.vue'), `
+      <script setup lang="ts">
+      defineProps<FooProps>()
+      defineProps<BarProps>()
+      </script>
+      <template><div /></template>
+    `)
+    const nuxt = await loadNuxt({
+      cwd: rootDir,
+      overrides: {
+        modules: [
+          () => addTypeTemplate({
+            filename: 'foo.d.ts',
+            getContents: () => `
+              declare global { type FooProps = { a?: number } }
+              export {};
+            `,
+          }),
+          () => addTypeTemplate({
+            filename: 'bar.d.ts',
+            getContents: () => `
+              declare global { type BarProps = { b?: string } }
+              export {};
+            `,
+          }, { shared: true }),
+        ],
+      },
+    })
+    await expect(buildNuxt(nuxt)).resolves.not.toThrow()
+    await nuxt.close()
+  })
 })

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 **/*.vue : Use `<script setup lang="ts">` and the composition API when creating Vue components

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: 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/components/templates.ts (3)

4-4: Type-only import is correct and avoids runtime bundling.
Importing Nuxt types as type-only keeps the generated bundles clean.

---

154-174: Vue GlobalComponents augmentation looks good.

• Module augmentation is scoped and ends with export {} to keep it as a module.
• Mapping includes Lazy variants with LazyComponent.

---

135-153: Runtime export confirmed for componentNames
The componentNamesTemplate in packages/nuxt/src/components/templates.ts generates component-names.mjs with

export const componentNames = [ /* … */ ]

ensuring a runtime module exports componentNames.

The transform plugin in packages/nuxt/src/components/plugins/transform.ts injects this via Unimport’s virtual module #components, mapping

name: 'componentNames',
from: '#build/component-names',
virtualImports: ['#components']

so that any

import { componentNames } from '#components'

is rewritten to pull from component-names.mjs. No further changes are needed.

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

9-9: Importing componentsDeclarationTemplate is consistent with the new two-template split.
Keeps declarations and Vue augmentation concerns separated.

---

131-133: Order of template registration is sensible; one note on references.

• components.d.ts is added via addTemplate (written to disk) and is resolved by the #components path mapping (set later in prepare:types), so it does not need an explicit reference entry.
• types/components.d.ts uses addTypeTemplate so it’s referenced and participates in TS global augmentation. LGTM.

If you want extra safety, add an assertion in a unit test that importing from '#components' resolves types (e.g. a small TS program that imports a known component symbol and checks its type).

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

80-95: Retaining prepare:types references preserves editor TS awareness.
Good that references are still pushed for nuxt/node/shared contexts; this maintains compatibility with tooling that relies on TS triple-slash references.