…serialization (#565)

src/auth/nostr.js hashed JSON.stringify(request.body) — the parsed-
then-recompacted body — to check the NIP-98 `payload` tag. NIP-98
defines that tag as sha256 over the EXACT body bytes on the wire, so
any client sending pretty-printed (or differently-escaped / different
key-order) JSON 401'd with 'Payload hash mismatch' despite a valid
signature, URL, method, and timestamp. It silently forced every
NIP-98 client to send minified JSON in Node's exact serialization —
not a real spec requirement, and the bug only bit Nostr auth (DPoP
has no payload check), making valid signatures look broken.

Root cause: by the time the auth check runs, Fastify's default
application/json parser has already turned the body into an object —
the raw bytes are gone, so the re-serialization was the best the code
could do, and it only matched by coincidence when the client minified.

Fix (two halves):
  - server.js overrides the application/json content-type parser to
    capture the raw bytes as request.rawBody before parsing. It
    otherwise mirrors Fastify 4's defaultJsonParser exactly — empty
    body → 400, secure-json-parse (the SAME prototype-pollution
    protection JSS gets today; not plain JSON.parse), 400 on malformed
    — so no other request path changes. secure-json-parse promoted to
    a direct dependency for this.
  - nostr.js hashes request.rawBody when present, never a
    re-serialization. Other content types are unaffected: they stay
    Buffers via the '*' parser and already hashed raw bytes correctly;
    only application/json (parsed to an object) was broken.

Tests (test/nip98-payload-hash.test.js, 6):
  - parser: pretty JSON accepted, malformed → 400, __proto__ → 400 +
    Object.prototype not polluted (proves secure parsing preserved)
  - payload hash: a pretty body with rawBody passes AND resolves to
    the did:nostr identity; the same body WITHOUT rawBody still
    mismatches (control — proves rawBody is the fix); a compact body
    still verifies (no regression).

Full suite: 968/968 (the global JSON-parser override regressed nothing).

Closes #565.

…ing()

Copilot caught a real correctness bug in the pre-existing Buffer
branch: `request.body.toString()` UTF-8-decodes the bytes, which
mangles binary / non-UTF-8 bodies (an image PUT, etc.) — so the
server's hash wouldn't match the raw-byte sha256 a NIP-98 client
signed. crypto.update() accepts a Buffer directly, so we now pass the
Buffer through unconverted and only ever hash native forms (string →
UTF-8, Buffer → raw bytes).

New test: a deliberately non-UTF-8 Buffer body (with a sanity check
that it's genuinely lossy under a UTF-8 round-trip) verifies against
its raw-byte payload hash — would have failed under the old
.toString() path. 7/7 in the file; full suite green.

Copilot pass-2 (separate from the Buffer fix): the
`if (payloadTag && request.body)` guard skipped payload validation
when a JSON body parsed to a falsy value (null/false/0/""), so a
client could sign a payload tag, send a falsy body, and the integrity
check silently didn't run. Guard on `request.body !== undefined`
instead — Fastify leaves body undefined only when no body was sent —
so falsy-but-present bodies are still verified while genuinely
bodyless requests stay skipped.

New test: a `false` body with a WRONG payload tag is now rejected
(was skipped), and with the correct tag passes. 8/8 in file; full
suite green.

…JSON_BODY code

Copilot pass-3: the custom parser's empty-body 400 was a plain Error
with no err.code, but JSS's error handler emits code: err.code, so the
response shape drifted from Fastify's default (which uses
FST_ERR_CTP_EMPTY_JSON_BODY) — undercutting the 'mirrors the default
exactly' claim. Set err.code = 'FST_ERR_CTP_EMPTY_JSON_BODY' with the
same message/status. The malformed-JSON path already matched (Fastify
sets statusCode on the raw parser error without an FST code; so do we)
— documented that in a comment so it doesn't look like an oversight.

New test: an empty application/json body returns 400 with
code === 'FST_ERR_CTP_EMPTY_JSON_BODY'. 9/9 in file; full suite green.