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

59-59:Attach module context to async dependency failures and prefer nullish coalescing

The await is correct. For clearer semantics and better diagnostics, catch errors here and use?? {} instead of|| {}.

Apply:

-    const dependencyMeta = await res.nuxtModule.getModuleDependencies?.(nuxt) || {}+    let dependencyMeta = {}+    try {+      dependencyMeta = await res.nuxtModule.getModuleDependencies?.(nuxt) ?? {}+    } catch (e) {+      const which = typeof key === 'string' ? `\`${key}\`` : 'an inline module'+      throw new TypeError(`Error resolving moduleDependencies for ${which}: ${e instanceof Error ? e.message : String(e)}`)+    }

docs/2.guide/3.going-further/3.modules.md (1)

549-573:Good example; add a short caveat about heavy I/O

The sample is clear. Consider a one‑line note that heavy I/O inmoduleDependencies delays start‑up and should be deferred to hooks when possible, to align with the “Async Modules” guidance below.

packages/kit/test/module.test.ts (1)

138-157:Add coverage for async optional and async overrides/defaults

To harden the contract, include:

• Async dependency returning{ optional: true } → not installed.
• Async dependency that returnsoverrides/defaults → merged as in sync path.

Example additions:

+  it('should honour optional when provided asynchronously', async () => {+    nuxt = await loadNuxt({+      cwd: tempDir,+      overrides: {+        modules: [+          defineNuxtModule({+            meta: { name: 'foo' },+            async moduleDependencies () {+              await Promise.resolve()+              return { 'some-module': { optional: true } }+            },+          }),+        ],+      },+    })+    expect(globalThis.someModuleLoaded).toBeUndefined()+  })++  it('should merge overrides/defaults from async dependencies', async () => {+    nuxt = await loadNuxt({+      cwd: tempDir,+      overrides: {+        // @ts-expect-error test-only option+        a: { user: 'provided by user' },+        modules: [+          defineNuxtModule({+            meta: { name: 'a' },+            defaults: { value: 'provided by a' },+            setup (options) {+              expect(options.value).toBe('provided by c')+              expect(options.user).toBe('provided by user')+            },+          }),+          defineNuxtModule({+            meta: { name: 'c' },+            async moduleDependencies () {+              await Promise.resolve()+              return {+                a: {+                  overrides: { value: 'provided by c' },+                  defaults: { user: 'provided by c' },+                },+              }+            },+          }),+        ],+      },+    })+  })

packages/schema/src/types/module.ts (2)

87-87:Tighten union: avoid duplication

You can simplify to a single async-capable function type.

Apply:

-  moduleDependencies?: ModuleDependencies | ((nuxt: Nuxt) => ModuleDependencies) | ((nuxt: Nuxt) => Awaitable<ModuleDependencies>)+  moduleDependencies?: ModuleDependencies | ((nuxt: Nuxt) => Awaitable<ModuleDependencies>)

---

119-119:Return type simplification

PreferAwaitable<ModuleDependencies | undefined> for readability.

Apply:

-  getModuleDependencies?: (nuxt: Nuxt) => Awaitable<ModuleDependencies> | ModuleDependencies | undefined+  getModuleDependencies?: (nuxt: Nuxt) => Awaitable<ModuleDependencies | undefined>

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro