Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/nuxt/src/app/nuxt.ts`:
- Around line 390-392: The current replacement of nuxtApp.hooks.callHook wraps
the call synchronously using Promise.resolve(_callHook(name, ...args)) which
still allows synchronous throws to escape; update the override so it defers
execution into the microtask queue (e.g., use Promise.resolve().then(() =>
_callHook(name, ...args))) thereby ensuring any synchronous exceptions from
_callHook(name, ...args) are converted into rejected promises; modify the
assignment that references _callHook and asyncCallHook accordingly.

In `@packages/nuxt/src/core/nuxt.ts`:
- Around line 62-68: When options.experimental.asyncCallHook is true the current
use of Promise.resolve(runWithNuxtContext(...)) can create a Promise with a void
union and also lets synchronous errors escape, so change both assignments to
create the Promise first and defer invocation using Promise.resolve().then(() =>
runWithNuxtContext(...callHook...)). For callHookParallel ensure the resolved
value is narrowed to Promise<any[]> by using the nullish-coalescing fallback
(callHookParallel(...) ?? []) inside the .then to handle no-hook cases. Update
hooks.callHook and hooks.callHookParallel to use Promise.resolve().then(...)
with runWithNuxtContext and apply ?? [] for callHookParallel.

---

Outside diff comments:
In `@packages/nuxt/src/app/nuxt.ts`:
- Around line 381-389: The server branch uses an async contextCaller which
forces Promise returns and breaks compat-v5 sync-hook mode; replace it with two
variants and choose based on experimental.asyncCallHook: keep the existing async
function (contextCallerAsync) that awaits each hook for async mode, and add a
synchronous contextCallerSync that calls each hook inside nuxtApp.runWithContext
without using await (e.g., for (const hook of hooks) hook(...args)), then set
nuxtApp.hooks.callHook to use callHookWith(contextCallerSync, ...) when
nuxtApp.options.experimental.asyncCallHook is false and to use the async variant
otherwise, referencing contextCaller (or named variants),
nuxtApp.hooks.callHook, and nuxtApp.hooks.callHookWith so the server preserves
synchronous execution when requested.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/nuxt/src/app/nuxt.ts`:
- Line 389: The hook wrapper passes the entire args array as a single argument
to callHookWith, causing nested arrays; update nuxtApp.hooks.callHook so it
forwards arguments using the spread operator to callHookWith (i.e.,
callHookWith(contextCaller, name, ...args)) so that callHookWith and
contextCaller receive individual variadic args rather than a single array;
modify the line assigning nuxtApp.hooks.callHook to use ...args and keep the
existing contextCaller and name parameters unchanged.

In `@packages/nuxt/src/core/nuxt.ts`:
- Line 80: The hook registration currently invokes nuxt.close() without awaiting
its Promise; update the hook callback in builder code that calls
nuxt.hook('prepare:types', ...) so it either returns the Promise or is declared
async and awaits nuxt.close() to ensure the 'close' hook completes; reference
the close method on the nuxt object and the nuxt.hook('prepare:types', ...)
registration when applying the change.