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

Inline comments:
In `@docs/1.getting-started/18.upgrade.md`:
- Around line 347-349: The note about getRouteRules() is ambiguous; update the
documentation to explicitly reference the Nitro helper import (e.g., from
"nitro/app") and clarify the new server signature and return shape: state that
getRouteRules(method, pathname) is the Nitro server helper (not the Nuxt
composable) and that it returns an object containing { routeRules } instead of
the older getRouteRules(event) form; ensure the text mentions the import source
"nitro/app" and contrasts it with the Nuxt composable that accepts an event.

In `@docs/2.directory-structure/1.server.md`:
- Line 22: Replace the redundant phrasing in the sentence "The handler can
directly return JSON data, a `Promise`, or return a `Response` object." with the
tightened wording "The handler can directly return JSON data, a `Promise`, or a
`Response` object." by removing the duplicated verb; update the line in
docs/2.directory-structure/1.server.md where the handler return types are listed
(the sentence starting "The handler can directly return...") to the new
phrasing.
- Line 25: The page mixes imports from 'nitro/h3' and 'h3' (e.g., the import
using defineEventHandler), causing conflicting guidance; pick the intended
canonical import path (likely 'nitro/h3') and update all snippets that import
from 'h3' to import from the chosen path so every example uses the same module
name and the same defineEventHandler import form across the document.

In `@packages/nitro-server/src/runtime/handlers/error.ts`:
- Around line 103-107: The merge at the end re-injects raw res.headers and
event.res.headers (via setCookies + mergeHeaders) which can restore stale
content-type or content-security-policy; update the merge to first filter those
headers out (e.g. implement a small filterErrorPageHeaders that copies all
header entries except 'content-type' and 'content-security-policy') and pass the
filtered Headers into mergeHeaders instead of using res.headers or (event as
H3Event).res.headers directly; ensure setCookies handling remains unchanged and
reference the existing setCookies, mergeHeaders, headers, res.headers and
event/H3Event symbols when making the change.
- Around line 39-42: The code assigns errorObject.data using the `||=` operator
which will overwrite valid falsy values; update the assignment in the error
handler so that errorObject.data uses the nullish assignment operator (`??=`)
instead of `||=` to only replace when `errorObject.data` is null or undefined
(locate the block that creates `const errorObject = (defaultRes.body || {})
...`, the line `errorObject.data ||= error.data`, and change it to use `??=`),
leaving the subsequent `errorObject.url = event.req.url` unchanged.

In `@packages/nitro-server/src/runtime/handlers/island.ts`:
- Around line 24-25: Replace the two-step cache check (import.meta.prerender &&
await islandCache!.hasItem(islandPath) followed by
islandCache!.getItem(islandPath)) with a single await
islandCache!.getItem(islandPath) call and null/undefined check so we avoid the
TOCTOU and double I/O; when returning the cached value, use the actual stored
type (NuxtIslandResponse) instead of casting to Partial<RenderResponse> and
propagate that correct type back to the caller (update the same pattern found
around the other occurrences that use hasItem/getItem at the referenced spots),
ensuring you reference islandCache, islandPath, getItem, hasItem,
NuxtIslandResponse and RenderResponse while making the type consistent.
- Around line 136-141: The returned island context currently sets props to
destr(context?.props) || {}, which can allow non-object truthy values (e.g.,
true, [], "x") through; change this to normalize/clamp props to a plain object:
call destr(context?.props) into a temporary (e.g., rawProps), then if rawProps
is a non-null object and not an Array use it, otherwise use {}; update the
returned props field to that sanitized object. Reference variables/functions:
destr, context?.props, and the returned props field in island.ts.

In `@test/basic.test.ts`:
- Around line 1214-1218: The test currently asserts the new error shape
(message, status, statusText) but doesn't ensure deprecated aliases are removed;
update the assertions in the blocks around the existing
expect(error).not.toHaveProperty('url') checks to also assert the deprecated
fields are absent by adding negative assertions for 'statusCode' and
'statusMessage' (and mirror the same additions in the other affected block
around lines 1236-1242) so the test fails if old aliases are still serialized.

---

Outside diff comments:
In `@docs/2.directory-structure/1.server.md`:
- Around line 325-352: The note is misleading about passing the event to
useRuntimeConfig; update the docs around the example (the defineEventHandler
block and the useRuntimeConfig call) to remove or rewrite the statement that
"Giving the `event` as argument to `useRuntimeConfig` is recommended" — instead
state that useRuntimeConfig should be called without arguments
(useRuntimeConfig()) because the implementation no longer accepts/uses an event
parameter and environment-variable overrides are applied automatically at
runtime; reference the example's defineEventHandler and useRuntimeConfig symbols
so the change is made next to that snippet.

---

Duplicate comments:
In `@packages/nitro-server/src/runtime/utils/cache-driver.js`:
- Around line 34-35: The getItem implementation in function getItem currently
treats falsy cached values as misses by using "||" between lru.getItem and
fs.getItem; change the logic to call lru.getItem(key, opts) and check explicitly
for undefined (not falsy) before falling back to fs.getItem(normalizeFsKey(key),
opts) so values like 0, '', and false are returned from the LRU without hitting
disk; update references in getItem to use the explicit undefined check with lru
and fs and preserve existing normalizeFsKey usage.

In `@packages/nitro-server/src/runtime/utils/error.ts`:
- Around line 13-20: The code uses new FastURL(event.req.url).pathname (stored
in pathname) which reflects the raw URL and fails when a non-root app.baseURL is
in effect; change the /api/ detection to use the normalised request path
produced by the base-url middleware (or explicitly strip the app baseURL from
event.req.url) before evaluating pathname so pathname.startsWith('/api/') and
pathname.endsWith('.json') run against the normalized path; update the logic in
error helper (where FastURL and hasReqHeader are used) to derive pathname from
the normalised path/context provided by the middleware rather than the raw
event.req.url.

---

Nitpick comments:
In `@test/basic.test.ts`:
- Line 2308: Replace the bare TODO comment "// TODO: document as breaking
change" in test/basic.test.ts with an actionable item: either remove the TODO if
the breaking change is already documented, or replace it with a one-line link to
the exact upgrade note or a created follow-up issue (include the issue
number/URL) and a short rationale; ensure the comment references the exact
change it concerns so future readers can find the upgrade guidance.

In `@test/bundle.test.ts`:
- Around line 72-74: Extract the repeated normalisation into a small helper
(e.g. normalizePackageName) inside the test file and replace the inline map
logic in the three places (the packages = modules.files map at lines around the
three occurrences) to call that helper; the helper should take a filename
string, strip the leading "_libs/" and remove a trailing ".mjs" (using the same
replace calls currently used) and return the normalized package name so all
three server-bundle test cases share the same normalization logic.
- Around line 66-70: Replace the implicit exclusion pattern '!_libs' with an
explicit descendant exclusion '!_libs/**' in the analyzeSizes calls (e.g., where
analyzeSizes([...], serverDir) is invoked to compute serverStats and modules);
update all occurrences referenced in this test (the calls around serverStats and
modules) so the glob intentionally excludes the _libs directory and its children
by using '!_libs/**' to make the intent clear and robust against glob library
changes.

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

Duplicate comments:
In `@packages/nuxt/test/nitro/render-index.ts`:
- Around line 8-16: The top-level promise from renderIndex() can produce
unhandled rejections when nitroApp.fetch(...) fails or when the `if (!res.ok)`
branch throws; append a final `.catch(...)` to the call to renderIndex() to
handle all rejections, read the response body via `res.text()` (or the caught
error's response if available) and include that body text in the thrown/logged
error so failed renders surface clear diagnostics; modify the call site where
`renderIndex()` is invoked to attach `.catch(err => { /* include await
res.text() when present and rethrow or console.error with body */ })` and ensure
any asynchronous reading of `res.text()` is awaited inside the catch before
reporting.