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 in moduleDependencies 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 returns overrides/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

Prefer Awaitable<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