@rshono/core 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/runtime/context.js

@@ -1,51 +1,59 @@
+// `__RSHONO_CONFIG__` is a global const, and an `import` cannot bring one into scope — a path reference is
+// the only way to reach it, which is the whole reason that file is separate. See its header.
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
 /// <reference path="../types/rshono-config.d.ts" />
 /**
- * The request context: {@link getContext} and the {@link Ctx} wrapper it returns,
- * the {@link redirect} / {@link notFound} control-flow helpers, and the
- * {@link onServerError} reporting funnel — plus the `@internal` plumbing that binds
- * a request to the async context in the first place.
- *
- * The public half of this module is re-exported by `runtime/server.ts`, which is
- * what the `@rshono/core/server` subpath resolves to; import *that* from an app. Nothing
- * here is safe in a `'use client'` module — those run in the browser, with no bound
- * request context.
+ * The request context: {@link getRequestContext} and the {@link RequestContext} it returns, the
+ * {@link redirect} / {@link notFound} control-flow helpers, and the {@link onServerError} reporting
+ * funnel — plus the `@internal` plumbing that binds a request to the async context.
+ *
+ * The public half is re-exported by `runtime/server.ts`, which is what `@rshono/core/server` resolves
+ * to; an app imports that.
  */
 import { deleteCookie, getCookie, setCookie } from 'hono/cookie';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { NotFoundSignal, RedirectSignal } from './control.js';
 const contextStorage = new AsyncLocalStorage();
-/** One {@link Ctx} per Hono {@link Context}, so repeated `getContext()` calls in a request share its lazy getters. */
+/** One {@link RequestContext} per Hono {@link Context}, so repeated `getRequestContext()` calls share its lazy getters. */
 const wrappers = new WeakMap();
+// Keyed on the Hono context rather than held as a field, so marking a request never forces the lazily
+// built `RequestContext` wrapper into existence.
+const rendering = new WeakSet();
 /**
- * `process.env`, snapshotted on first read.
+ * Marks the request as having entered its page render, which is what makes
+ * {@link RequestContext.setHeader} and `ctx.cookies.set()` start throwing.
  *
- * It is not a plain object — every enumeration crosses into the host environment, which made
- * spreading it (~20µs) by far the most expensive thing {@link Ctx.env} did, once per request that
- * touched it. Snapshotted lazily rather than at module load because `loadEnvFiles()` runs *after*
- * this module is imported, so an eager copy would miss everything from `.env`. The trade-off: a
- * `process.env` mutation after the first `ctx.env` read is not picked up.
+ * @internal
  */
+export function beginPageRender(c) {
+    rendering.add(c);
+}
+/** The shared refusal for a response write that arrived too late — the message names where it belongs instead. */
+function tooLateToWrite(call) {
+    throw new Error(`[rshono] ${call} was called while rendering a page, which is too late to affect the response. ` +
+        'A page streams, so its response head is already committed by the time the component runs — the ' +
+        'write would land on a full page load and be silently dropped on a soft navigation. Do it from a ' +
+        "'use server' action instead; or, in middleware and { type: 'endpoint' } routes — which are handed " +
+        "Hono's `c` directly and run outside the request context — with `c.header(…)` / `setCookie(c, …)`.");
+}
+/** The shared refusal for a Hono `Context` member a page has no way to use. See the stubs on {@link RequestContext}. */
+function notOnContext(call, instead) {
+    throw new Error(`[rshono] ctx.${call} does not exist. A page returns JSX and the framework builds the response from it, ` +
+        `so Hono's response builders have nothing to return to. ${instead}`);
+}
+// Snapshotted rather than spread per request: enumerating `process.env` crosses into the host
+// environment (~20µs). Lazily, because `loadEnvFiles()` runs after this module is imported — so a
+// mutation after the first `ctx.env` read is not picked up.
 let envSnapshot;
 function processEnv() {
     return (envSnapshot ??= typeof process !== 'undefined' && process.env ? { ...process.env } : {});
 }
-/**
- * True when this process is the SSG build prerendering `render: 'static'` routes,
- * rather than a server handling real requests. `build.ts` sets `RSHONO_PRERENDER`
- * before importing the app bundle and starting the prerender pass; the app bundle
- * inlines its own copy of this module, so a shared `process.env` (not a module-level
- * flag) is what reliably crosses that boundary. Read by {@link getContext} to turn a
- * static route's request-context read into a clear build-time error instead of
- * silently baking synthetic build-time values (a `localhost` URL, no cookies, build
- * env) into the snapshot.
- */
+// Set by `build.ts` before it imports the app bundle, which inlines its own copy of this module — so
+// `process.env` is what crosses that boundary rather than a module-level flag.
 const prerendering = typeof process !== 'undefined' && !!process.env?.RSHONO_PRERENDER;
 /**
- * Runs `fn` with the given Hono {@link Context} bound as the ambient request
- * context, so that {@link getContext} resolves to it anywhere in the call tree.
- *
- * Framework internal — the request handler wraps every render and action in
- * this. Application code should reach for {@link getContext} instead.
+ * Runs `fn` with `c` bound as the ambient request context, so {@link getRequestContext} resolves to it
+ * anywhere in the call tree.
  *
  * @internal
  */
@@ -53,12 +61,7 @@ export function runWithContext(c, fn) {
     return contextStorage.run(c, fn);
 }
 /**
- * Reads the matched route params, returning an empty object when there is no
- * active route match (rather than throwing). Shared by {@link Ctx.params} and the
- * request renderer so the fallback behaviour stays in one place.
- *
- * Framework internal — read params from {@link Ctx.params} or a page's
- * `PageProps` instead.
+ * The matched route params, or an empty object when there is no active match.
  *
  * @internal
  */
@@ -75,172 +78,339 @@ function firstForwardedValue(header) {
     const first = header?.split(',')[0]?.trim();
     return first || undefined;
 }
-// DefinePlugin inlines the config into the server bundle, but this module is the public
-// `@rshono/core/server` entry and could be loaded by tooling that doesn't (a unit test, a one-off script).
-// Read through `typeof` so that degrades to the safe answer — don't trust — instead of a ReferenceError.
+// Read through `typeof`: DefinePlugin inlines this into the server bundle, but the module is also the
+// public `@rshono/core/server` entry, which tooling can load without one. Absent means don't trust.
 const trustProxy = typeof __RSHONO_CONFIG__ !== 'undefined' && __RSHONO_CONFIG__.trustProxy;
+// Read the same way, for the same reason. Absent means the platform passes no bindings — see the getter.
+const envBindings = typeof __RSHONO_CONFIG__ !== 'undefined' && __RSHONO_CONFIG__.envBindings;
 /**
- * Resolves the browser-facing {@link URL} for a request.
+ * The browser-facing {@link URL} for a request, resolved from Hono's {@link Context} — a fresh
+ * instance per call.
  *
- * `c.req.url` reflects the internal address the server was reached on, which is wrong behind a
- * proxy or load balancer. `X-Forwarded-Host` / `X-Forwarded-Proto` fix that up — **but only when
- * `trustProxy` is enabled in `rshono.config.ts`** (always the case under `rshono dev`). Those
- * headers are client-supplied: honouring them unconditionally lets anyone who can reach the server
- * dictate the origin of every absolute URL the app builds — canonical tags, emails, redirects — and
- * poison a shared cache with them. So the default is to ignore them entirely.
+ * `c.req.url` is the internal address the server was reached on, which is wrong behind a proxy;
+ * `X-Forwarded-Host` / `-Proto` correct it, but only when `trustProxy` is enabled in
+ * `rshono.config.ts` — they are client-supplied, so trusting them unconditionally would let anyone
+ * dictate the origin of every absolute URL the app builds.
  *
- * Framework internal — prefer {@link Ctx.url}, which caches the result per request.
+ * This is the form for **middleware**, which is handed `c` and runs outside the request context — and
+ * so the way to give Hono's own middleware the origin the browser actually used. In a server component
+ * or action, prefer {@link RequestContext.url}, the same value cached per request.
  *
- * @internal
+ * @param c - The Hono {@link Context} for the request.
+ * @returns The browser-facing URL — proxy-corrected under `trustProxy`, `c.req.url` otherwise.
+ *
+ * @example
+ * ```ts
+ * // src/server.ts — a CSRF check that still works behind a proxy that rewrites Host
+ * import { publicUrl } from '@rshono/core/server';
+ * import { csrf } from 'hono/csrf';
+ *
+ * server.use(csrf({ origin: (origin, c) => origin === publicUrl(c).origin }));
+ * ```
+ *
+ * @see {@link https://www.rshono.com/docs/configuration#proxy-headers | Docs — proxy headers}
  */
 export function publicUrl(c) {
     const url = new URL(c.req.url);
     if (!trustProxy)
         return url;
     const forwardedHost = firstForwardedValue(c.req.header('x-forwarded-host'));
-    // Parsed rather than assigned to `url.host`, because that setter *keeps the existing port* when
-    // the new value has none — leaving the internal port on the public URL (`example.com:3000`).
+    // Parsed, not assigned to `url.host`: that setter keeps the existing port when the new value has none.
     const forwarded = forwardedHost ? URL.parse(`http://${forwardedHost}`) : null;
     if (forwarded) {
         url.hostname = forwarded.hostname;
-        url.port = forwarded.port; // '' when the forwarded host carries no port, which clears it
+        url.port = forwarded.port;
     }
-    // Restricted to the two schemes a browser can actually have requested; anything else (a proxy
-    // sending junk, or a client trying its luck) leaves the scheme alone.
+    // Only the two schemes a browser could have requested; anything else leaves the scheme alone.
     const forwardedProto = firstForwardedValue(c.req.header('x-forwarded-proto'));
     if (forwardedProto === 'http' || forwardedProto === 'https')
         url.protocol = forwardedProto;
     return url;
 }
 /**
- * Ergonomic, read-mostly wrapper around Hono's {@link Context} for use inside
- * server components and server actions.
+ * Read-mostly wrapper around Hono's {@link Context}, for server components and server actions.
+ *
+ * Obtain one with {@link getRequestContext}, or take it off a page's `ctx` prop — the same object.
+ * Never construct it yourself. One instance is reused for the whole request, so its lazy getters
+ * ({@link RequestContext.url}, {@link RequestContext.env}) are computed at most once.
  *
- * Obtain one with {@link getContext}, or — in a page component — take it straight
- * off the `ctx` prop, which is this same object. Never construct it yourself. One
- * instance is reused for the lifetime of a request, so its lazy getters
- * ({@link Ctx.url}, {@link Ctx.env}) are computed at most once.
+ * The eight members that only throw — `redirect`, `notFound`, `json`, `text`, `html`, `body`, `status`,
+ * `header` — are **permanent, and exist to throw**. Every one of them is a silent no-op when reached through
+ * {@link RequestContext.hono} from a page, so a stub that names the thing that does work is the difference
+ * between a message and a page that renders while quietly ignoring half of what it was asked for. They carry
+ * `@deprecated` for the strike-through an editor draws with it, not because they are on the way out: nothing
+ * will un-deprecate or remove them, and dropping them would leave `ctx.redirect('/x')` as
+ * "property does not exist", which says what is wrong and not what to do.
  *
- * @typeParam E - The Hono {@link Env} describing this app's `Bindings` and
- *   `Variables`, so {@link Ctx.var} and {@link Ctx.env} stay typed.
+ * @typeParam E - The Hono {@link Env} describing this app's `Bindings` and `Variables`, so
+ *   {@link RequestContext.var} and {@link RequestContext.env} stay typed.
  *
  * @example
  * ```tsx
- * import { getContext } from '@rshono/core/server';
+ * import { getRequestContext } from '@rshono/core/server';
  *
  * export default async function Whoami() {
- *   const ctx = getContext();
+ *   const ctx = getRequestContext();
  *   const session = ctx.cookies.get('session');
  *   return <p>{ctx.url.pathname} — {session ?? 'anonymous'}</p>;
  * }
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreserver | Docs — `@rshono/core/server`}
+ * @see {@link https://hono.dev/docs/api/context | Hono — Context}, reachable in full via {@link RequestContext.hono}
  */
-export class Ctx {
+export class RequestContext {
     #raw;
     #url;
     #env;
+    #params;
+    /**
+     * One instance is created per request and handed out by {@link getRequestContext} or the `ctx` page
+     * prop. Application code never calls this.
+     *
+     * @internal
+     */
     constructor(c) {
         this.#raw = c;
     }
     /**
-     * The underlying Hono {@link Context}. Escape hatch for anything this wrapper does not expose.
+     * The underlying Hono {@link Context} — the escape hatch for what this wrapper does not expose, such
+     * as `executionCtx.waitUntil()` on Workers.
      *
-     * A getter over a private field rather than a plain property, so it is not an *own enumerable*
-     * one — which matters more than it looks. React's diagnostic for a value that cannot be sent to a
-     * client component (`describeObjectForErrorMessage`) walks `Object.keys` recursively with no depth
-     * limit and no cycle guard, and the Hono context graph reaches the socket and the whole server
-     * through `req.raw` and `env`. While this was a plain property, passing a `Ctx` to a `'use client'`
-     * component blew the stack *inside that message builder* — so React's actual, accurate "you cannot
-     * pass this" error never got printed. Hidden from `Object.keys`, the walk stops here.
+     * Its response builders (`redirect`, `json`, `body`, `status`, …) still do nothing from inside a
+     * page: reaching them through here bypasses the errors the stubs on this class throw, it does not
+     * make them work.
+     *
+     * @example
+     * ```ts
+     * getRequestContext().hono.executionCtx.waitUntil(logAsync()); // Workers
+     * ```
+     *
+     * @see {@link https://hono.dev/docs/api/context | Hono — Context}
      */
-    get raw() {
+    // Every member here is a getter or method so that none is *own enumerable*: React's "you cannot pass
+    // this to a client component" diagnostic walks `Object.keys` recursively with no cycle guard, and the
+    // Hono context graph reaches the socket through `req.raw`. `cookies` is the one own property, and it
+    // is a shallow object of four functions.
+    get hono() {
         return this.#raw;
     }
-    /** The parsed Hono request (`c.req`) — headers, body parsing, param access, etc. */
+    /**
+     * The parsed request — method, headers, path params, query and the body readers. Hono's
+     * {@link Context.req}, unwrapped, so `ctx.req.header('authorization')` rather than
+     * `ctx.hono.req.header(…)`.
+     *
+     * Reads only; setting a *response* header is {@link RequestContext.setHeader}, deliberately spelled
+     * differently.
+     *
+     * @example
+     * ```ts
+     * const ctx = getRequestContext();
+     * ctx.req.method;                     // 'GET'
+     * ctx.req.header('authorization');    // string | undefined
+     * ctx.req.query('tab');               // string | undefined
+     * ```
+     *
+     * @see {@link https://hono.dev/docs/api/request | Hono — HonoRequest}
+     */
     get req() {
         return this.#raw.req;
     }
     /**
-     * The browser-facing request URL, proxy-header aware (see {@link publicUrl}) —
-     * read `url.pathname`, `url.searchParams` and the rest off it. Parsed once and
-     * cached, so the same instance comes back on every read within a request; treat
-     * it as read-only for that reason.
+     * Matched route params for this request, e.g. `{ id: '42' }` for `/profile/:id`. Empty when no route
+     * matched.
+     *
+     * A page is handed the same record as its `params` prop, typed key-by-key from its route path, and
+     * that is the better read where it exists. This is for everywhere else — a nested server component,
+     * or a `'use server'` action.
      */
-    get url() {
-        return (this.#url ??= publicUrl(this.#raw));
-    }
-    /** The HTTP method of the request, e.g. `GET` or `POST`. */
-    get method() {
-        return this.#raw.req.method;
+    get params() {
+        return (this.#params ??= readParams(this.#raw));
     }
     /**
-     * Matched route params, e.g. `{ id }` for a `/users/[id]` route. Returns an
-     * empty object when there is no active route match (rather than throwing).
+     * The browser-facing request URL. Parsed once and cached, so every read within a request returns the
+     * same instance — treat it as read-only.
+     *
+     * `X-Forwarded-Host` / `-Proto` are honoured only when `trustProxy` is enabled in
+     * `rshono.config.ts`, since any client can send them.
+     *
+     * @example `const tab = getRequestContext().url.searchParams.get('tab');`
+     *
+     * @see {@link https://www.rshono.com/docs/configuration#proxy-headers | Docs — proxy headers}
      */
-    get params() {
-        return readParams(this.#raw);
+    get url() {
+        return (this.#url ??= publicUrl(this.#raw));
     }
     /**
-     * Typed variables set by middleware via `c.set('user', …)`, read here as
-     * `ctx.var.user`. Type them by parameterising this class's {@link Env}.
+     * Typed variables set by middleware via `c.set('user', …)`, read here as `ctx.var.user`. Type them by
+     * parameterising this class's {@link Env}.
+     *
+     * @example
+     * ```ts
+     * type AppEnv = { Variables: { user: { id: string } } };
+     * const { user } = getRequestContext<AppEnv>().var; // typed, set by your middleware
+     * ```
+     *
+     * @see {@link https://hono.dev/docs/api/context#var | Hono — c.var}
+     * @see {@link https://www.rshono.com/docs/hono#typing-the-context | Docs — typing the context}
      */
     get var() {
         return this.#raw.var;
     }
     /**
-     * Environment for the request: process env vars merged with runtime bindings
-     * (bindings win on conflict). Computed once and cached.
+     * Environment for the request: process env vars, merged on a bindings platform with the bindings, which
+     * win on conflict.
+     *
+     * The `process.env` half is snapshotted **once per process**, not per request — enumerating it crosses
+     * into the host environment, and doing that on every request is a cost with nothing to show for it. So a
+     * `process.env` mutation made after the first `ctx.env` read anywhere in the process is never seen here.
+     * Read `process.env` directly if you have one. The bindings half is per request, since it comes off the
+     * request's own Hono context.
+     *
+     * Bindings are merged **only where the platform supplies them** — `deploy: 'cloudflare'`, today. Hono's
+     * `c.env` is whatever the host passed as the second argument to `app.fetch`, and off Workers that is the
+     * adapter's own private state: `{ incoming, outgoing }` on Node and Vercel, the entire invocation —
+     * headers, cookies, `authorization` — on Lambda. Merging it would make `ctx.env` uncloneable on one and
+     * a disclosure vector on the other, both behind names this type declares `string | undefined`. Reach for
+     * {@link RequestContext.hono}`.env` if you really do want the adapter's argument.
+     *
+     * @example `const key = getRequestContext().env.STRIPE_SECRET_KEY;`
      *
-     * @example `const key = getContext().env.STRIPE_SECRET_KEY;`
+     * @see {@link https://hono.dev/docs/api/context#env | Hono — c.env}
+     * @see {@link https://www.rshono.com/docs/configuration#environment-and-secrets | Docs — environment and secrets}
      */
     get env() {
         if (this.#env)
             return this.#env;
-        const bindings = this.#raw.env;
-        // The snapshot is shared, so hand it back as-is when there are no bindings to merge over it.
+        const bindings = envBindings ? this.#raw.env : undefined;
         return (this.#env = (bindings ? { ...processEnv(), ...bindings } : processEnv()));
     }
-    /** Sets a response header. Thin pass-through to `c.header(name, value)`. */
-    header(name, value) {
-        this.#raw.header(name, value);
-    }
     /**
      * Read and write request/response cookies.
      *
      * @example
      * ```ts
-     * const ctx = getContext();
+     * const ctx = getRequestContext();
      * ctx.cookies.get('session');                       // string | undefined
      * ctx.cookies.set('session', id, { httpOnly: true, sameSite: 'Lax', path: '/' });
      * ctx.cookies.delete('session', { path: '/' });
      * ```
+     *
+     * @see {@link https://hono.dev/docs/helpers/cookie | Hono — cookie helper}, which this wraps
      */
     cookies = {
-        /** Reads a single cookie by name, or `undefined` if absent. */
+        /** Reads a single cookie by name, or `undefined` if absent. Safe anywhere, a page included. */
         get: (name) => getCookie(this.#raw, name),
-        /** Reads every cookie as a `{ name: value }` record. */
+        /** Reads every cookie as a `{ name: value }` record. Safe anywhere, a page included. */
         all: () => getCookie(this.#raw),
-        /** Sets a cookie on the response. See Hono's {@link CookieOptions} for `path`, `httpOnly`, `maxAge`, etc. */
-        set: (name, value, options) => setCookie(this.#raw, name, value, options),
-        /** Clears a cookie. Pass the same `path`/`domain` it was set with so the browser matches it. */
+        /**
+         * Sets a cookie on the response. See Hono's {@link CookieOptions} for `path`, `httpOnly`, `maxAge`
+         * and the rest.
+         *
+         * **Throws inside a page render** — a `Set-Cookie` is a special case of
+         * {@link RequestContext.setHeader}. Set cookies from a `'use server'` action, or with Hono's
+         * `setCookie(c, …)` in middleware and endpoint routes.
+         *
+         * @throws If called while a page is rendering, where it could not reach the browser reliably.
+         *
+         * @see {@link https://hono.dev/docs/helpers/cookie#options | Hono — cookie options}
+         */
+        set: (name, value, options) => {
+            this.#assertWritable('ctx.cookies.set()');
+            setCookie(this.#raw, name, value, options);
+        },
+        /**
+         * Clears a cookie. Pass the same `path`/`domain` it was set with so the browser matches it.
+         * Throws inside a page render, exactly as `set` does.
+         *
+         * @throws If called while a page is rendering.
+         */
         delete: (name, options) => {
+            this.#assertWritable('ctx.cookies.delete()');
             deleteCookie(this.#raw, name, options);
         },
     };
+    #assertWritable(call) {
+        if (rendering.has(this.#raw))
+            tooLateToWrite(call);
+    }
+    /**
+     * Sets a header on the response — from a `'use server'` action, which is the one place a request
+     * context exists *and* the response is still open.
+     *
+     * From inside a page it throws: a page streams, so its response head is already committed by then,
+     * and the write would land on a full page load but vanish on a soft navigation.
+     *
+     * Middleware and `{ type: 'endpoint' }` routes are handed Hono's `c` directly and use `c.header(…)`.
+     * That is also where a header belonging to the *page* goes — `Cache-Control`, `X-Robots-Tag` — since
+     * middleware runs before the render.
+     *
+     * @param name - Header name, case-insensitive.
+     * @param value - Header value.
+     * @param options - `{ append: true }` to add another value rather than replace.
+     * @throws If called while a page is rendering, where it could not reach the browser reliably.
+     *
+     * @example
+     * ```ts
+     * 'use server';
+     * export async function logout() {
+     *   const ctx = getRequestContext();
+     *   ctx.cookies.delete('session', { path: '/' });
+     *   ctx.setHeader('clear-site-data', '"cache", "storage"');
+     *   redirect('/');
+     * }
+     * ```
+     */
+    setHeader(name, value, options) {
+        this.#assertWritable('ctx.setHeader()');
+        this.#raw.header(name, value, options);
+    }
+    // Hono's response builders, restated as errors naming what to use instead — through `ctx.hono` every
+    // one of them is a silent no-op from a page. Permanent, deliberately: see the class doc. `@deprecated`
+    // strikes them through in autocomplete; the unread `..._args` is so `ctx.redirect('/x')` reaches the
+    // thrown message rather than an arity error.
+    /** @deprecated Not available on a page's context — use `redirect()` from `@rshono/core/server`. */
+    redirect(..._args) {
+        return notOnContext('redirect(location, status?)', "Use `redirect()` from '@rshono/core/server', which throws a signal the framework turns into a real redirect.");
+    }
+    /** @deprecated Not available on a page's context — use `notFound()` from `@rshono/core/server`. */
+    notFound(..._args) {
+        return notOnContext('notFound()', "Use `notFound()` from '@rshono/core/server', which aborts the render and shows the app's not-found page.");
+    }
+    /** @deprecated A page renders JSX. For a JSON response, use an `{ type: 'endpoint' }` route. */
+    json(..._args) {
+        return notOnContext('json(object)', "For a JSON response use an { type: 'endpoint' } route; to read the request body use `ctx.req.json()`.");
+    }
+    /** @deprecated A page renders JSX. For a text response, use an `{ type: 'endpoint' }` route. */
+    text(..._args) {
+        return notOnContext('text(string)', "For a text response use an { type: 'endpoint' } route; to read the request body use `ctx.req.text()`.");
+    }
+    /** @deprecated A page renders JSX, which the framework turns into HTML for you. */
+    html(..._args) {
+        return notOnContext('html(string)', "A page's JSX is already its HTML; for a hand-built HTML response use an { type: 'endpoint' } route.");
+    }
+    /** @deprecated Not available on a page's context. To read the request body, use `ctx.req`. */
+    body(..._args) {
+        return notOnContext('body(data, …)', "To read the *request* body use `ctx.req.json()` / `ctx.req.text()` / `ctx.req.formData()`; to build a response, use an { type: 'endpoint' } route.");
+    }
+    /** @deprecated A page's status is set by the framework — use `notFound()`, or an endpoint route. */
+    status(..._args) {
+        return notOnContext('status(code)', "A page's status is the framework's: 200, 404 via `notFound()`, 500 when it throws. For any other code use an { type: 'endpoint' } route.");
+    }
+    /** @deprecated Renamed — use `ctx.setHeader(name, value)`, which is valid from a `'use server'` action. */
+    header(..._args) {
+        return notOnContext('header(name, value)', "Use `ctx.setHeader(name, value)` from a 'use server' action, or `c.header(…)` in middleware — a page renders too late to set one.");
+    }
 }
 /**
- * Returns the {@link Ctx} for the current request.
- *
- * This is the primary entry point for reading request data from a server
- * component or server action — the URL, cookies, params, env, and middleware
- * variables. The returned wrapper is memoised per request, so repeated calls in
- * the same request are cheap and return the same instance.
+ * The {@link RequestContext} for the current request — URL, cookies, params, env and middleware
+ * variables — read from a server component or a server action. Memoised per request, so repeated calls
+ * return the same instance.
  *
- * A **page** component is handed the very same object as its `ctx` prop, so this
- * import is for everywhere else: a nested server component, or a `'use server'`
- * action module — neither of which receives props from the framework.
+ * A page is handed that same object as its `ctx` prop, so this import is for everywhere else: a nested
+ * server component, or a `'use server'` action module.
  *
- * @typeParam E - The app's Hono {@link Env}, to type {@link Ctx.var} and {@link Ctx.env}.
+ * @typeParam E - The app's Hono {@link Env}, to type {@link RequestContext.var} and {@link RequestContext.env}.
  * @throws If called at module load, where there is no ambient context to resolve.
  * @throws If called while prerendering a `render: 'static'` route, which has no
  *   per-request context at build time — mark the route `render: 'dynamic'` instead.
@@ -248,47 +418,48 @@ export class Ctx {
  * @example
  * ```ts
  * 'use server';
- * import { getContext, redirect } from '@rshono/core/server';
+ * import { getRequestContext, redirect } from '@rshono/core/server';
  *
  * export async function login(form: FormData) {
- *   getContext().cookies.set('session', String(form.get('email')), { httpOnly: true });
+ *   getRequestContext().cookies.set('session', String(form.get('email')), { httpOnly: true });
  *   redirect('/dashboard');
  * }
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreserver | Docs — `@rshono/core/server`}
  */
-export function getContext() {
+export function getRequestContext() {
     if (prerendering) {
-        throw new Error("[rshono] getContext() was called while prerendering a `render: 'static'` route. A static page " +
+        throw new Error("[rshono] getRequestContext() was called while prerendering a `render: 'static'` route. A static page " +
             'is rendered once at build time, so it has no per-request context to read (URL, cookies, ' +
             "headers, env). Change this route to `render: 'dynamic'` so it renders per request, or remove " +
-            'the getContext() call.');
+            'the getRequestContext() call.');
     }
     const c = contextStorage.getStore();
     if (!c) {
-        throw new Error('[rshono] getContext() was called outside a request. It only works inside a server component or a server action, not at module load.');
+        throw new Error('[rshono] getRequestContext() was called outside a request. It only works inside a server component or a server action, not at module load.');
     }
     let ctx = wrappers.get(c);
     if (!ctx) {
-        ctx = new Ctx(c);
+        ctx = new RequestContext(c);
         wrappers.set(c, ctx);
     }
     return ctx;
 }
 /**
- * Redirects the request to `location` by throwing a control signal that the
- * framework catches and turns into an HTTP redirect response.
+ * Redirects the request to `location`, by throwing a control signal the framework turns into an HTTP
+ * redirect.
  *
- * Because it throws, it never returns — TypeScript narrows away any code after
- * the call, and you do not need to `return` it. Do not wrap it in a `try/catch`
- * that swallows the signal.
+ * Because it throws it never returns, so TypeScript narrows away everything after the call and there
+ * is nothing to `return`. Don't wrap it in a `try/catch` that swallows the signal.
  *
  * @param location - Absolute path or URL to redirect to, e.g. `/dashboard`.
- * @param status - Redirect {@link RedirectStatus}; defaults to `303` (See Other),
- *   the correct choice after a form action so the browser follows up with a `GET`.
+ * @param status - Redirect {@link RedirectStatus}; defaults to `303` (See Other), which is what makes
+ *   the browser follow up with a `GET` after a form action.
  *
  * @example
  * ```ts
- * const session = getContext().cookies.get('session');
+ * const session = getRequestContext().cookies.get('session');
  * if (!session) redirect('/login');
  * // session is defined below this line
  * ```
@@ -297,32 +468,69 @@ export function redirect(location, status = 303) {
     throw new RedirectSignal(location, status);
 }
 /**
- * Aborts the current render with a 404, rendering the app's not-found page.
+ * Aborts the current render with a 404, rendering the app's `notFound` page.
+ *
+ * Like {@link redirect} it throws a control signal and never returns, so TypeScript narrows away
+ * everything after the call. Don't catch-and-swallow it.
  *
- * Like {@link redirect}, this throws a control signal and never returns, so
- * TypeScript narrows away everything after the call. Do not catch-and-swallow it.
+ * **A real 404 status is only possible on a document load.** A soft navigation asks for a flight payload,
+ * and that response is committed as `200 text/x-component` the moment the render hands its stream back —
+ * before anything is awaited — so there is no shell to beat and calling this from the first line of a page
+ * is already too late. The signal still reaches the browser as a digest, and the client recovers by
+ * reloading the page for real: correct, but an extra round trip and a full document parse every time. Unlike
+ * {@link redirect}, which the same client turns into a soft navigation and which costs nothing. Where the
+ * status matters — a crawler, a monitor — decide in Hono middleware, ahead of the render.
  *
  * @example
  * ```tsx
- * const user = await db.user.find(getContext().params.id);
- * if (!user) notFound();
- * return <Profile user={user} />; // user is non-null here
+ * export default async function Page({ params }: PageProps<'/users/:id'>) {
+ *   const user = await db.user.find(params.id);
+ *   if (!user) notFound();
+ *   return <Profile user={user} />; // user is non-null here
+ * }
  * ```
  */
 export function notFound() {
     throw new NotFoundSignal();
 }
 let errorHandler;
+/**
+ * The platform's "keep this invocation alive" hook, or a no-op where there is none.
+ *
+ * `c.executionCtx` *throws* rather than answering `undefined` where a platform has no execution context, so
+ * a handler that reached for it itself would have its report swallowed by the guard in
+ * {@link reportServerError} — on exactly the platforms where nothing needed holding open.
+ */
+function keepAlive(c, promise) {
+    // Caught here rather than left to the platform: under `--unhandled-rejections=strict` a rejected report
+    // would end the process, and a failed report must never be worse than no report.
+    const settled = Promise.resolve(promise).catch((error) => {
+        console.error('[rshono] a promise passed to the onServerError waitUntil rejected:', error);
+    });
+    try {
+        c.executionCtx.waitUntil(settled);
+    }
+    catch {
+        // No execution context: nothing here cuts the work off, so there is nothing to hold open.
+    }
+}
+/**
+ * Errors already forwarded, so one fault is reported once however many stages it crosses.
+ *
+ * A thrown server action is reported where it is known to be an action and then re-thrown, which lands it in
+ * the top-level handler as well — and a funnel that counts the same error twice, under two different
+ * `source`s, is worse than one that only ever names the outer stage.
+ */
+const alreadyReported = new WeakSet();
 /**
  * Registers a handler for every error the framework catches, so they can reach an error tracker
  * (Sentry, Datadog, a log pipeline) instead of only `stderr`.
  *
- * Call it **once, at the top level of `src/server.ts`** — that module is imported as the server
- * starts, before any request is served. Registering again replaces the previous handler.
+ * Call it once, at the top level of `src/server.ts`, which is imported as the server starts.
+ * Registering again replaces the previous handler. Errors still go to `stderr` either way, and a
+ * handler that throws is caught and logged — reporting can never fail a request.
  *
- * Errors are still written to `stderr` either way, so a handler adds a destination rather than
- * replacing one. A handler that throws is caught and logged: reporting must never be able to fail
- * a request.
+ * @typeParam E - The app's Hono {@link Env}, to type the `hono` context the handler is given.
  *
  * @example
  * ```ts
@@ -330,28 +538,48 @@ let errorHandler;
  * import * as Sentry from '@sentry/node';
  * import { onServerError } from '@rshono/core/server';
  *
- * onServerError((error, { source, request }) => {
- *   Sentry.captureException(error, { tags: { source }, extra: { url: request.url } });
+ * onServerError((error, { source, request, hono, waitUntil }) => {
+ *   // `waitUntil` so a serverless invocation is not frozen before the report is sent.
+ *   waitUntil(
+ *     Sentry.captureException(error, {
+ *       tags: { source, requestId: hono.var.requestId },
+ *       extra: { url: request.url },
+ *     }),
+ *   );
  * });
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/hono#error-reporting | Docs — error reporting}
  */
 export function onServerError(handler) {
     errorHandler = handler;
 }
 /**
- * Logs an error and forwards it to the registered {@link ServerErrorHandler}.
- *
- * Framework internal — the single funnel every caught server-side error goes through, so that
- * adding a reporting destination is one registration rather than a hook per call site.
+ * Logs an error and forwards it to the registered {@link ServerErrorHandler} — the single funnel every
+ * caught server-side error goes through.
  *
  * @internal
  */
 export function reportServerError(error, info) {
+    // The first stage to recognise it wins, since that is the one that knows what it was. A primitive throw
+    // cannot be tracked and is reported wherever it is caught.
+    if (typeof error === 'object' && error !== null) {
+        if (alreadyReported.has(error))
+            return;
+        alreadyReported.add(error);
+    }
     console.error(info.message, error);
     if (!errorHandler)
         return;
     try {
-        errorHandler(error, { source: info.source, request: info.request });
+        errorHandler(error, {
+            source: info.source,
+            request: info.hono.req.raw,
+            // The handler was registered for the app's own `Env`, which `onServerError` erased to store it; this
+            // puts the context back in the shape it was registered with. Same trade as {@link getRequestContext}.
+            hono: info.hono,
+            waitUntil: (promise) => keepAlive(info.hono, promise),
+        });
     }
     catch (handlerError) {
         console.error('[rshono] the onServerError handler threw:', handlerError);