@rshono/core 1.0.0-rc.6 → 1.0.0-rc.7

package/dist/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AA4GA,6GAA6G;AAC7G,MAAM,UAAU,YAAY,CAAC,MAAoB;IAC/C,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import type { RspackOptions } from '@rspack/core';\nimport type { DeployTarget } from './deploy/contract.js';\n\n/** Which of the two Rspack compilers the {@link RshonoConfig.rspack} hook is being called for. */\nexport interface RspackHookContext {\n  /** `true` for the server (`target: node`) bundle, `false` for the client (`target: web`) bundle. */\n  isServer: boolean;\n  /** `true` under `rshono dev`, `false` under `rshono build`. */\n  isDev: boolean;\n}\n\n/**\n * Project configuration for rshono, default-exported from `rshono.config.ts` at the project root\n * (`.js` / `.mjs` also work). Every field is optional; omit the file entirely to accept all defaults.\n *\n * @example\n * ```ts\n * import { defineConfig } from '@rshono/core';\n *\n * export default defineConfig({\n *   csp: true,\n *   bodySizeLimit: '4mb',\n *   allowedOrigins: ['https://admin.example.com'],\n * });\n * ```\n */\nexport interface RshonoConfig {\n  /**\n   * The hosting platform `rshono build` targets. Default `'node'` — a long-lived server process, for\n   * a VPS, a container or anywhere else you run `rshono start`.\n   *\n   * Overridden by the `--deploy` flag or the `RSHONO_DEPLOY` env var, so one config can still be\n   * built for more than one place. `rshono dev` ignores it entirely and always runs the Node dev\n   * server.\n   */\n  deploy?: DeployTarget;\n  /**\n   * The public origin the site is served from, e.g. `'https://example.com'`.\n   *\n   * Only used when prerendering `render: 'static'` routes. A prerendered page is one fixed file\n   * handed to everyone, so any absolute URL inside it has to be decided at build time — there is no\n   * request to read a `Host` from. That is what a page's `url` prop is, so without this a static\n   * page bakes in `http://localhost` wherever it builds a canonical tag, an absolute link or an\n   * `og:url`. Dynamic routes are unaffected: they resolve the URL per request.\n   *\n   * The origin is what's used; a path is rejected rather than silently dropped.\n   */\n  siteUrl?: string;\n  /**\n   * Honour `X-Forwarded-Host` / `X-Forwarded-Proto` when resolving the browser-facing request\n   * URL (`getRequestContext().url`, a page's `url` prop, and the origin the CSRF check compares against).\n   *\n   * **Off by default, and leave it off unless a proxy you control sets those headers**, because\n   * any client can send them: with it on and nothing stripping them at the edge, one request can\n   * point every absolute URL your app builds at an attacker's host (and poison a shared cache).\n   * Turn it on when you terminate TLS or rewrite `Host` at a reverse proxy / load balancer.\n   * Always `true` under `rshono dev`, where the framework's own proxy sets them and binds to\n   * localhost. Default `false`.\n   */\n  trustProxy?: boolean;\n  /**\n   * CSRF origin check on server-action POSTs — rejects a cross-origin request with 403.\n   * Turn off only behind a gateway that already enforces it. Default `true`.\n   */\n  checkOrigin?: boolean;\n  /**\n   * Extra origins allowed to post server actions, in addition to the app's own origin.\n   * Accepts full origins or bare hosts, e.g. `['https://admin.example.com', 'localhost:4000']`.\n   */\n  allowedOrigins?: string[];\n  /**\n   * Send a strict per-request-nonce `Content-Security-Policy` with every HTML document.\n   * While enabled, `render: 'static'` routes render per request (a prerendered file can't carry a\n   * per-request nonce). Default `false`.\n   */\n  csp?: boolean;\n  /**\n   * Directives merged over the built-in {@link csp} policy, which is deliberately strict\n   * (`default-src 'self'`, no framing, no plugins) and so blocks third-party images, fonts and\n   * API hosts until you widen it here. Set a directive to `''` to drop it entirely.\n   *\n   * The per-request nonce is always appended to `script-src`, whatever you put there.\n   * Ignored unless `csp` is `true`.\n   *\n   * @example\n   * ```ts\n   * cspDirectives: {\n   *   'img-src': \"'self' data: https://images.example.com\",\n   *   'font-src': \"'self' https://fonts.gstatic.com\",\n   *   'frame-ancestors': \"'self'\",\n   * }\n   * ```\n   */\n  cspDirectives?: Record<string, string>;\n  /**\n   * Max server-action request body before it's rejected with 413 — a memory-exhaustion guard.\n   * A number is bytes; a string carries a unit (`'512kb'`, `'4mb'`); `false` (or `0`) disables the cap.\n   * Default `'1mb'`.\n   */\n  bodySizeLimit?: string | number | false;\n  /**\n   * Escape hatch: mutate the generated Rspack config just before it's compiled. Called once per\n   * compiler — inspect {@link RspackHookContext.isServer} to tell them apart. Mutate `config` in\n   * place and return nothing, or return a replacement.\n   */\n  rspack?: (config: RspackOptions, ctx: RspackHookContext) => RspackOptions | void;\n}\n\n/** Identity helper that types a config object — gives editor autocomplete without an explicit annotation. */\nexport function defineConfig(config: RshonoConfig): RshonoConfig {\n  return config;\n}\n"]}
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAwIA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CAAC,MAAoB;IAC/C,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import type { RspackOptions } from '@rspack/core';\nimport type { DeployTarget } from './deploy/contract.js';\n\n/** Which of the two Rspack compilers the {@link RshonoConfig.rspack} hook is being called for. */\nexport interface RspackHookContext {\n  /** `true` for the server (`target: node`) bundle, `false` for the client (`target: web`) bundle. */\n  isServer: boolean;\n  /** `true` under `rshono dev`, `false` under `rshono build`. */\n  isDev: boolean;\n}\n\n/**\n * Project configuration for rshono, default-exported from `rshono.config.ts` at the project root\n * (`.js` / `.mjs` also work). Every field is optional; omit the file entirely to accept all defaults.\n *\n * @example\n * ```ts\n * import { defineConfig } from '@rshono/core';\n *\n * export default defineConfig({\n *   csp: true,\n *   bodySizeLimit: '4mb',\n *   allowedOrigins: ['https://admin.example.com'],\n * });\n * ```\n *\n * @see {@link https://www.rshono.com/docs/configuration | Docs — configuration}\n */\nexport interface RshonoConfig {\n  /**\n   * The hosting platform `rshono build` targets. Default `'node'` — a long-lived server process, for\n   * a VPS, a container or anywhere else you run `rshono start`.\n   *\n   * Overridden by the `--deploy` flag or the `RSHONO_DEPLOY` env var, so one config can still be\n   * built for more than one place. `rshono dev` ignores it entirely and always runs the Node dev\n   * server.\n   *\n   * @see {@link https://www.rshono.com/docs/deployment | Docs — deployment}\n   */\n  deploy?: DeployTarget;\n  /**\n   * The public origin the site is served from, e.g. `'https://example.com'`.\n   *\n   * Only used when prerendering `render: 'static'` routes. A prerendered page is one fixed file\n   * handed to everyone, so any absolute URL inside it has to be decided at build time — there is no\n   * request to read a `Host` from. That is what a page's `url` prop is, so without this a static\n   * page bakes in `http://localhost` wherever it builds a canonical tag, an absolute link or an\n   * `og:url`. Dynamic routes are unaffected: they resolve the URL per request.\n   *\n   * The origin is what's used; a path is rejected rather than silently dropped.\n   *\n   * @see {@link https://www.rshono.com/docs/configuration#siteurl | Docs — siteUrl}\n   */\n  siteUrl?: string;\n  /**\n   * Honour `X-Forwarded-Host` / `X-Forwarded-Proto` when resolving the browser-facing request\n   * URL (`getRequestContext().url`, a page's `url` prop, and the origin the CSRF check compares against).\n   *\n   * **Off by default, and leave it off unless a proxy you control sets those headers**, because\n   * any client can send them: with it on and nothing stripping them at the edge, one request can\n   * point every absolute URL your app builds at an attacker's host (and poison a shared cache).\n   * Turn it on when you terminate TLS or rewrite `Host` at a reverse proxy / load balancer.\n   * Always `true` under `rshono dev`, where the framework's own proxy sets them and binds to\n   * localhost. Default `false`.\n   *\n   * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host | MDN — X-Forwarded-Host}\n   * @see {@link https://www.rshono.com/docs/configuration#proxy-headers | Docs — proxy headers}\n   */\n  trustProxy?: boolean;\n  /**\n   * CSRF origin check on server-action POSTs — rejects a cross-origin request with 403.\n   * Turn off only behind a gateway that already enforces it. Default `true`.\n   *\n   * @see {@link https://www.rshono.com/docs/configuration#csrf | Docs — CSRF}\n   */\n  checkOrigin?: boolean;\n  /**\n   * Extra origins allowed to post server actions, in addition to the app's own origin.\n   * Accepts full origins or bare hosts, e.g. `['https://admin.example.com', 'localhost:4000']`.\n   */\n  allowedOrigins?: string[];\n  /**\n   * Send a strict per-request-nonce `Content-Security-Policy` with every HTML document.\n   * While enabled, `render: 'static'` routes render per request (a prerendered file can't carry a\n   * per-request nonce). Default `false`.\n   *\n   * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy | MDN — Content-Security-Policy}\n   * @see {@link https://www.rshono.com/docs/configuration#csp-opt-in | Docs — CSP}\n   */\n  csp?: boolean;\n  /**\n   * Directives merged over the built-in {@link csp} policy, which is deliberately strict\n   * (`default-src 'self'`, no framing, no plugins) and so blocks third-party images, fonts and\n   * API hosts until you widen it here. Set a directive to `''` to drop it entirely.\n   *\n   * The per-request nonce is always appended to `script-src`, whatever you put there.\n   * Ignored unless `csp` is `true`.\n   *\n   * @example\n   * ```ts\n   * cspDirectives: {\n   *   'img-src': \"'self' data: https://images.example.com\",\n   *   'font-src': \"'self' https://fonts.gstatic.com\",\n   *   'frame-ancestors': \"'self'\",\n   * }\n   * ```\n   *\n   * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy#directives | MDN — CSP directives}\n   */\n  cspDirectives?: Record<string, string>;\n  /**\n   * Max server-action request body before it's rejected with 413 — a memory-exhaustion guard.\n   * A number is bytes; a string carries a unit (`'512kb'`, `'4mb'`); `false` (or `0`) disables the cap.\n   * Default `'1mb'`.\n   *\n   * @see {@link https://www.rshono.com/docs/configuration#request-body-limit | Docs — request-body limit}\n   */\n  bodySizeLimit?: string | number | false;\n  /**\n   * Escape hatch: mutate the generated Rspack config just before it's compiled. Called once per\n   * compiler — inspect {@link RspackHookContext.isServer} to tell them apart. Mutate `config` in\n   * place and return nothing, or return a replacement.\n   *\n   * @example\n   * ```ts\n   * rspack(config, { isServer }) {\n   *   config.module?.rules?.push({ test: /\\.svg$/, type: 'asset/source' });\n   * }\n   * ```\n   *\n   * @see {@link https://rspack.rs/config/ | Rspack — configuration reference}\n   * @see {@link https://www.rshono.com/docs/configuration#the-rspack-hook | Docs — the rspack hook}\n   */\n  rspack?: (config: RspackOptions, ctx: RspackHookContext) => RspackOptions | void;\n}\n\n/**\n * Identity helper that types a config object — gives editor autocomplete without an explicit\n * annotation. Default-export the result from `rshono.config.ts`.\n *\n * @param config - The project's {@link RshonoConfig}; every field is optional.\n * @returns The config, unchanged and fully typed.\n *\n * @example\n * ```ts\n * // rshono.config.ts\n * import { defineConfig } from '@rshono/core';\n *\n * export default defineConfig({ deploy: 'cloudflare', siteUrl: 'https://example.com' });\n * ```\n *\n * @see {@link https://www.rshono.com/docs/configuration | Docs — configuration}\n */\nexport function defineConfig(config: RshonoConfig): RshonoConfig {\n  return config;\n}\n"]}

package/dist/deploy/contract.d.ts

@@ -1,19 +1,24 @@
 import type { Context, Hono } from 'hono';
 import type { PrerenderVariant, PrerenderedPage } from '../server/prerendered.js';
 /**
- * A hosting platform rshono can build for. Selected with {@link RshonoConfig.deploy}, the
+ * A hosting platform `rshono build` targets. Selected with `deploy` in `rshono.config.ts`, the
  * `--deploy` flag or the `RSHONO_DEPLOY` env var, and resolved to a preset by `deploy/presets.ts`.
  *
- * One per *handoff*, which is the thing an app cannot arrange for itself: `node` binds its own port (and
- * so covers a VPS, a container, a PaaS, and — through `node:` compatibility — Bun and Deno);
- * `cloudflare`, `vercel` and `aws-lambda` are each handed a request by their host, in three different
- * shapes, two of which also need a specific on-disk layout and a config file to stream at all.
+ * - `'node'` (the default) — rshono binds the port itself and you run the build with `rshono start`.
+ *   Covers a VPS, a container, a PaaS, and — through `node:` compatibility — Bun and Deno.
+ * - `'cloudflare'` — a Worker; the entry exports `{ fetch }`.
+ * - `'vercel'` — a Vercel function, plus the on-disk layout and config file streaming needs there.
+ * - `'aws-lambda'` — a streaming Lambda handler.
  *
- * There is deliberately no target whose only content would be "run the Node build". Bun and Deno had one
- * each and that is all they were, so importing the bundle under those runtimes replaces them.
+ * One entry per *handoff* — who opens the socket, and what shape a request arrives in — because that
+ * is the part an app cannot arrange for itself. There is deliberately no target whose only content
+ * would be "run the Node build": Bun and Deno had one each and that is all they were, so importing
+ * the bundle under those runtimes replaces them.
  *
  * `rshono dev` always runs the `node` server whatever this says — the dev server owns the process,
  * watches both compilers and fronts them on one port, none of which a hosting platform provides.
+ *
+ * @see {@link https://www.rshono.com/docs/deployment#the-targets | Docs — the targets}
  */
 export type DeployTarget = 'node' | 'cloudflare' | 'vercel' | 'aws-lambda';
 /**

package/dist/deploy/contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/deploy/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAElF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE3E;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,OAAO,CAAC;IAC7B;;;;;OAKG;IACH,iBAAiB,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAAC;IACnC;;;OAGG;IACH,mBAAmB,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAAC;IACrC;;;;;;;;OAQG;IACH,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACxF,4GAA4G;IAC5G,OAAO,IAAI,IAAI,CAAC;CACjB"}
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/deploy/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAElF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE3E;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,OAAO,CAAC;IAC7B;;;;;OAKG;IACH,iBAAiB,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAAC;IACnC;;;OAGG;IACH,mBAAmB,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAAC;IACrC;;;;;;;;OAQG;IACH,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACxF,4GAA4G;IAC5G,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/deploy/contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../src/deploy/contract.ts"],"names":[],"mappings":"","sourcesContent":["import type { Context, Hono } from 'hono';\nimport type { PrerenderVariant, PrerenderedPage } from '../server/prerendered.js';\n\n/**\n * A hosting platform rshono can build for. Selected with {@link RshonoConfig.deploy}, the\n * `--deploy` flag or the `RSHONO_DEPLOY` env var, and resolved to a preset by `deploy/presets.ts`.\n *\n * One per *handoff*, which is the thing an app cannot arrange for itself: `node` binds its own port (and\n * so covers a VPS, a container, a PaaS, and — through `node:` compatibility — Bun and Deno);\n * `cloudflare`, `vercel` and `aws-lambda` are each handed a request by their host, in three different\n * shapes, two of which also need a specific on-disk layout and a config file to stream at all.\n *\n * There is deliberately no target whose only content would be \"run the Node build\". Bun and Deno had one\n * each and that is all they were, so importing the bundle under those runtimes replaces them.\n *\n * `rshono dev` always runs the `node` server whatever this says — the dev server owns the process,\n * watches both compilers and fronts them on one port, none of which a hosting platform provides.\n */\nexport type DeployTarget = 'node' | 'cloudflare' | 'vercel' | 'aws-lambda';\n\n/**\n * Everything the app server needs from the platform it is running on.\n *\n * One preset implements this per target, and the `@rshono/deploy` alias resolves to exactly that\n * module at build time (see `builder/rspack-config.ts`), so only the selected platform's code is\n * ever in the bundle. `runtime/entry.rsc.tsx` is written against this interface and nothing else —\n * it is the whole of what \"which platform is this\" means at request time.\n *\n * The members are the capabilities that genuinely differ between a host with a disk and one without:\n * who opens the socket, who serves the assets, where a prerendered page is read from, and whether\n * there is a `.env` to load at all.\n */\nexport interface DeployRuntime {\n  /**\n   * Hands the assembled app to the platform, and returns whatever the entry module should\n   * `export default` there.\n   *\n   * The two shapes hosting takes, in one call: where rshono owns the process (node, bun, deno) this\n   * binds a port and returns nothing; where the host owns it, it returns the export the platform\n   * looks for — `{ fetch }` on Workers, a handler function on Vercel/Netlify/Lambda.\n   */\n  serveApp(app: Hono): unknown;\n  /**\n   * Mounts the hashed client bundle at `/_static`. A no-op where the platform's own CDN serves it\n   * before a request ever reaches the app.\n   *\n   * Called *before* the app's routes, so the bundle is never shadowed by one.\n   */\n  mountStaticAssets(app: Hono): void;\n  /**\n   * Mounts the `public/` fallback at the web root — files served verbatim, and only for paths no\n   * route claimed. Called *after* every route for exactly that reason.\n   */\n  mountPublicFallback(app: Hono): void;\n  /**\n   * Reads the page prerendered for `c.req.path` by `rshono build`, or `null` when there is none (in\n   * which case the route renders per request, which is always a valid answer).\n   *\n   * Takes the whole {@link Context} rather than just the path because on a platform with no\n   * filesystem the store *is* a request-scoped binding — `c.env.ASSETS` on Workers. The path is\n   * untrusted either way, so an implementation has to treat traversal as a miss, not a lookup\n   * (see `prerenderedRelPath`).\n   */\n  readPrerendered(c: Context, variant: PrerenderVariant): Promise<PrerenderedPage | null>;\n  /** Loads `.env` files, where the platform has a filesystem to read them from. Env is bindings elsewhere. */\n  loadEnv(): void;\n}\n"]}
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../src/deploy/contract.ts"],"names":[],"mappings":"","sourcesContent":["import type { Context, Hono } from 'hono';\nimport type { PrerenderVariant, PrerenderedPage } from '../server/prerendered.js';\n\n/**\n * A hosting platform `rshono build` targets. Selected with `deploy` in `rshono.config.ts`, the\n * `--deploy` flag or the `RSHONO_DEPLOY` env var, and resolved to a preset by `deploy/presets.ts`.\n *\n * - `'node'` (the default) — rshono binds the port itself and you run the build with `rshono start`.\n *   Covers a VPS, a container, a PaaS, and — through `node:` compatibility — Bun and Deno.\n * - `'cloudflare'` — a Worker; the entry exports `{ fetch }`.\n * - `'vercel'` — a Vercel function, plus the on-disk layout and config file streaming needs there.\n * - `'aws-lambda'` — a streaming Lambda handler.\n *\n * One entry per *handoff* — who opens the socket, and what shape a request arrives in — because that\n * is the part an app cannot arrange for itself. There is deliberately no target whose only content\n * would be \"run the Node build\": Bun and Deno had one each and that is all they were, so importing\n * the bundle under those runtimes replaces them.\n *\n * `rshono dev` always runs the `node` server whatever this says — the dev server owns the process,\n * watches both compilers and fronts them on one port, none of which a hosting platform provides.\n *\n * @see {@link https://www.rshono.com/docs/deployment#the-targets | Docs — the targets}\n */\nexport type DeployTarget = 'node' | 'cloudflare' | 'vercel' | 'aws-lambda';\n\n/**\n * Everything the app server needs from the platform it is running on.\n *\n * One preset implements this per target, and the `@rshono/deploy` alias resolves to exactly that\n * module at build time (see `builder/rspack-config.ts`), so only the selected platform's code is\n * ever in the bundle. `runtime/entry.rsc.tsx` is written against this interface and nothing else —\n * it is the whole of what \"which platform is this\" means at request time.\n *\n * The members are the capabilities that genuinely differ between a host with a disk and one without:\n * who opens the socket, who serves the assets, where a prerendered page is read from, and whether\n * there is a `.env` to load at all.\n */\nexport interface DeployRuntime {\n  /**\n   * Hands the assembled app to the platform, and returns whatever the entry module should\n   * `export default` there.\n   *\n   * The two shapes hosting takes, in one call: where rshono owns the process (node, bun, deno) this\n   * binds a port and returns nothing; where the host owns it, it returns the export the platform\n   * looks for — `{ fetch }` on Workers, a handler function on Vercel/Netlify/Lambda.\n   */\n  serveApp(app: Hono): unknown;\n  /**\n   * Mounts the hashed client bundle at `/_static`. A no-op where the platform's own CDN serves it\n   * before a request ever reaches the app.\n   *\n   * Called *before* the app's routes, so the bundle is never shadowed by one.\n   */\n  mountStaticAssets(app: Hono): void;\n  /**\n   * Mounts the `public/` fallback at the web root — files served verbatim, and only for paths no\n   * route claimed. Called *after* every route for exactly that reason.\n   */\n  mountPublicFallback(app: Hono): void;\n  /**\n   * Reads the page prerendered for `c.req.path` by `rshono build`, or `null` when there is none (in\n   * which case the route renders per request, which is always a valid answer).\n   *\n   * Takes the whole {@link Context} rather than just the path because on a platform with no\n   * filesystem the store *is* a request-scoped binding — `c.env.ASSETS` on Workers. The path is\n   * untrusted either way, so an implementation has to treat traversal as a miss, not a lookup\n   * (see `prerenderedRelPath`).\n   */\n  readPrerendered(c: Context, variant: PrerenderVariant): Promise<PrerenderedPage | null>;\n  /** Loads `.env` files, where the platform has a filesystem to read them from. Env is bindings elsewhere. */\n  loadEnv(): void;\n}\n"]}

package/dist/index.d.ts

@@ -10,6 +10,8 @@
  * - `@rshono/core/client` — hooks and components for `'use client'` modules
  *   (`useNavigation`, `AsyncBoundary`, `CatchBoundary`).
  *
+ * @see {@link https://www.rshono.com/docs/api | Docs — API reference}
+ *
  * @packageDocumentation
  */
 export { defineRoutes, type EndpointRoute, type EndpointServerModule, type ErrorPageInfo, type ErrorPageProps, type FallbackPage, type HTTPMethod, type PageComponent, type PageProps, type PageRoute, type PathParams, type Route, type RouteConfig, } from './router.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,WAAW,GACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEtF,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,WAAW,GACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEtF,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -10,6 +10,8 @@
  * - `@rshono/core/client` — hooks and components for `'use client'` modules
  *   (`useNavigation`, `AsyncBoundary`, `CatchBoundary`).
  *
+ * @see {@link https://www.rshono.com/docs/api | Docs — API reference}
+ *
  * @packageDocumentation
  */
 export { defineRoutes, } from './router.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,YAAY,GAab,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,YAAY,EAA6C,MAAM,aAAa,CAAC;AAItF,kGAAkG;AAClG,sGAAsG;AACtG,mGAAmG","sourcesContent":["/**\n * `@rshono/core` — the build-time surface: route and config declaration plus the types\n * your pages and endpoints are written against. Everything here is safe to\n * import from server code; none of it pulls in runtime machinery.\n *\n * The two companion entry points are runtime-only:\n * - `@rshono/core/server` — {@link https://hono.dev | Hono} request context inside\n *   server components and actions (`getRequestContext`, `redirect`, `notFound`), plus\n *   `onServerError` for reporting the errors the framework catches.\n * - `@rshono/core/client` — hooks and components for `'use client'` modules\n *   (`useNavigation`, `AsyncBoundary`, `CatchBoundary`).\n *\n * @packageDocumentation\n */\n\nexport {\n  defineRoutes,\n  type EndpointRoute,\n  type EndpointServerModule,\n  type ErrorPageInfo,\n  type ErrorPageProps,\n  type FallbackPage,\n  type HTTPMethod,\n  type PageComponent,\n  type PageProps,\n  type PageRoute,\n  type PathParams,\n  type Route,\n  type RouteConfig,\n} from './router.js';\n\nexport { defineConfig, type RshonoConfig, type RspackHookContext } from './config.js';\n\nexport type { DeployTarget } from './deploy/contract.js';\n\n// Hono's own `Context` and `Handler` used to be re-exported from here \"for convenience\". They are\n// Hono's types, `hono` is a peer dependency every app already has, and importing them from two places\n// only raised the question of which one is right — so an endpoint module imports them from `hono`.\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,YAAY,GAab,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,YAAY,EAA6C,MAAM,aAAa,CAAC;AAItF,kGAAkG;AAClG,sGAAsG;AACtG,mGAAmG","sourcesContent":["/**\n * `@rshono/core` — the build-time surface: route and config declaration plus the types\n * your pages and endpoints are written against. Everything here is safe to\n * import from server code; none of it pulls in runtime machinery.\n *\n * The two companion entry points are runtime-only:\n * - `@rshono/core/server` — {@link https://hono.dev | Hono} request context inside\n *   server components and actions (`getRequestContext`, `redirect`, `notFound`), plus\n *   `onServerError` for reporting the errors the framework catches.\n * - `@rshono/core/client` — hooks and components for `'use client'` modules\n *   (`useNavigation`, `AsyncBoundary`, `CatchBoundary`).\n *\n * @see {@link https://www.rshono.com/docs/api | Docs — API reference}\n *\n * @packageDocumentation\n */\n\nexport {\n  defineRoutes,\n  type EndpointRoute,\n  type EndpointServerModule,\n  type ErrorPageInfo,\n  type ErrorPageProps,\n  type FallbackPage,\n  type HTTPMethod,\n  type PageComponent,\n  type PageProps,\n  type PageRoute,\n  type PathParams,\n  type Route,\n  type RouteConfig,\n} from './router.js';\n\nexport { defineConfig, type RshonoConfig, type RspackHookContext } from './config.js';\n\nexport type { DeployTarget } from './deploy/contract.js';\n\n// Hono's own `Context` and `Handler` used to be re-exported from here \"for convenience\". They are\n// Hono's types, `hono` is a peer dependency every app already has, and importing them from two places\n// only raised the question of which one is right — so an endpoint module imports them from `hono`.\n"]}

package/dist/router.d.ts

@@ -19,6 +19,8 @@ type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) exten
  * ```ts
  * type P = PathParams<'/users/:id/posts/:postId'>; // { id: string; postId: string }
  * ```
+ *
+ * @see {@link https://hono.dev/docs/api/routing#path-parameter | Hono — path parameters}
  */
 export type PathParams<P extends string> = ParamKeys<P> extends never ? Record<string, never> : Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>>;
 /**
@@ -47,6 +49,8 @@ export type PathParams<P extends string> = ParamKeys<P> extends never ? Record<s
  *   return <Layout>{user.name} — {tab}</Layout>;
  * }
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/pages#page-props | Docs — page props}
  */
 export interface PageProps<Path extends string = string, E extends Env = Env> {
     /**
@@ -72,25 +76,22 @@ export interface PageProps<Path extends string = string, E extends Env = Env> {
      * page so cookies, headers, env and middleware variables are reachable without
      * an import.
      *
-     * Server-only, and never serialized: React renders a server component and puts
-     * its *output* on the wire, not its props. It is also deliberately a
-     * non-enumerable property, which has three consequences worth knowing:
+     * Server-only and never serialized: React puts a server component's *output* on
+     * the wire, not its props. It is also a deliberately non-enumerable property, so:
      *
-     * - It **cannot be handed to a `'use client'` component** — it wraps the live
-     *   request and response, which do not exist in the browser. Passing it
-     *   explicitly (`<Counter ctx={ctx} />`) fails the render with React's *"Only
-     *   plain objects … can be passed to Client Components"*. Read what you need on
-     *   the server and pass plain values down.
-     * - Spreading the page's props instead (`<Counter {...props} />`) drops `ctx`
-     *   silently rather than failing, since the spread copies enumerables only.
-     *   (That spread still fails, mind — on `url`, which is enumerable and just as
-     *   unserializable. Pass the values you need.)
+     * - Handing it to a `'use client'` component (`<Counter ctx={ctx} />`) fails the
+     *   render with React's *"Only plain objects … can be passed to Client
+     *   Components"* — it wraps the live request and response, which do not exist in
+     *   the browser. Read what you need here and pass plain values down.
+     * - Spreading the page's props (`<Counter {...props} />`) drops `ctx` silently
+     *   instead, since a spread copies enumerables only. (That spread still fails,
+     *   mind — on `url`, which is enumerable and just as unserializable.)
      * - `Object.keys(props)`, `JSON.stringify(props)` and friends don't see it.
      *
      * Reading it on a `render: 'static'` route throws: a prerendered page has no
-     * per-request context at build time. Mark the route `render: 'dynamic'` (or use
-     * the `url` / `params` props, which are available either way — with the
-     * build-time caveats noted on `url`).
+     * per-request context at build time. Mark the route `render: 'dynamic'`, or use
+     * the `url` / `params` props — available either way, with the build-time caveat
+     * noted on `url`.
      *
      * @example
      * ```tsx
@@ -112,6 +113,9 @@ export interface PageProps<Path extends string = string, E extends Env = Env> {
  * belong in `'use client'` components the page imports — only those ship JS.
  *
  * @typeParam P - The component's props; for a page these are {@link PageProps}.
+ *
+ * @see {@link https://react.dev/reference/rsc/server-components | React — Server Components}
+ * @see {@link https://www.rshono.com/docs/pages | Docs — pages}
  */
 export type PageComponent<P = any> = (props: P) => ReactNode | Promise<ReactNode>;
 /**
@@ -126,9 +130,17 @@ export type PageComponent<P = any> = (props: P) => ReactNode | Promise<ReactNode
  *
  * export const handler: Handler = (c) => c.json({ ok: true });
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/routing#endpoint-routes | Docs — endpoint routes}
  */
 export interface EndpointServerModule {
-    /** A Hono {@link Handler} handling every request matched by the route. */
+    /**
+     * A Hono {@link Handler} handling every request matched by the route. It is passed Hono's
+     * `Context`, so the request, response builders (`c.json`, `c.text`, `c.body`) and middleware
+     * variables are all reached through it.
+     *
+     * @see {@link https://hono.dev/docs/api/context | Hono — Context}
+     */
     handler: Handler;
 }
 /**
@@ -143,7 +155,12 @@ export interface EndpointServerModule {
 export interface PageRoute {
     /** Discriminates a page from an endpoint; optional because `'page'` is the default. */
     type?: 'page';
-    /** Hono-style path pattern, e.g. `/`, `/profile/:id`, `/files/*`. */
+    /**
+     * Hono-style path pattern, e.g. `/`, `/profile/:id`, `/files/*`. Routes are matched in
+     * declaration order.
+     *
+     * @see {@link https://hono.dev/docs/api/routing | Hono — routing}
+     */
     path: string;
     /**
      * Dynamic import of the page module, whose default export is the
@@ -156,6 +173,8 @@ export interface PageRoute {
      * component up any other way — a variable, a barrel re-export, a computed
      * specifier — add `'use server-entry'` as the first line of the page module
      * yourself; the framework throws a descriptive error when neither happened.
+     *
+     * @see {@link https://www.rshono.com/docs/pages#the-use-server-entry-directive | Docs — the `'use server-entry'` directive}
      */
     component: () => Promise<{
         default: PageComponent;
@@ -180,6 +199,8 @@ export interface PageRoute {
      *   staticPaths: async () => (await db.docs.all()).map((d) => ({ slug: d.slug })),
      * }
      * ```
+     *
+     * @see {@link https://www.rshono.com/docs/routing#static-rendering | Docs — static rendering}
      */
     staticPaths?: () => Array<Record<string, string>> | Promise<Array<Record<string, string>>>;
 }
@@ -192,11 +213,17 @@ export interface PageRoute {
  * ```ts
  * { type: 'endpoint', path: '/api/health', server: () => import('./health') }
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/routing#endpoint-routes | Docs — endpoint routes}
  */
 export interface EndpointRoute {
     /** Marks this route as an endpoint rather than a page. Required. */
     type: 'endpoint';
-    /** Hono-style path pattern, e.g. `/api/health`, `/api/users/:id`. */
+    /**
+     * Hono-style path pattern, e.g. `/api/health`, `/api/users/:id`.
+     *
+     * @see {@link https://hono.dev/docs/api/routing | Hono — routing}
+     */
     path: string;
     /** HTTP method to match. Defaults to `'all'` — every method. */
     method?: HTTPMethod;
@@ -256,6 +283,7 @@ export interface ErrorPageInfo {
  * ```
  */
 export type ErrorPageProps<E extends Env = Env> = PageProps<string, E> & {
+    /** The error that failed the request, redacted in production — see {@link ErrorPageInfo}. */
     error: ErrorPageInfo;
 };
 /**
@@ -264,6 +292,8 @@ export type ErrorPageProps<E extends Env = Env> = PageProps<string, E> & {
  *
  * @typeParam TRoutes - Inferred tuple of route literals, which is what makes the
  *   per-route `path` → props check possible.
+ *
+ * @see {@link https://www.rshono.com/docs/routing#notfound-and-error | Docs — notFound and error pages}
  */
 export interface RouteConfig<TRoutes extends readonly Route[] = readonly Route[]> {
     /** Every page and endpoint in the app, matched in order. */
@@ -297,8 +327,10 @@ type ValidateRoutes<TRoutes extends readonly Route[]> = {
  * PageProps<'/…'>`. Fix it by matching the page's `PageProps<Path>` type
  * argument to the path it's mounted at.
  *
- * @param config - A {@link RouteConfig}, or a bare {@link Route} array as
- *   shorthand when there are no `notFound` / `error` pages.
+ * A bare {@link Route} array is accepted as shorthand — see the second overload.
+ *
+ * @param config - A {@link RouteConfig}: the `routes` array plus the optional
+ *   `notFound` and `error` pages.
  * @returns The config, unchanged and fully typed.
  *
  * @example
@@ -323,14 +355,25 @@ type ValidateRoutes<TRoutes extends readonly Route[]> = {
  * });
  * ```
  *
- * @example Array shorthand
- * ```ts
- * export const routes = defineRoutes([{ path: '/', component: () => import('./components/home') }]);
- * ```
+ * @see {@link https://www.rshono.com/docs/routing | Docs — routing}
  */
 export declare function defineRoutes<const TRoutes extends readonly Route[]>(config: RouteConfig<TRoutes> & {
     routes: ValidateRoutes<TRoutes>;
 }): RouteConfig<TRoutes>;
+/**
+ * Array shorthand for {@link defineRoutes} — equivalent to `defineRoutes({ routes })`, for an app
+ * with no `notFound` or `error` page.
+ *
+ * @param routes - The {@link Route} array; each page is checked against its own `path`.
+ * @returns A {@link RouteConfig} wrapping them.
+ *
+ * @example
+ * ```ts
+ * export const routes = defineRoutes([{ path: '/', component: () => import('./components/home') }]);
+ * ```
+ *
+ * @see {@link https://www.rshono.com/docs/routing | Docs — routing}
+ */
 export declare function defineRoutes<const TRoutes extends readonly Route[]>(routes: TRoutes & ValidateRoutes<TRoutes>): RouteConfig<TRoutes>;
 export {};
 //# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"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"}

package/dist/router.js.map

@@ -1 +1 @@
-{"version":3,"file":"router.js","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AA0NA;;;;;;;;;GASG;AACH,MAAM,UAAU,WAAW,CAAC,KAAY;IACtC,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC;AACnC,CAAC;AAwHD,MAAM,UAAU,YAAY,CAAC,KAAqC;IAChE,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAE,KAAqB,CAAC;AAC3E,CAAC","sourcesContent":["import type { Env, Handler } from 'hono';\nimport type { ParamKeys, ParamKeyToRecord } from 'hono/types';\nimport type { ReactNode } from 'react';\n// Type-only, so this stays a build-time module: the import is erased and none of `context.ts`'s\n// runtime machinery (AsyncLocalStorage, hono/cookie) is pulled in by importing `@rshono/core`.\nimport type { RequestContext } from './runtime/context.js';\n\ntype Simplify<T> = { [K in keyof T]: T[K] } & {};\ntype UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;\n\n/**\n * The `params` record implied by a route path pattern — one required `string` key\n * per `:param` segment, `Record<string, never>` for a path with no params.\n *\n * Paths use Hono's syntax, so `:id`, `:id{[0-9]+}` and `*` all work. You rarely\n * name this type directly; {@link PageProps} applies it for you.\n *\n * @typeParam P - The literal route path, e.g. `'/users/:id/posts/:postId'`.\n *\n * @example\n * ```ts\n * type P = PathParams<'/users/:id/posts/:postId'>; // { id: string; postId: string }\n * ```\n */\nexport type PathParams<P extends string> =\n  ParamKeys<P> extends never ? Record<string, never> : Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>>;\n\n/**\n * Props every page component receives. Pass the route's path as the type\n * argument to get `params` typed key-by-key; without it `params` falls back to\n * an open `Record<string, string>`.\n *\n * `defineRoutes` checks each page's props against `PageProps<path>` at compile\n * time, so a mismatched path literal is a type error at the route definition.\n *\n * The location props (`url` and `params`) mirror what a `'use client'` component\n * gets from `useNavigation()` — same names, same types — so moving a read across\n * the server/client line is a copy-paste.\n *\n * @typeParam Path - The literal path this page is mounted at, e.g. `'/profile/:id'`.\n * @typeParam E - The app's Hono {@link Env}, to type {@link RequestContext.var} and\n *   {@link RequestContext.env} on {@link PageProps.ctx}.\n *\n * @example\n * ```tsx\n * import type { PageProps } from '@rshono/core';\n *\n * export default async function Profile({ params, url }: PageProps<'/profile/:id'>) {\n *   const user = await db.getUser(params.id); // params.id is string\n *   const tab = url.searchParams.get('tab') ?? 'overview';\n *   return <Layout>{user.name} — {tab}</Layout>;\n * }\n * ```\n */\nexport interface PageProps<Path extends string = string, E extends Env = Env> {\n  /**\n   * The absolute browser-facing request {@link URL}, proxy-header aware\n   * (`X-Forwarded-Host` / `-Proto`). Read `url.pathname`, `url.searchParams` and\n   * the rest off it.\n   *\n   * A fresh instance per request that nothing else holds, so mutating it is local\n   * to the page — but note it is *not* serializable, so a `'use client'` component\n   * has to be handed `url.href` rather than `url`.\n   *\n   * On a prerendered page it is the build-time URL: a `render: 'static'` route is\n   * rendered once, against `siteUrl` and with no query string, and that one file\n   * then answers every request whatever its own query. So `url.searchParams` is\n   * always empty there — read the query from `useNavigation().url` in a\n   * `'use client'` component instead, or mark the route `render: 'dynamic'`.\n   */\n  url: URL;\n  /** Matched route params for this request, e.g. `{ id: '42' }` for `/profile/:id`. */\n  params: string extends Path ? Record<string, string> : PathParams<Path>;\n  /**\n   * The request context — the very object `getRequestContext()` returns, handed to the\n   * page so cookies, headers, env and middleware variables are reachable without\n   * an import.\n   *\n   * Server-only, and never serialized: React renders a server component and puts\n   * its *output* on the wire, not its props. It is also deliberately a\n   * non-enumerable property, which has three consequences worth knowing:\n   *\n   * - It **cannot be handed to a `'use client'` component** — it wraps the live\n   *   request and response, which do not exist in the browser. Passing it\n   *   explicitly (`<Counter ctx={ctx} />`) fails the render with React's *\"Only\n   *   plain objects … can be passed to Client Components\"*. Read what you need on\n   *   the server and pass plain values down.\n   * - Spreading the page's props instead (`<Counter {...props} />`) drops `ctx`\n   *   silently rather than failing, since the spread copies enumerables only.\n   *   (That spread still fails, mind — on `url`, which is enumerable and just as\n   *   unserializable. Pass the values you need.)\n   * - `Object.keys(props)`, `JSON.stringify(props)` and friends don't see it.\n   *\n   * Reading it on a `render: 'static'` route throws: a prerendered page has no\n   * per-request context at build time. Mark the route `render: 'dynamic'` (or use\n   * the `url` / `params` props, which are available either way — with the\n   * build-time caveats noted on `url`).\n   *\n   * @example\n   * ```tsx\n   * export default function Dashboard({ ctx }: PageProps) {\n   *   const session = ctx.cookies.get('session');\n   *   if (!session) redirect('/login');\n   *   return <Layout>Signed in as {session}</Layout>;\n   * }\n   * ```\n   */\n  ctx: RequestContext<E>;\n}\n\n/**\n * A page: a React **server component** that renders the entire document\n * (`<html>…</html>`), usually via a shared layout. It may be `async` and await\n * data directly.\n *\n * Each page module must default-export exactly one of these. Interactive parts\n * belong in `'use client'` components the page imports — only those ship JS.\n *\n * @typeParam P - The component's props; for a page these are {@link PageProps}.\n */\nexport type PageComponent<P = any> = (props: P) => ReactNode | Promise<ReactNode>;\n\n/**\n * The shape an `{ type: 'endpoint' }` route's server module must have: a single\n * named `handler` export. The module only ever loads on the server, so it is\n * safe to import a database client or read secrets from it.\n *\n * @example\n * ```ts\n * // src/health.ts\n * import type { Handler } from 'hono';\n *\n * export const handler: Handler = (c) => c.json({ ok: true });\n * ```\n */\nexport interface EndpointServerModule {\n  /** A Hono {@link Handler} handling every request matched by the route. */\n  handler: Handler;\n}\n\n/**\n * A page route — a path rendered by a server component. This is the default\n * route kind, so `type` can be omitted.\n *\n * @example\n * ```ts\n * { path: '/profile/:id', component: () => import('./components/profile') }\n * ```\n */\nexport interface PageRoute {\n  /** Discriminates a page from an endpoint; optional because `'page'` is the default. */\n  type?: 'page';\n  /** Hono-style path pattern, e.g. `/`, `/profile/:id`, `/files/*`. */\n  path: string;\n  /**\n   * Dynamic import of the page module, whose default export is the\n   * {@link PageComponent}.\n   *\n   * Write it inline as shown — the framework detects that exact\n   * `() => import('…')` form and injects Rspack's `'use server-entry'`\n   * directive into the module for you (that directive is what attaches the\n   * page's client JS/CSS, giving per-page code splitting). If you wire the\n   * component up any other way — a variable, a barrel re-export, a computed\n   * specifier — add `'use server-entry'` as the first line of the page module\n   * yourself; the framework throws a descriptive error when neither happened.\n   */\n  component: () => Promise<{ default: PageComponent }>;\n  /** `'static'` prerenders the route at build time; `'dynamic'` (the default) renders per request. */\n  render?: 'static' | 'dynamic';\n  /**\n   * For a `render: 'static'` route with params: the param sets to prerender, one\n   * HTML file each. Runs at build time only, on the server, so it may hit a\n   * database or read the filesystem.\n   *\n   * A parameterised static route without `staticPaths` falls back to rendering\n   * per request (with a build warning). Wildcard (`*`), optional and regex\n   * params can't be prerendered.\n   *\n   * @example\n   * ```ts\n   * {\n   *   path: '/docs/:slug',\n   *   render: 'static',\n   *   component: () => import('./components/documentation'),\n   *   staticPaths: async () => (await db.docs.all()).map((d) => ({ slug: d.slug })),\n   * }\n   * ```\n   */\n  staticPaths?: () => Array<Record<string, string>> | Promise<Array<Record<string, string>>>;\n}\n\n/**\n * An endpoint route — a path served by a raw Hono handler instead of a React\n * component. Use it for JSON APIs, webhooks, redirects, feeds, or anything that\n * isn't an HTML page.\n *\n * @example\n * ```ts\n * { type: 'endpoint', path: '/api/health', server: () => import('./health') }\n * ```\n */\nexport interface EndpointRoute {\n  /** Marks this route as an endpoint rather than a page. Required. */\n  type: 'endpoint';\n  /** Hono-style path pattern, e.g. `/api/health`, `/api/users/:id`. */\n  path: string;\n  /** HTTP method to match. Defaults to `'all'` — every method. */\n  method?: HTTPMethod;\n  /** Dynamic import of the {@link EndpointServerModule} exporting `handler`. */\n  server: () => Promise<EndpointServerModule>;\n}\n\n/** HTTP methods an {@link EndpointRoute} can match. `'all'` matches every method. */\nexport type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'options' | 'all';\n\n/** Any entry in the `routes` array: a {@link PageRoute} or an {@link EndpointRoute}. */\nexport type Route = PageRoute | EndpointRoute;\n\n/**\n * Type guard narrowing a {@link Route} to a {@link PageRoute}. Because `type` is\n * optional on page routes, anything not explicitly `'endpoint'` is a page.\n *\n * Framework internal — deliberately absent from `index.ts`, so it is not part of the\n * `@rshono/core` surface. The request renderer and the builder use it to split the\n * route table; an app declares its routes rather than walking them.\n *\n * @internal\n */\nexport function isPageRoute(route: Route): route is PageRoute {\n  return route.type !== 'endpoint';\n}\n\n/**\n * A page the framework falls back to rather than routes to — `notFound` and\n * `error` in {@link RouteConfig}. Same contract as a {@link PageRoute}\n * `component`, without a path of its own.\n */\nexport interface FallbackPage {\n  /** Dynamic import of the page module; its default export is the {@link PageComponent}. */\n  component: () => Promise<{ default: PageComponent }>;\n}\n\n/**\n * The error detail handed to the `error` page. Redacted in production: the\n * message is a generic `'Internal Server Error'` and there is no `stack`. In dev\n * you get the real message plus the stack.\n */\nexport interface ErrorPageInfo {\n  /** The thrown error's message in dev; `'Internal Server Error'` in production. */\n  message: string;\n  /** The stack trace. Present in dev only. */\n  stack?: string;\n}\n\n/**\n * Props for the `error` page declared in {@link RouteConfig.error} — the usual\n * {@link PageProps} plus the redaction-aware {@link ErrorPageInfo}.\n *\n * @typeParam E - The app's Hono {@link Env}, forwarded to {@link PageProps.ctx}.\n *\n * @example\n * ```tsx\n * import type { ErrorPageProps } from '@rshono/core';\n *\n * export default function ServerError({ error }: ErrorPageProps) {\n *   return <html><body><h1>Something went wrong</h1><p>{error.message}</p></body></html>;\n * }\n * ```\n */\nexport type ErrorPageProps<E extends Env = Env> = PageProps<string, E> & { error: ErrorPageInfo };\n\n/**\n * The object form accepted by {@link defineRoutes}: the route table plus the two\n * optional framework-owned pages.\n *\n * @typeParam TRoutes - Inferred tuple of route literals, which is what makes the\n *   per-route `path` → props check possible.\n */\nexport interface RouteConfig<TRoutes extends readonly Route[] = readonly Route[]> {\n  /** Every page and endpoint in the app, matched in order. */\n  routes: TRoutes;\n  /** Page rendered with a 404 status for unmatched paths and for `notFound()` calls. */\n  notFound?: FallbackPage;\n  /** Page rendered with a 500 status when a request throws. Receives {@link ErrorPageProps}. */\n  error?: FallbackPage;\n}\n\n// `PageProps<P, any>`, not `PageProps<P>`: this check is about the *path* matching the page's\n// `params`, and pinning the Env to the default would additionally demand that a page declaring its\n// own (`PageProps<'/x', MyEnv>`, to type `ctx.var`) accept a `RequestContext<Env>` — which it doesn't, so every\n// such page would fail its own route check. `any` makes `ctx` compatible either way.\ntype ValidateRoute<R> = R extends {\n  path: infer P extends string;\n  component: () => Promise<{ default: PageComponent<infer CP> }>;\n}\n  ? [PageProps<P, any>] extends [CP]\n    ? R\n    : R & { component: `component props are not satisfied by PageProps<'${P}'>` }\n  : R;\n\ntype ValidateRoutes<TRoutes extends readonly Route[]> = { [K in keyof TRoutes]: ValidateRoute<TRoutes[K]> };\n\n/**\n * Declares the app's route table. Default-export the result as `routes` from\n * `src/routes.ts` — the one file rshono requires.\n *\n * `routes.ts` only ever runs on the server, so importing server-only modules\n * from it (e.g. inside `staticPaths`) is safe.\n *\n * Beyond typing the config, this cross-checks every page against its own path:\n * if a component's props aren't satisfied by `PageProps<'<its path>'>`, the\n * `component` field errors with `component props are not satisfied by\n * PageProps<'/…'>`. Fix it by matching the page's `PageProps<Path>` type\n * argument to the path it's mounted at.\n *\n * @param config - A {@link RouteConfig}, or a bare {@link Route} array as\n *   shorthand when there are no `notFound` / `error` pages.\n * @returns The config, unchanged and fully typed.\n *\n * @example\n * ```ts\n * // src/routes.ts\n * import { defineRoutes } from '@rshono/core';\n *\n * export const routes = defineRoutes({\n *   routes: [\n *     { path: '/', component: () => import('./components/home') },\n *     { path: '/profile/:id', component: () => import('./components/profile') },\n *     {\n *       path: '/docs/:slug',\n *       render: 'static',\n *       component: () => import('./components/documentation'),\n *       staticPaths: async () => [{ slug: 'getting-started' }, { slug: 'deployment' }],\n *     },\n *     { type: 'endpoint', path: '/api/health', server: () => import('./health') },\n *   ],\n *   notFound: { component: () => import('./components/404') },\n *   error: { component: () => import('./components/500') },\n * });\n * ```\n *\n * @example Array shorthand\n * ```ts\n * export const routes = defineRoutes([{ path: '/', component: () => import('./components/home') }]);\n * ```\n */\nexport function defineRoutes<const TRoutes extends readonly Route[]>(\n  config: RouteConfig<TRoutes> & { routes: ValidateRoutes<TRoutes> },\n): RouteConfig<TRoutes>;\nexport function defineRoutes<const TRoutes extends readonly Route[]>(routes: TRoutes & ValidateRoutes<TRoutes>): RouteConfig<TRoutes>;\nexport function defineRoutes(input: readonly Route[] | RouteConfig): RouteConfig {\n  return Array.isArray(input) ? { routes: input } : (input as RouteConfig);\n}\n"]}
+{"version":3,"file":"router.js","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAqPA;;;;;;;;;GASG;AACH,MAAM,UAAU,WAAW,CAAC,KAAY;IACtC,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC;AACnC,CAAC;AA0ID,MAAM,UAAU,YAAY,CAAC,KAAqC;IAChE,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAE,KAAqB,CAAC;AAC3E,CAAC","sourcesContent":["import type { Env, Handler } from 'hono';\nimport type { ParamKeys, ParamKeyToRecord } from 'hono/types';\nimport type { ReactNode } from 'react';\n// Type-only, so this stays a build-time module: the import is erased and none of `context.ts`'s\n// runtime machinery (AsyncLocalStorage, hono/cookie) is pulled in by importing `@rshono/core`.\nimport type { RequestContext } from './runtime/context.js';\n\ntype Simplify<T> = { [K in keyof T]: T[K] } & {};\ntype UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;\n\n/**\n * The `params` record implied by a route path pattern — one required `string` key\n * per `:param` segment, `Record<string, never>` for a path with no params.\n *\n * Paths use Hono's syntax, so `:id`, `:id{[0-9]+}` and `*` all work. You rarely\n * name this type directly; {@link PageProps} applies it for you.\n *\n * @typeParam P - The literal route path, e.g. `'/users/:id/posts/:postId'`.\n *\n * @example\n * ```ts\n * type P = PathParams<'/users/:id/posts/:postId'>; // { id: string; postId: string }\n * ```\n *\n * @see {@link https://hono.dev/docs/api/routing#path-parameter | Hono — path parameters}\n */\nexport type PathParams<P extends string> =\n  ParamKeys<P> extends never ? Record<string, never> : Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>>;\n\n/**\n * Props every page component receives. Pass the route's path as the type\n * argument to get `params` typed key-by-key; without it `params` falls back to\n * an open `Record<string, string>`.\n *\n * `defineRoutes` checks each page's props against `PageProps<path>` at compile\n * time, so a mismatched path literal is a type error at the route definition.\n *\n * The location props (`url` and `params`) mirror what a `'use client'` component\n * gets from `useNavigation()` — same names, same types — so moving a read across\n * the server/client line is a copy-paste.\n *\n * @typeParam Path - The literal path this page is mounted at, e.g. `'/profile/:id'`.\n * @typeParam E - The app's Hono {@link Env}, to type {@link RequestContext.var} and\n *   {@link RequestContext.env} on {@link PageProps.ctx}.\n *\n * @example\n * ```tsx\n * import type { PageProps } from '@rshono/core';\n *\n * export default async function Profile({ params, url }: PageProps<'/profile/:id'>) {\n *   const user = await db.getUser(params.id); // params.id is string\n *   const tab = url.searchParams.get('tab') ?? 'overview';\n *   return <Layout>{user.name} — {tab}</Layout>;\n * }\n * ```\n *\n * @see {@link https://www.rshono.com/docs/pages#page-props | Docs — page props}\n */\nexport interface PageProps<Path extends string = string, E extends Env = Env> {\n  /**\n   * The absolute browser-facing request {@link URL}, proxy-header aware\n   * (`X-Forwarded-Host` / `-Proto`). Read `url.pathname`, `url.searchParams` and\n   * the rest off it.\n   *\n   * A fresh instance per request that nothing else holds, so mutating it is local\n   * to the page — but note it is *not* serializable, so a `'use client'` component\n   * has to be handed `url.href` rather than `url`.\n   *\n   * On a prerendered page it is the build-time URL: a `render: 'static'` route is\n   * rendered once, against `siteUrl` and with no query string, and that one file\n   * then answers every request whatever its own query. So `url.searchParams` is\n   * always empty there — read the query from `useNavigation().url` in a\n   * `'use client'` component instead, or mark the route `render: 'dynamic'`.\n   */\n  url: URL;\n  /** Matched route params for this request, e.g. `{ id: '42' }` for `/profile/:id`. */\n  params: string extends Path ? Record<string, string> : PathParams<Path>;\n  /**\n   * The request context — the very object `getRequestContext()` returns, handed to the\n   * page so cookies, headers, env and middleware variables are reachable without\n   * an import.\n   *\n   * Server-only and never serialized: React puts a server component's *output* on\n   * the wire, not its props. It is also a deliberately non-enumerable property, so:\n   *\n   * - Handing it to a `'use client'` component (`<Counter ctx={ctx} />`) fails the\n   *   render with React's *\"Only plain objects … can be passed to Client\n   *   Components\"* — it wraps the live request and response, which do not exist in\n   *   the browser. Read what you need here and pass plain values down.\n   * - Spreading the page's props (`<Counter {...props} />`) drops `ctx` silently\n   *   instead, since a spread copies enumerables only. (That spread still fails,\n   *   mind — on `url`, which is enumerable and just as unserializable.)\n   * - `Object.keys(props)`, `JSON.stringify(props)` and friends don't see it.\n   *\n   * Reading it on a `render: 'static'` route throws: a prerendered page has no\n   * per-request context at build time. Mark the route `render: 'dynamic'`, or use\n   * the `url` / `params` props — available either way, with the build-time caveat\n   * noted on `url`.\n   *\n   * @example\n   * ```tsx\n   * export default function Dashboard({ ctx }: PageProps) {\n   *   const session = ctx.cookies.get('session');\n   *   if (!session) redirect('/login');\n   *   return <Layout>Signed in as {session}</Layout>;\n   * }\n   * ```\n   */\n  ctx: RequestContext<E>;\n}\n\n/**\n * A page: a React **server component** that renders the entire document\n * (`<html>…</html>`), usually via a shared layout. It may be `async` and await\n * data directly.\n *\n * Each page module must default-export exactly one of these. Interactive parts\n * belong in `'use client'` components the page imports — only those ship JS.\n *\n * @typeParam P - The component's props; for a page these are {@link PageProps}.\n *\n * @see {@link https://react.dev/reference/rsc/server-components | React — Server Components}\n * @see {@link https://www.rshono.com/docs/pages | Docs — pages}\n */\nexport type PageComponent<P = any> = (props: P) => ReactNode | Promise<ReactNode>;\n\n/**\n * The shape an `{ type: 'endpoint' }` route's server module must have: a single\n * named `handler` export. The module only ever loads on the server, so it is\n * safe to import a database client or read secrets from it.\n *\n * @example\n * ```ts\n * // src/health.ts\n * import type { Handler } from 'hono';\n *\n * export const handler: Handler = (c) => c.json({ ok: true });\n * ```\n *\n * @see {@link https://www.rshono.com/docs/routing#endpoint-routes | Docs — endpoint routes}\n */\nexport interface EndpointServerModule {\n  /**\n   * A Hono {@link Handler} handling every request matched by the route. It is passed Hono's\n   * `Context`, so the request, response builders (`c.json`, `c.text`, `c.body`) and middleware\n   * variables are all reached through it.\n   *\n   * @see {@link https://hono.dev/docs/api/context | Hono — Context}\n   */\n  handler: Handler;\n}\n\n/**\n * A page route — a path rendered by a server component. This is the default\n * route kind, so `type` can be omitted.\n *\n * @example\n * ```ts\n * { path: '/profile/:id', component: () => import('./components/profile') }\n * ```\n */\nexport interface PageRoute {\n  /** Discriminates a page from an endpoint; optional because `'page'` is the default. */\n  type?: 'page';\n  /**\n   * Hono-style path pattern, e.g. `/`, `/profile/:id`, `/files/*`. Routes are matched in\n   * declaration order.\n   *\n   * @see {@link https://hono.dev/docs/api/routing | Hono — routing}\n   */\n  path: string;\n  /**\n   * Dynamic import of the page module, whose default export is the\n   * {@link PageComponent}.\n   *\n   * Write it inline as shown — the framework detects that exact\n   * `() => import('…')` form and injects Rspack's `'use server-entry'`\n   * directive into the module for you (that directive is what attaches the\n   * page's client JS/CSS, giving per-page code splitting). If you wire the\n   * component up any other way — a variable, a barrel re-export, a computed\n   * specifier — add `'use server-entry'` as the first line of the page module\n   * yourself; the framework throws a descriptive error when neither happened.\n   *\n   * @see {@link https://www.rshono.com/docs/pages#the-use-server-entry-directive | Docs — the `'use server-entry'` directive}\n   */\n  component: () => Promise<{ default: PageComponent }>;\n  /** `'static'` prerenders the route at build time; `'dynamic'` (the default) renders per request. */\n  render?: 'static' | 'dynamic';\n  /**\n   * For a `render: 'static'` route with params: the param sets to prerender, one\n   * HTML file each. Runs at build time only, on the server, so it may hit a\n   * database or read the filesystem.\n   *\n   * A parameterised static route without `staticPaths` falls back to rendering\n   * per request (with a build warning). Wildcard (`*`), optional and regex\n   * params can't be prerendered.\n   *\n   * @example\n   * ```ts\n   * {\n   *   path: '/docs/:slug',\n   *   render: 'static',\n   *   component: () => import('./components/documentation'),\n   *   staticPaths: async () => (await db.docs.all()).map((d) => ({ slug: d.slug })),\n   * }\n   * ```\n   *\n   * @see {@link https://www.rshono.com/docs/routing#static-rendering | Docs — static rendering}\n   */\n  staticPaths?: () => Array<Record<string, string>> | Promise<Array<Record<string, string>>>;\n}\n\n/**\n * An endpoint route — a path served by a raw Hono handler instead of a React\n * component. Use it for JSON APIs, webhooks, redirects, feeds, or anything that\n * isn't an HTML page.\n *\n * @example\n * ```ts\n * { type: 'endpoint', path: '/api/health', server: () => import('./health') }\n * ```\n *\n * @see {@link https://www.rshono.com/docs/routing#endpoint-routes | Docs — endpoint routes}\n */\nexport interface EndpointRoute {\n  /** Marks this route as an endpoint rather than a page. Required. */\n  type: 'endpoint';\n  /**\n   * Hono-style path pattern, e.g. `/api/health`, `/api/users/:id`.\n   *\n   * @see {@link https://hono.dev/docs/api/routing | Hono — routing}\n   */\n  path: string;\n  /** HTTP method to match. Defaults to `'all'` — every method. */\n  method?: HTTPMethod;\n  /** Dynamic import of the {@link EndpointServerModule} exporting `handler`. */\n  server: () => Promise<EndpointServerModule>;\n}\n\n/** HTTP methods an {@link EndpointRoute} can match. `'all'` matches every method. */\nexport type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'options' | 'all';\n\n/** Any entry in the `routes` array: a {@link PageRoute} or an {@link EndpointRoute}. */\nexport type Route = PageRoute | EndpointRoute;\n\n/**\n * Type guard narrowing a {@link Route} to a {@link PageRoute}. Because `type` is\n * optional on page routes, anything not explicitly `'endpoint'` is a page.\n *\n * Framework internal — deliberately absent from `index.ts`, so it is not part of the\n * `@rshono/core` surface. The request renderer and the builder use it to split the\n * route table; an app declares its routes rather than walking them.\n *\n * @internal\n */\nexport function isPageRoute(route: Route): route is PageRoute {\n  return route.type !== 'endpoint';\n}\n\n/**\n * A page the framework falls back to rather than routes to — `notFound` and\n * `error` in {@link RouteConfig}. Same contract as a {@link PageRoute}\n * `component`, without a path of its own.\n */\nexport interface FallbackPage {\n  /** Dynamic import of the page module; its default export is the {@link PageComponent}. */\n  component: () => Promise<{ default: PageComponent }>;\n}\n\n/**\n * The error detail handed to the `error` page. Redacted in production: the\n * message is a generic `'Internal Server Error'` and there is no `stack`. In dev\n * you get the real message plus the stack.\n */\nexport interface ErrorPageInfo {\n  /** The thrown error's message in dev; `'Internal Server Error'` in production. */\n  message: string;\n  /** The stack trace. Present in dev only. */\n  stack?: string;\n}\n\n/**\n * Props for the `error` page declared in {@link RouteConfig.error} — the usual\n * {@link PageProps} plus the redaction-aware {@link ErrorPageInfo}.\n *\n * @typeParam E - The app's Hono {@link Env}, forwarded to {@link PageProps.ctx}.\n *\n * @example\n * ```tsx\n * import type { ErrorPageProps } from '@rshono/core';\n *\n * export default function ServerError({ error }: ErrorPageProps) {\n *   return <html><body><h1>Something went wrong</h1><p>{error.message}</p></body></html>;\n * }\n * ```\n */\nexport type ErrorPageProps<E extends Env = Env> = PageProps<string, E> & {\n  /** The error that failed the request, redacted in production — see {@link ErrorPageInfo}. */\n  error: ErrorPageInfo;\n};\n\n/**\n * The object form accepted by {@link defineRoutes}: the route table plus the two\n * optional framework-owned pages.\n *\n * @typeParam TRoutes - Inferred tuple of route literals, which is what makes the\n *   per-route `path` → props check possible.\n *\n * @see {@link https://www.rshono.com/docs/routing#notfound-and-error | Docs — notFound and error pages}\n */\nexport interface RouteConfig<TRoutes extends readonly Route[] = readonly Route[]> {\n  /** Every page and endpoint in the app, matched in order. */\n  routes: TRoutes;\n  /** Page rendered with a 404 status for unmatched paths and for `notFound()` calls. */\n  notFound?: FallbackPage;\n  /** Page rendered with a 500 status when a request throws. Receives {@link ErrorPageProps}. */\n  error?: FallbackPage;\n}\n\n// `PageProps<P, any>`, not `PageProps<P>`: this check is about the *path* matching the page's\n// `params`, and pinning the Env to the default would additionally demand that a page declaring its\n// own (`PageProps<'/x', MyEnv>`, to type `ctx.var`) accept a `RequestContext<Env>` — which it doesn't, so every\n// such page would fail its own route check. `any` makes `ctx` compatible either way.\ntype ValidateRoute<R> = R extends {\n  path: infer P extends string;\n  component: () => Promise<{ default: PageComponent<infer CP> }>;\n}\n  ? [PageProps<P, any>] extends [CP]\n    ? R\n    : R & { component: `component props are not satisfied by PageProps<'${P}'>` }\n  : R;\n\ntype ValidateRoutes<TRoutes extends readonly Route[]> = { [K in keyof TRoutes]: ValidateRoute<TRoutes[K]> };\n\n/**\n * Declares the app's route table. Default-export the result as `routes` from\n * `src/routes.ts` — the one file rshono requires.\n *\n * `routes.ts` only ever runs on the server, so importing server-only modules\n * from it (e.g. inside `staticPaths`) is safe.\n *\n * Beyond typing the config, this cross-checks every page against its own path:\n * if a component's props aren't satisfied by `PageProps<'<its path>'>`, the\n * `component` field errors with `component props are not satisfied by\n * PageProps<'/…'>`. Fix it by matching the page's `PageProps<Path>` type\n * argument to the path it's mounted at.\n *\n * A bare {@link Route} array is accepted as shorthand — see the second overload.\n *\n * @param config - A {@link RouteConfig}: the `routes` array plus the optional\n *   `notFound` and `error` pages.\n * @returns The config, unchanged and fully typed.\n *\n * @example\n * ```ts\n * // src/routes.ts\n * import { defineRoutes } from '@rshono/core';\n *\n * export const routes = defineRoutes({\n *   routes: [\n *     { path: '/', component: () => import('./components/home') },\n *     { path: '/profile/:id', component: () => import('./components/profile') },\n *     {\n *       path: '/docs/:slug',\n *       render: 'static',\n *       component: () => import('./components/documentation'),\n *       staticPaths: async () => [{ slug: 'getting-started' }, { slug: 'deployment' }],\n *     },\n *     { type: 'endpoint', path: '/api/health', server: () => import('./health') },\n *   ],\n *   notFound: { component: () => import('./components/404') },\n *   error: { component: () => import('./components/500') },\n * });\n * ```\n *\n * @see {@link https://www.rshono.com/docs/routing | Docs — routing}\n */\nexport function defineRoutes<const TRoutes extends readonly Route[]>(\n  config: RouteConfig<TRoutes> & { routes: ValidateRoutes<TRoutes> },\n): RouteConfig<TRoutes>;\n/**\n * Array shorthand for {@link defineRoutes} — equivalent to `defineRoutes({ routes })`, for an app\n * with no `notFound` or `error` page.\n *\n * @param routes - The {@link Route} array; each page is checked against its own `path`.\n * @returns A {@link RouteConfig} wrapping them.\n *\n * @example\n * ```ts\n * export const routes = defineRoutes([{ path: '/', component: () => import('./components/home') }]);\n * ```\n *\n * @see {@link https://www.rshono.com/docs/routing | Docs — routing}\n */\nexport function defineRoutes<const TRoutes extends readonly Route[]>(routes: TRoutes & ValidateRoutes<TRoutes>): RouteConfig<TRoutes>;\nexport function defineRoutes(input: readonly Route[] | RouteConfig): RouteConfig {\n  return Array.isArray(input) ? { routes: input } : (input as RouteConfig);\n}\n"]}

package/dist/runtime/boundaries.d.ts

@@ -9,6 +9,7 @@ import { Component, type ReactNode } from 'react';
  * server component, pass a `ReactNode`.
  */
 export type ErrorFallback = ReactNode | ((error: Error, reset: () => void) => ReactNode);
+/** Props for {@link CatchBoundary}. */
 export interface CatchBoundaryProps {
     /**
      * Rendered in place of the children after one of them throws. Omit it to
@@ -24,6 +25,7 @@ export interface CatchBoundaryProps {
      * recover when the user navigates away: `resetKeys={[useNavigation().url.pathname]}`.
      */
     resetKeys?: readonly unknown[];
+    /** The subtree this boundary protects. */
     children: ReactNode;
 }
 interface CatchBoundaryState {
@@ -52,6 +54,9 @@ interface CatchBoundaryState {
  *   <RiskyWidget />
  * </CatchBoundary>
  * ```
+ *
+ * @see {@link https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary | React — error boundaries}
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreclient | Docs — `@rshono/core/client`}
  */
 export declare class CatchBoundary extends Component<CatchBoundaryProps, CatchBoundaryState> {
     state: CatchBoundaryState;
@@ -61,6 +66,7 @@ export declare class CatchBoundary extends Component<CatchBoundaryProps, CatchBo
     reset: () => void;
     render(): ReactNode;
 }
+/** Props for {@link AsyncBoundary}. */
 export interface AsyncBoundaryProps {
     /**
      * Suspense fallback, shown while the children (or their data) are still
@@ -75,6 +81,7 @@ export interface AsyncBoundaryProps {
     onError?: (error: Error) => void;
     /** Clears the error fallback when any value changes — see {@link CatchBoundaryProps.resetKeys}. */
     resetKeys?: readonly unknown[];
+    /** The subtree this boundary suspends on and protects. */
     children: ReactNode;
 }
 /**
@@ -100,6 +107,9 @@ export interface AsyncBoundaryProps {
  *   <SlowServerComponent />
  * </AsyncBoundary>
  * ```
+ *
+ * @see {@link https://react.dev/reference/react/Suspense | React — `<Suspense>`}
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreclient | Docs — `@rshono/core/client`}
  */
 export declare function AsyncBoundary({ loading, error, onError, resetKeys, children }: AsyncBoundaryProps): ReactNode;
 export {};

package/dist/runtime/boundaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundaries.d.ts","sourceRoot":"","sources":["../../src/runtime/boundaries.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAa5D;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,SAAS,CAAC,CAAC;AAEzF,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC/B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,UAAU,kBAAkB;IAC1B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,aAAc,SAAQ,SAAS,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAClF,KAAK,EAAE,kBAAkB,CAAmB;IAE5C,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,kBAAkB,CAEhE;IAED,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAGpC;IAED,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAKjD;IAED,KAAK,QAAO,IAAI,CAEd;IAEF,MAAM,IAAI,SAAS,CASlB;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,OAAO,EAAE,SAAS,CAAC;IACnB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,oCAAoC;IACpC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,mGAAmG;IACnG,SAAS,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC/B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,kBAAkB,GAAG,SAAS,CAM7G"}
+{"version":3,"file":"boundaries.d.ts","sourceRoot":"","sources":["../../src/runtime/boundaries.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAa5D;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,SAAS,CAAC,CAAC;AAEzF,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC/B,0CAA0C;IAC1C,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,UAAU,kBAAkB;IAC1B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,aAAc,SAAQ,SAAS,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAClF,KAAK,EAAE,kBAAkB,CAAmB;IAE5C,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,kBAAkB,CAEhE;IAED,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAGpC;IAED,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAKjD;IAED,KAAK,QAAO,IAAI,CAEd;IAEF,MAAM,IAAI,SAAS,CASlB;CACF;AAED,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,OAAO,EAAE,SAAS,CAAC;IACnB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,oCAAoC;IACpC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,mGAAmG;IACnG,SAAS,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,kBAAkB,GAAG,SAAS,CAM7G"}

package/dist/runtime/boundaries.js

@@ -37,6 +37,9 @@ function keysChanged(a, b) {
  *   <RiskyWidget />
  * </CatchBoundary>
  * ```
+ *
+ * @see {@link https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary | React — error boundaries}
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreclient | Docs — `@rshono/core/client`}
  */
 export class CatchBoundary extends Component {
     state = { error: null };
@@ -93,6 +96,9 @@ export class CatchBoundary extends Component {
  *   <SlowServerComponent />
  * </AsyncBoundary>
  * ```
+ *
+ * @see {@link https://react.dev/reference/react/Suspense | React — `<Suspense>`}
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreclient | Docs — `@rshono/core/client`}
  */
 export function AsyncBoundary({ loading, error, onError, resetKeys, children }) {
     return (_jsx(CatchBoundary, { fallback: error, onError: onError, resetKeys: resetKeys, children: _jsx(Suspense, { fallback: loading, children: children }) }));

package/dist/runtime/boundaries.js.map

@@ -1 +1 @@
-{"version":3,"file":"boundaries.js","sourceRoot":"","sources":["../../src/runtime/boundaries.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;AAEb,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAkB,MAAM,OAAO,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;;GAKG;AACH,SAAS,cAAc,CAAC,KAAc;IACpC,OAAO,eAAe,CAAE,KAAqC,EAAE,MAAM,CAAC,CAAC;AACzE,CAAC;AAmCD,SAAS,WAAW,CAAC,CAAqB,EAAE,CAAqB;IAC/D,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,OAAO,aAAc,SAAQ,SAAiD;IAClF,KAAK,GAAuB,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAE5C,MAAM,CAAC,wBAAwB,CAAC,KAAY;QAC1C,OAAO,EAAE,KAAK,EAAE,CAAC;IACnB,CAAC;IAED,iBAAiB,CAAC,KAAY;QAC5B,IAAI,cAAc,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,sCAAsC;QACzE,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,kBAAkB,CAAC,IAAwB;QACzC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QACjC,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,IAAI,SAAS,IAAI,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;YAC9F,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,CAAC;IACH,CAAC;IAED,KAAK,GAAG,GAAS,EAAE;QACjB,IAAI,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACjC,CAAC,CAAC;IAEF,MAAM;QACJ,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QAC7B,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,IAAI,cAAc,CAAC,KAAK,CAAC;gBAAE,MAAM,KAAK,CAAC,CAAC,sDAAsD;YAC9F,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;YAChC,IAAI,QAAQ,KAAK,SAAS;gBAAE,MAAM,KAAK,CAAC,CAAC,qDAAqD;YAC9F,OAAO,OAAO,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QACjF,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;IAC7B,CAAC;CACF;AAmBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,aAAa,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAsB;IAChG,OAAO,CACL,KAAC,aAAa,IAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,YACpE,KAAC,QAAQ,IAAC,QAAQ,EAAE,OAAO,YAAG,QAAQ,GAAY,GACpC,CACjB,CAAC;AACJ,CAAC","sourcesContent":["'use client';\n\nimport { Component, Suspense, type ReactNode } from 'react';\nimport { isControlDigest } from './control.js';\n\n/**\n * `redirect()` and `notFound()` reach the browser as a thrown error carrying a control digest.\n * They are navigation, not failure, so no boundary may absorb one — otherwise a `redirect()` from\n * a component inside a `<CatchBoundary>` would render \"something went wrong\" instead of navigating.\n * They're re-thrown to the root, where the runtime turns the digest into a real navigation.\n */\nfunction isControlError(error: unknown): boolean {\n  return isControlDigest((error as { digest?: unknown } | null)?.digest);\n}\n\n/**\n * What a {@link CatchBoundary} / {@link AsyncBoundary} renders once a child throws.\n * Either a static node, or a render function that also gets a `reset` callback\n * to clear the error and re-render the children (e.g. a \"Try again\" button).\n *\n * The render-function form only works when the boundary is used from a `'use\n * client'` component — functions can't cross the server→client boundary. From a\n * server component, pass a `ReactNode`.\n */\nexport type ErrorFallback = ReactNode | ((error: Error, reset: () => void) => ReactNode);\n\nexport interface CatchBoundaryProps {\n  /**\n   * Rendered in place of the children after one of them throws. Omit it to\n   * report the error via `onError` and re-throw to the next boundary out (or\n   * the global error page) instead of handling it here.\n   */\n  fallback?: ErrorFallback;\n  /** Called with the caught error (for logging / reporting). */\n  onError?: (error: Error) => void;\n  /**\n   * When any value in this array changes while the boundary is showing its\n   * fallback, the error is cleared automatically. Pass the current pathname to\n   * recover when the user navigates away: `resetKeys={[useNavigation().url.pathname]}`.\n   */\n  resetKeys?: readonly unknown[];\n  children: ReactNode;\n}\n\ninterface CatchBoundaryState {\n  error: Error | null;\n}\n\nfunction keysChanged(a: readonly unknown[], b: readonly unknown[]): boolean {\n  return a.length !== b.length || a.some((value, i) => !Object.is(value, b[i]));\n}\n\n/**\n * A general-purpose error boundary. Catches errors thrown while rendering its\n * children — a client island that blew up, or a server component that rejected\n * on a soft navigation — and renders `fallback` in their place instead of\n * tearing down the whole page.\n *\n * It's a `'use client'` component (React error boundaries must be), so drop it\n * anywhere in the tree from a server or client component. Use {@link AsyncBoundary}\n * when you also want a Suspense loading fallback in the same wrapper.\n *\n * @example\n * ```tsx\n * import { CatchBoundary } from '@rshono/core/client';\n *\n * <CatchBoundary fallback={(error, reset) => (\n *   <div role=\"alert\">\n *     <p>{error.message}</p>\n *     <button onClick={reset}>Try again</button>\n *   </div>\n * )}>\n *   <RiskyWidget />\n * </CatchBoundary>\n * ```\n */\nexport class CatchBoundary extends Component<CatchBoundaryProps, CatchBoundaryState> {\n  state: CatchBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): CatchBoundaryState {\n    return { error };\n  }\n\n  componentDidCatch(error: Error): void {\n    if (isControlError(error)) return; // a redirect isn't an error to report\n    this.props.onError?.(error);\n  }\n\n  componentDidUpdate(prev: CatchBoundaryProps): void {\n    const { resetKeys } = this.props;\n    if (this.state.error && prev.resetKeys && resetKeys && keysChanged(prev.resetKeys, resetKeys)) {\n      this.reset();\n    }\n  }\n\n  reset = (): void => {\n    this.setState({ error: null });\n  };\n\n  render(): ReactNode {\n    const { error } = this.state;\n    if (error !== null) {\n      if (isControlError(error)) throw error; // navigation in flight — never show a fallback for it\n      const { fallback } = this.props;\n      if (fallback === undefined) throw error; // no local fallback → propagate to an outer boundary\n      return typeof fallback === 'function' ? fallback(error, this.reset) : fallback;\n    }\n    return this.props.children;\n  }\n}\n\nexport interface AsyncBoundaryProps {\n  /**\n   * Suspense fallback, shown while the children (or their data) are still\n   * loading. Required — a loading state is the reason to reach for this over\n   * {@link CatchBoundary}, so showing nothing is an explicit `loading={null}`\n   * rather than something you get by leaving the prop off.\n   */\n  loading: ReactNode;\n  /** Error fallback, shown if a child throws. See {@link ErrorFallback}. */\n  error?: ErrorFallback;\n  /** Called with the caught error. */\n  onError?: (error: Error) => void;\n  /** Clears the error fallback when any value changes — see {@link CatchBoundaryProps.resetKeys}. */\n  resetKeys?: readonly unknown[];\n  children: ReactNode;\n}\n\n/**\n * A loading + error boundary in one wrapper — the common case for an async\n * section of a page. It always renders the same shape:\n *\n * ```tsx\n * <CatchBoundary fallback={error}>\n *   <Suspense fallback={loading}>{children}</Suspense>\n * </CatchBoundary>\n * ```\n *\n * so `error` catches anything the children throw (including while suspended) and\n * `loading` shows until they resolve. `error` is optional: omit it and thrown\n * errors propagate to the next boundary out (or the global error page) rather\n * than being caught here.\n *\n * @example\n * ```tsx\n * import { AsyncBoundary } from '@rshono/core/client';\n *\n * <AsyncBoundary loading={<Spinner />} error={(e, reset) => <Retry onClick={reset} />}>\n *   <SlowServerComponent />\n * </AsyncBoundary>\n * ```\n */\nexport function AsyncBoundary({ loading, error, onError, resetKeys, children }: AsyncBoundaryProps): ReactNode {\n  return (\n    <CatchBoundary fallback={error} onError={onError} resetKeys={resetKeys}>\n      <Suspense fallback={loading}>{children}</Suspense>\n    </CatchBoundary>\n  );\n}\n"]}
+{"version":3,"file":"boundaries.js","sourceRoot":"","sources":["../../src/runtime/boundaries.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;AAEb,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAkB,MAAM,OAAO,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;;GAKG;AACH,SAAS,cAAc,CAAC,KAAc;IACpC,OAAO,eAAe,CAAE,KAAqC,EAAE,MAAM,CAAC,CAAC;AACzE,CAAC;AAqCD,SAAS,WAAW,CAAC,CAAqB,EAAE,CAAqB;IAC/D,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,OAAO,aAAc,SAAQ,SAAiD;IAClF,KAAK,GAAuB,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAE5C,MAAM,CAAC,wBAAwB,CAAC,KAAY;QAC1C,OAAO,EAAE,KAAK,EAAE,CAAC;IACnB,CAAC;IAED,iBAAiB,CAAC,KAAY;QAC5B,IAAI,cAAc,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,sCAAsC;QACzE,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,kBAAkB,CAAC,IAAwB;QACzC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QACjC,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,IAAI,SAAS,IAAI,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;YAC9F,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,CAAC;IACH,CAAC;IAED,KAAK,GAAG,GAAS,EAAE;QACjB,IAAI,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACjC,CAAC,CAAC;IAEF,MAAM;QACJ,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QAC7B,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,IAAI,cAAc,CAAC,KAAK,CAAC;gBAAE,MAAM,KAAK,CAAC,CAAC,sDAAsD;YAC9F,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;YAChC,IAAI,QAAQ,KAAK,SAAS;gBAAE,MAAM,KAAK,CAAC,CAAC,qDAAqD;YAC9F,OAAO,OAAO,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QACjF,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;IAC7B,CAAC;CACF;AAqBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,aAAa,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAsB;IAChG,OAAO,CACL,KAAC,aAAa,IAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,YACpE,KAAC,QAAQ,IAAC,QAAQ,EAAE,OAAO,YAAG,QAAQ,GAAY,GACpC,CACjB,CAAC;AACJ,CAAC","sourcesContent":["'use client';\n\nimport { Component, Suspense, type ReactNode } from 'react';\nimport { isControlDigest } from './control.js';\n\n/**\n * `redirect()` and `notFound()` reach the browser as a thrown error carrying a control digest.\n * They are navigation, not failure, so no boundary may absorb one — otherwise a `redirect()` from\n * a component inside a `<CatchBoundary>` would render \"something went wrong\" instead of navigating.\n * They're re-thrown to the root, where the runtime turns the digest into a real navigation.\n */\nfunction isControlError(error: unknown): boolean {\n  return isControlDigest((error as { digest?: unknown } | null)?.digest);\n}\n\n/**\n * What a {@link CatchBoundary} / {@link AsyncBoundary} renders once a child throws.\n * Either a static node, or a render function that also gets a `reset` callback\n * to clear the error and re-render the children (e.g. a \"Try again\" button).\n *\n * The render-function form only works when the boundary is used from a `'use\n * client'` component — functions can't cross the server→client boundary. From a\n * server component, pass a `ReactNode`.\n */\nexport type ErrorFallback = ReactNode | ((error: Error, reset: () => void) => ReactNode);\n\n/** Props for {@link CatchBoundary}. */\nexport interface CatchBoundaryProps {\n  /**\n   * Rendered in place of the children after one of them throws. Omit it to\n   * report the error via `onError` and re-throw to the next boundary out (or\n   * the global error page) instead of handling it here.\n   */\n  fallback?: ErrorFallback;\n  /** Called with the caught error (for logging / reporting). */\n  onError?: (error: Error) => void;\n  /**\n   * When any value in this array changes while the boundary is showing its\n   * fallback, the error is cleared automatically. Pass the current pathname to\n   * recover when the user navigates away: `resetKeys={[useNavigation().url.pathname]}`.\n   */\n  resetKeys?: readonly unknown[];\n  /** The subtree this boundary protects. */\n  children: ReactNode;\n}\n\ninterface CatchBoundaryState {\n  error: Error | null;\n}\n\nfunction keysChanged(a: readonly unknown[], b: readonly unknown[]): boolean {\n  return a.length !== b.length || a.some((value, i) => !Object.is(value, b[i]));\n}\n\n/**\n * A general-purpose error boundary. Catches errors thrown while rendering its\n * children — a client island that blew up, or a server component that rejected\n * on a soft navigation — and renders `fallback` in their place instead of\n * tearing down the whole page.\n *\n * It's a `'use client'` component (React error boundaries must be), so drop it\n * anywhere in the tree from a server or client component. Use {@link AsyncBoundary}\n * when you also want a Suspense loading fallback in the same wrapper.\n *\n * @example\n * ```tsx\n * import { CatchBoundary } from '@rshono/core/client';\n *\n * <CatchBoundary fallback={(error, reset) => (\n *   <div role=\"alert\">\n *     <p>{error.message}</p>\n *     <button onClick={reset}>Try again</button>\n *   </div>\n * )}>\n *   <RiskyWidget />\n * </CatchBoundary>\n * ```\n *\n * @see {@link https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary | React — error boundaries}\n * @see {@link https://www.rshono.com/docs/api#rshonocoreclient | Docs — `@rshono/core/client`}\n */\nexport class CatchBoundary extends Component<CatchBoundaryProps, CatchBoundaryState> {\n  state: CatchBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): CatchBoundaryState {\n    return { error };\n  }\n\n  componentDidCatch(error: Error): void {\n    if (isControlError(error)) return; // a redirect isn't an error to report\n    this.props.onError?.(error);\n  }\n\n  componentDidUpdate(prev: CatchBoundaryProps): void {\n    const { resetKeys } = this.props;\n    if (this.state.error && prev.resetKeys && resetKeys && keysChanged(prev.resetKeys, resetKeys)) {\n      this.reset();\n    }\n  }\n\n  reset = (): void => {\n    this.setState({ error: null });\n  };\n\n  render(): ReactNode {\n    const { error } = this.state;\n    if (error !== null) {\n      if (isControlError(error)) throw error; // navigation in flight — never show a fallback for it\n      const { fallback } = this.props;\n      if (fallback === undefined) throw error; // no local fallback → propagate to an outer boundary\n      return typeof fallback === 'function' ? fallback(error, this.reset) : fallback;\n    }\n    return this.props.children;\n  }\n}\n\n/** Props for {@link AsyncBoundary}. */\nexport interface AsyncBoundaryProps {\n  /**\n   * Suspense fallback, shown while the children (or their data) are still\n   * loading. Required — a loading state is the reason to reach for this over\n   * {@link CatchBoundary}, so showing nothing is an explicit `loading={null}`\n   * rather than something you get by leaving the prop off.\n   */\n  loading: ReactNode;\n  /** Error fallback, shown if a child throws. See {@link ErrorFallback}. */\n  error?: ErrorFallback;\n  /** Called with the caught error. */\n  onError?: (error: Error) => void;\n  /** Clears the error fallback when any value changes — see {@link CatchBoundaryProps.resetKeys}. */\n  resetKeys?: readonly unknown[];\n  /** The subtree this boundary suspends on and protects. */\n  children: ReactNode;\n}\n\n/**\n * A loading + error boundary in one wrapper — the common case for an async\n * section of a page. It always renders the same shape:\n *\n * ```tsx\n * <CatchBoundary fallback={error}>\n *   <Suspense fallback={loading}>{children}</Suspense>\n * </CatchBoundary>\n * ```\n *\n * so `error` catches anything the children throw (including while suspended) and\n * `loading` shows until they resolve. `error` is optional: omit it and thrown\n * errors propagate to the next boundary out (or the global error page) rather\n * than being caught here.\n *\n * @example\n * ```tsx\n * import { AsyncBoundary } from '@rshono/core/client';\n *\n * <AsyncBoundary loading={<Spinner />} error={(e, reset) => <Retry onClick={reset} />}>\n *   <SlowServerComponent />\n * </AsyncBoundary>\n * ```\n *\n * @see {@link https://react.dev/reference/react/Suspense | React — `<Suspense>`}\n * @see {@link https://www.rshono.com/docs/api#rshonocoreclient | Docs — `@rshono/core/client`}\n */\nexport function AsyncBoundary({ loading, error, onError, resetKeys, children }: AsyncBoundaryProps): ReactNode {\n  return (\n    <CatchBoundary fallback={error} onError={onError} resetKeys={resetKeys}>\n      <Suspense fallback={loading}>{children}</Suspense>\n    </CatchBoundary>\n  );\n}\n"]}

package/dist/runtime/client.d.ts

@@ -1,13 +1,15 @@
 /**
  * `@rshono/core/client` — the browser-side surface, for use from `'use client'`
- * modules: {@link useNavigation} for the current URL and soft navigation, and
- * {@link AsyncBoundary} / {@link CatchBoundary} as components.
+ * modules: `useNavigation()` for the current URL and soft navigation, and
+ * `<AsyncBoundary>` / `<CatchBoundary>` as components.
  *
  * Every export is itself a `'use client'` module, so a server component can
- * render {@link AsyncBoundary} directly — but the hook needs a client component. In a
+ * render `<AsyncBoundary>` directly — but the hook needs a client component. In a
  * server component, read the same request data from `getRequestContext()` in
  * `@rshono/core/server`.
  *
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreclient | Docs — `@rshono/core/client`}
+ *
  * @packageDocumentation
  */
 export { useNavigation, type NavigationRouter, type NavigationState } from './navigation.js';

package/dist/runtime/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/runtime/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/runtime/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,aAAa,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC"}