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

13-13: Type narrowing looks good; consider normalising id earlier for consistency.

The switch to Pick<Unimport, 'injectImports'> is sound and tightens the surface area. One small consistency win: normalise id in transformInclude before running include/exclude regexes (you already normalise in transform). This avoids platform-specific path mismatches.

Apply:

 export const TransformPlugin = ({ ctx, options, sourcemap }: { ctx: Pick<Unimport, 'injectImports'>, options: Partial<ImportsOptions>, sourcemap?: boolean }) => createUnplugin(() => {
   return {
     name: 'nuxt:imports-transform',
     enforce: 'post',
     transformInclude (id) {
+      id = normalize(id)
       // Included
       if (options.transform?.include?.some(pattern => pattern.test(id))) {
         return true
       }
       // Excluded
       if (options.transform?.exclude?.some(pattern => pattern.test(id))) {
         return false
       }

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

74-77: Deferring imports:dirs and path normalisation is correct; also normalise the watcher path.

You normalise composablesDirs on modules:done. For symmetric comparisons in the watcher, normalise path too to avoid separator issues on Windows.

Apply:

-        const path = resolve(nuxt.options.srcDir, relativePath)
+        const path = normalize(resolve(nuxt.options.srcDir, relativePath))

---

91-116: Initialising ctx on modules:done — please verify no early access; optional hardening with a ctxReady gate.

Everything that uses ctx appears to execute after modules:done, but there’s an implicit ordering assumption (e.g. template getters and the transform plugin wrapper). To be belt-and-braces, gate access behind a promise so accidental early calls don’t throw if ordering changes.

Minimal hardening:

-    let ctx: Unimport
+    let ctx: Unimport
+    let resolveCtx!: (u: Unimport) => void
+    const ctxReady = new Promise<Unimport>(r => { resolveCtx = r })

     // initialise unimport only after all modules
     // have had a chance to register their hooks
     nuxt.hook('modules:done', async () => {
       await nuxt.callHook('imports:sources', presets)

       const { addons: inlineAddons, ...rest } = options
       const [addons, addonsOptions] = Array.isArray(inlineAddons) ? [inlineAddons] : [[], inlineAddons]

       // Create a context to share state between module internals
       ctx = createUnimport({
         injectAtEnd: true,
         ...rest,
         addons: {
           addons,
           vueTemplate: options.autoImport,
           vueDirectives: options.autoImport === false ? undefined : true,
           ...addonsOptions,
         },
         presets,
       })

       await nuxt.callHook('imports:context', ctx)
+      resolveCtx(ctx)
     })

And adapt the two main access sites:

-    addTemplate({
+    addTemplate({
       filename: 'imports.mjs',
-      getContents: async () => toExports(await ctx.getImports()) + '\nif (import.meta.dev) { console.warn("[nuxt] `#imports` should be transformed with real imports. There seems to be something wrong with the imports plugin.") }',
+      getContents: async () => {
+        const i = await ctxReady
+        return toExports(await i.getImports()) + '\nif (import.meta.dev) { console.warn("[nuxt] `#imports` should be transformed with real imports. There seems to be something wrong with the imports plugin.") }'
+      },
     })

-    addBuildPlugin(TransformPlugin({
-      ctx: { injectImports: (code, id, options) => ctx.injectImports(code, id, options) },
+    addBuildPlugin(TransformPlugin({
+      ctx: { injectImports: async (code, id, options) => (await ctxReady).injectImports(code, id, options) },
       options, sourcemap: !!nuxt.options.sourcemap.server || !!nuxt.options.sourcemap.client,
     }))

Optionally, mirror this pattern for addDeclarationTemplates wrappers for complete consistency.

---

139-140: Compute nuxtImports after imports:sources mutates presets.

presets can be extended in imports:sources. Computing nuxtImports before that may miss newly contributed internal imports, weakening the override warning.

Apply:

-    const nuxtImportSources = new Set(allNuxtPresets.flatMap(i => i.from))
-    const nuxtImports = new Set(presets.flatMap(p => nuxtImportSources.has(p.from) ? p.imports : []))
+    const nuxtImportSources = new Set(allNuxtPresets.flatMap(i => i.from))
+    let nuxtImports = new Set<string>()

Then after await nuxt.callHook('imports:sources', presets):

+      // Recompute internal-import names after sources have been extended
+      nuxtImports = new Set(presets.flatMap(p => nuxtImportSources.has(p.from) ? p.imports : []))

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro