@rshono/core 1.0.0-rc.3 → 1.0.0-rc.5

package/dist/runtime/boundaries.js

@@ -5,7 +5,7 @@ import { isControlDigest } from './control.js';
 /**
  * `redirect()` and `notFound()` reach the browser as a thrown error carrying a control digest.
  * They are navigation, not failure, so no boundary may absorb one — otherwise a `redirect()` from
- * a component inside a `<Boundary>` would render "something went wrong" instead of navigating.
+ * a component inside a `<CatchBoundary>` would render "something went wrong" instead of navigating.
  * They're re-thrown to the root, where the runtime turns the digest into a real navigation.
  */
 function isControlError(error) {
@@ -21,24 +21,24 @@ function keysChanged(a, b) {
  * tearing down the whole page.
  *
  * It's a `'use client'` component (React error boundaries must be), so drop it
- * anywhere in the tree from a server or client component. Use {@link Boundary}
+ * anywhere in the tree from a server or client component. Use {@link AsyncBoundary}
  * when you also want a Suspense loading fallback in the same wrapper.
  *
  * @example
  * ```tsx
- * import { ErrorBoundary } from '@rshono/core/client';
+ * import { CatchBoundary } from '@rshono/core/client';
  *
- * <ErrorBoundary fallback={(error, reset) => (
+ * <CatchBoundary fallback={(error, reset) => (
  *   <div role="alert">
  *     <p>{error.message}</p>
  *     <button onClick={reset}>Try again</button>
  *   </div>
  * )}>
  *   <RiskyWidget />
- * </ErrorBoundary>
+ * </CatchBoundary>
  * ```
  */
-export class ErrorBoundary extends Component {
+export class CatchBoundary extends Component {
     state = { error: null };
     static getDerivedStateFromError(error) {
         return { error };
@@ -75,27 +75,26 @@ export class ErrorBoundary extends Component {
  * section of a page. It always renders the same shape:
  *
  * ```tsx
- * <ErrorBoundary fallback={error}>
+ * <CatchBoundary fallback={error}>
  *   <Suspense fallback={loading}>{children}</Suspense>
- * </ErrorBoundary>
+ * </CatchBoundary>
  * ```
  *
  * so `error` catches anything the children throw (including while suspended) and
- * `loading` shows until they resolve. Both fallbacks are optional: omit
- * `loading` and nothing shows while loading; omit `error` and thrown errors
- * propagate to the next boundary out (or the global error page) rather than
- * being caught here.
+ * `loading` shows until they resolve. `error` is optional: omit it and thrown
+ * errors propagate to the next boundary out (or the global error page) rather
+ * than being caught here.
  *
  * @example
  * ```tsx
- * import { Boundary } from '@rshono/core/client';
+ * import { AsyncBoundary } from '@rshono/core/client';
  *
- * <Boundary loading={<Spinner />} error={(e, reset) => <Retry onClick={reset} />}>
+ * <AsyncBoundary loading={<Spinner />} error={(e, reset) => <Retry onClick={reset} />}>
  *   <SlowServerComponent />
- * </Boundary>
+ * </AsyncBoundary>
  * ```
  */
-export function Boundary({ loading = null, error, onError, resetKeys, children }) {
-    return (_jsx(ErrorBoundary, { fallback: error, onError: onError, resetKeys: resetKeys, children: _jsx(Suspense, { fallback: loading, children: children }) }));
+export function AsyncBoundary({ loading, error, onError, resetKeys, children }) {
+    return (_jsx(CatchBoundary, { fallback: error, onError: onError, resetKeys: resetKeys, children: _jsx(Suspense, { fallback: loading, children: children }) }));
 }
 //# sourceMappingURL=boundaries.js.map

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;AAcD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAiB;IAC7F,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 `<Boundary>` 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 an {@link ErrorBoundary} / {@link Boundary} 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 ErrorBoundaryProps {\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 ErrorBoundaryState {\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 Boundary}\n * when you also want a Suspense loading fallback in the same wrapper.\n *\n * @example\n * ```tsx\n * import { ErrorBoundary } from '@rshono/core/client';\n *\n * <ErrorBoundary 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 * </ErrorBoundary>\n * ```\n */\nexport class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {\n  state: ErrorBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): ErrorBoundaryState {\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: ErrorBoundaryProps): 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 BoundaryProps {\n  /** Suspense fallback, shown while the children (or their data) are still loading. */\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 ErrorBoundaryProps.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 * <ErrorBoundary fallback={error}>\n *   <Suspense fallback={loading}>{children}</Suspense>\n * </ErrorBoundary>\n * ```\n *\n * so `error` catches anything the children throw (including while suspended) and\n * `loading` shows until they resolve. Both fallbacks are optional: omit\n * `loading` and nothing shows while loading; omit `error` and thrown errors\n * propagate to the next boundary out (or the global error page) rather than\n * being caught here.\n *\n * @example\n * ```tsx\n * import { Boundary } from '@rshono/core/client';\n *\n * <Boundary loading={<Spinner />} error={(e, reset) => <Retry onClick={reset} />}>\n *   <SlowServerComponent />\n * </Boundary>\n * ```\n */\nexport function Boundary({ loading = null, error, onError, resetKeys, children }: BoundaryProps): ReactNode {\n  return (\n    <ErrorBoundary fallback={error} onError={onError} resetKeys={resetKeys}>\n      <Suspense fallback={loading}>{children}</Suspense>\n    </ErrorBoundary>\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;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"]}

package/dist/runtime/client.d.ts

@@ -1,16 +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 Boundary} / {@link ErrorBoundary} / {@link NavigationProgress} as
- * components.
+ * {@link AsyncBoundary} / {@link CatchBoundary} as components.
  *
  * Every export is itself a `'use client'` module, so a server component can
- * render {@link Boundary} or {@link NavigationProgress} directly — but the hook
- * needs a client component. In a server component, read the same request data
- * from `getContext()` in `@rshono/core/server`.
+ * render {@link AsyncBoundary} directly — but the hook needs a client component. In a
+ * server component, read the same request data from `getRequestContext()` in
+ * `@rshono/core/server`.
  *
  * @packageDocumentation
  */
-export { NavigationProgress, useNavigation, type Navigation, type NavigationProgressProps, type Router } from './navigation.js';
-export { Boundary, ErrorBoundary, type BoundaryProps, type ErrorBoundaryProps, type ErrorFallback } from './boundaries.js';
+export { useNavigation, type NavigationRouter, type NavigationState } from './navigation.js';
+export { AsyncBoundary, CatchBoundary, type AsyncBoundaryProps, type CatchBoundaryProps, type ErrorFallback } from './boundaries.js';
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/runtime/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,KAAK,UAAU,EAAE,KAAK,uBAAuB,EAAE,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAChI,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,aAAa,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;;;;;;;;;;;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"}

package/dist/runtime/client.js

@@ -1,16 +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 Boundary} / {@link ErrorBoundary} / {@link NavigationProgress} as
- * components.
+ * {@link AsyncBoundary} / {@link CatchBoundary} as components.
  *
  * Every export is itself a `'use client'` module, so a server component can
- * render {@link Boundary} or {@link NavigationProgress} directly — but the hook
- * needs a client component. In a server component, read the same request data
- * from `getContext()` in `@rshono/core/server`.
+ * render {@link AsyncBoundary} directly — but the hook needs a client component. In a
+ * server component, read the same request data from `getRequestContext()` in
+ * `@rshono/core/server`.
  *
  * @packageDocumentation
  */
-export { NavigationProgress, useNavigation } from './navigation.js';
-export { Boundary, ErrorBoundary } from './boundaries.js';
+export { useNavigation } from './navigation.js';
+export { AsyncBoundary, CatchBoundary } from './boundaries.js';
 //# sourceMappingURL=client.js.map

package/dist/runtime/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/runtime/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAA8D,MAAM,iBAAiB,CAAC;AAChI,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAmE,MAAM,iBAAiB,CAAC","sourcesContent":["/**\n * `@rshono/core/client` — the browser-side surface, for use from `'use client'`\n * modules: {@link useNavigation} for the current URL and soft navigation, and\n * {@link Boundary} / {@link ErrorBoundary} / {@link NavigationProgress} as\n * components.\n *\n * Every export is itself a `'use client'` module, so a server component can\n * render {@link Boundary} or {@link NavigationProgress} directly — but the hook\n * needs a client component. In a server component, read the same request data\n * from `getContext()` in `@rshono/core/server`.\n *\n * @packageDocumentation\n */\n\nexport { NavigationProgress, useNavigation, type Navigation, type NavigationProgressProps, type Router } from './navigation.js';\nexport { Boundary, ErrorBoundary, type BoundaryProps, type ErrorBoundaryProps, type ErrorFallback } from './boundaries.js';\n"]}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/runtime/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAA+C,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,aAAa,EAAwE,MAAM,iBAAiB,CAAC","sourcesContent":["/**\n * `@rshono/core/client` — the browser-side surface, for use from `'use client'`\n * modules: {@link useNavigation} for the current URL and soft navigation, and\n * {@link AsyncBoundary} / {@link CatchBoundary} as components.\n *\n * Every export is itself a `'use client'` module, so a server component can\n * render {@link AsyncBoundary} directly — but the hook needs a client component. In a\n * server component, read the same request data from `getRequestContext()` in\n * `@rshono/core/server`.\n *\n * @packageDocumentation\n */\n\nexport { useNavigation, type NavigationRouter, type NavigationState } from './navigation.js';\nexport { AsyncBoundary, CatchBoundary, type AsyncBoundaryProps, type CatchBoundaryProps, type ErrorFallback } from './boundaries.js';\n"]}

package/dist/runtime/context.d.ts

@@ -1,5 +1,5 @@
 /**
- * The request context: {@link getContext} and the {@link Ctx} wrapper it returns,
+ * The request context: {@link getRequestContext} and the {@link RequestContext} wrapper it returns,
  * the {@link redirect} / {@link notFound} control-flow helpers, and the
  * {@link onServerError} reporting funnel — plus the `@internal` plumbing that binds
  * a request to the async context in the first place.
@@ -9,7 +9,7 @@
  * here is safe in a `'use client'` module — those run in the browser, with no bound
  * request context.
  */
-import type { Context, Env, HonoRequest } from 'hono';
+import type { Context, Env } from 'hono';
 import type { CookieOptions } from 'hono/utils/cookie';
 /**
  * HTTP status codes accepted by {@link redirect}.
@@ -22,21 +22,21 @@ import type { CookieOptions } from 'hono/utils/cookie';
 export type RedirectStatus = 301 | 302 | 303 | 307 | 308;
 /**
  * Runs `fn` with the given Hono {@link Context} bound as the ambient request
- * context, so that {@link getContext} resolves to it anywhere in the call tree.
+ * context, so that {@link getRequestContext} resolves to it anywhere in the call tree.
  *
  * Framework internal — the request handler wraps every render and action in
- * this. Application code should reach for {@link getContext} instead.
+ * this. Application code should reach for {@link getRequestContext} instead.
  *
  * @internal
  */
 export declare function runWithContext<T>(c: Context, fn: () => T): T;
 /**
  * Reads the matched route params, returning an empty object when there is no
- * active route match (rather than throwing). Shared by {@link Ctx.params} and the
- * request renderer so the fallback behaviour stays in one place.
+ * active route match (rather than throwing), so the fallback behaviour stays in
+ * one place.
  *
- * Framework internal — read params from {@link Ctx.params} or a page's
- * `PageProps` instead.
+ * Framework internal — the request renderer calls this to build a page's `params`
+ * prop. Read them from that prop (or `ctx.raw.req.param()` outside a page) instead.
  *
  * @internal
  */
@@ -51,7 +51,7 @@ export declare function readParams(c: Context): Record<string, string>;
  * dictate the origin of every absolute URL the app builds — canonical tags, emails, redirects — and
  * poison a shared cache with them. So the default is to ignore them entirely.
  *
- * Framework internal — prefer {@link Ctx.url}, which caches the result per request.
+ * Framework internal — prefer {@link RequestContext.url}, which caches the result per request.
  *
  * @internal
  */
@@ -59,49 +59,52 @@ export declare function publicUrl(c: Context): URL;
 /**
  * The environment available to a request: Cloudflare/Workers `Bindings` merged
  * with process env vars. Values not declared in `Bindings` are typed as
- * `string | undefined`. See {@link Ctx.env}.
+ * `string | undefined`. See {@link RequestContext.env}.
  */
 export type EnvVars<E extends Env> = E['Bindings'] & Record<string, string | undefined>;
 /**
  * Ergonomic, read-mostly wrapper around Hono's {@link Context} for use inside
  * server components and server actions.
  *
- * Obtain one with {@link getContext}, or — in a page component — take it straight
+ * Obtain one with {@link getRequestContext}, or — in a page component — take it straight
  * off the `ctx` prop, which is this same object. Never construct it yourself. One
  * instance is reused for the lifetime of a request, so its lazy getters
- * ({@link Ctx.url}, {@link Ctx.env}) are computed at most once.
+ * ({@link RequestContext.url}, {@link RequestContext.env}) are computed at most once.
  *
  * @typeParam E - The Hono {@link Env} describing this app's `Bindings` and
- *   `Variables`, so {@link Ctx.var} and {@link Ctx.env} stay typed.
+ *   `Variables`, so {@link RequestContext.var} and {@link RequestContext.env} stay typed.
  *
  * @example
  * ```tsx
- * import { getContext } from '@rshono/core/server';
+ * import { getRequestContext } from '@rshono/core/server';
  *
  * export default async function Whoami() {
- *   const ctx = getContext();
+ *   const ctx = getRequestContext();
  *   const session = ctx.cookies.get('session');
  *   return <p>{ctx.url.pathname} — {session ?? 'anonymous'}</p>;
  * }
  * ```
  */
-export declare class Ctx<E extends Env = Env> {
+export declare class RequestContext<E extends Env = Env> {
     #private;
     constructor(c: Context<E>);
     /**
-     * The underlying Hono {@link Context}. Escape hatch for anything this wrapper does not expose.
+     * The underlying Hono {@link Context}. Escape hatch for anything this wrapper does not expose — and
+     * deliberately most things. `req`, `method`, `params` and a `header()` setter used to sit on this class
+     * as one-line pass-throughs to `c.req`, `c.req.method`, `c.req.param()` and `c.header()`; they are
+     * reachable through here (`ctx.raw.req`, `ctx.raw.header(…)`) and adding no name of their own is the
+     * point. What stays below is what this wrapper actually *does*: a proxy-aware cached URL, an env that
+     * merges runtime bindings over process env, and cookies without a second import.
      *
      * A getter over a private field rather than a plain property, so it is not an *own enumerable*
      * one — which matters more than it looks. React's diagnostic for a value that cannot be sent to a
      * client component (`describeObjectForErrorMessage`) walks `Object.keys` recursively with no depth
      * limit and no cycle guard, and the Hono context graph reaches the socket and the whole server
-     * through `req.raw` and `env`. While this was a plain property, passing a `Ctx` to a `'use client'`
+     * through `req.raw` and `env`. While this was a plain property, passing a `RequestContext` to a `'use client'`
      * component blew the stack *inside that message builder* — so React's actual, accurate "you cannot
      * pass this" error never got printed. Hidden from `Object.keys`, the walk stops here.
      */
     get raw(): Context<E>;
-    /** The parsed Hono request (`c.req`) — headers, body parsing, param access, etc. */
-    get req(): HonoRequest;
     /**
      * The browser-facing request URL, proxy-header aware (see {@link publicUrl}) —
      * read `url.pathname`, `url.searchParams` and the rest off it. Parsed once and
@@ -109,13 +112,6 @@ export declare class Ctx<E extends Env = Env> {
      * it as read-only for that reason.
      */
     get url(): URL;
-    /** The HTTP method of the request, e.g. `GET` or `POST`. */
-    get method(): string;
-    /**
-     * Matched route params, e.g. `{ id }` for a `/users/[id]` route. Returns an
-     * empty object when there is no active route match (rather than throwing).
-     */
-    get params(): Record<string, string>;
     /**
      * Typed variables set by middleware via `c.set('user', …)`, read here as
      * `ctx.var.user`. Type them by parameterising this class's {@link Env}.
@@ -125,17 +121,15 @@ export declare class Ctx<E extends Env = Env> {
      * Environment for the request: process env vars merged with runtime bindings
      * (bindings win on conflict). Computed once and cached.
      *
-     * @example `const key = getContext().env.STRIPE_SECRET_KEY;`
+     * @example `const key = getRequestContext().env.STRIPE_SECRET_KEY;`
      */
     get env(): EnvVars<E>;
-    /** Sets a response header. Thin pass-through to `c.header(name, value)`. */
-    header(name: string, value: string): void;
     /**
      * Read and write request/response cookies.
      *
      * @example
      * ```ts
-     * const ctx = getContext();
+     * const ctx = getRequestContext();
      * ctx.cookies.get('session');                       // string | undefined
      * ctx.cookies.set('session', id, { httpOnly: true, sameSite: 'Lax', path: '/' });
      * ctx.cookies.delete('session', { path: '/' });
@@ -153,7 +147,7 @@ export declare class Ctx<E extends Env = Env> {
     };
 }
 /**
- * Returns the {@link Ctx} for the current request.
+ * Returns the {@link RequestContext} for the current request.
  *
  * This is the primary entry point for reading request data from a server
  * component or server action — the URL, cookies, params, env, and middleware
@@ -164,7 +158,7 @@ export declare class Ctx<E extends Env = Env> {
  * import is for everywhere else: a nested server component, or a `'use server'`
  * action module — neither of which receives props from the framework.
  *
- * @typeParam E - The app's Hono {@link Env}, to type {@link Ctx.var} and {@link Ctx.env}.
+ * @typeParam E - The app's Hono {@link Env}, to type {@link RequestContext.var} and {@link RequestContext.env}.
  * @throws If called at module load, where there is no ambient context to resolve.
  * @throws If called while prerendering a `render: 'static'` route, which has no
  *   per-request context at build time — mark the route `render: 'dynamic'` instead.
@@ -172,15 +166,15 @@ export declare class Ctx<E extends Env = Env> {
  * @example
  * ```ts
  * 'use server';
- * import { getContext, redirect } from '@rshono/core/server';
+ * import { getRequestContext, redirect } from '@rshono/core/server';
  *
  * export async function login(form: FormData) {
- *   getContext().cookies.set('session', String(form.get('email')), { httpOnly: true });
+ *   getRequestContext().cookies.set('session', String(form.get('email')), { httpOnly: true });
  *   redirect('/dashboard');
  * }
  * ```
  */
-export declare function getContext<E extends Env = Env>(): Ctx<E>;
+export declare function getRequestContext<E extends Env = Env>(): RequestContext<E>;
 /**
  * Redirects the request to `location` by throwing a control signal that the
  * framework catches and turns into an HTTP redirect response.
@@ -195,7 +189,7 @@ export declare function getContext<E extends Env = Env>(): Ctx<E>;
  *
  * @example
  * ```ts
- * const session = getContext().cookies.get('session');
+ * const session = getRequestContext().cookies.get('session');
  * if (!session) redirect('/login');
  * // session is defined below this line
  * ```
@@ -209,9 +203,11 @@ export declare function redirect(location: string, status?: RedirectStatus): nev
  *
  * @example
  * ```tsx
- * const user = await db.user.find(getContext().params.id);
- * if (!user) notFound();
- * return <Profile user={user} />; // user is non-null here
+ * export default async function Page({ params }: PageProps<'/users/:id'>) {
+ *   const user = await db.user.find(params.id);
+ *   if (!user) notFound();
+ *   return <Profile user={user} />; // user is non-null here
+ * }
  * ```
  */
 export declare function notFound(): never;

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

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