@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.211

package/dist/client/browser-dev.d.ts

@@ -1,5 +1,6 @@
 /**
- * Dev-only browser helpers — server log replay and client error forwarding.
+ * Dev-only browser helpers — server log replay, client error forwarding,
+ * and compiling overlay.
  *
  * These are only active when import.meta.hot is available (Vite dev mode).
  * Extracted from browser-entry.ts to keep files under 500 lines.
@@ -18,12 +19,51 @@ export interface HotInterface {
  * a styled "[SERVER]" badge and call the matching console method.
  */
 export declare function setupServerLogReplay(hot: Pick<HotInterface, 'on'>): void;
+/**
+ * Signal that an HMR/module update has started.
+ *
+ * If an update is already tracked, this increments the counter.
+ * The overlay is shown after SHOW_DELAY_MS to avoid flashing
+ * for fast updates.
+ *
+ * When the delay is 0 (E2E test override), the overlay is shown
+ * synchronously to eliminate the race where hideCompilingOverlay()
+ * clears the show timeout before it fires.
+ */
+export declare function showCompilingOverlay(): void;
+/**
+ * Signal that an HMR/module update has completed.
+ *
+ * When all pending updates are resolved, the overlay is hidden.
+ * If the overlay was never shown (update completed within the
+ * debounce window), the timeout is cleared — no visual flash.
+ *
+ * Test hook: if `window.__timber_hold_compiling_overlay` is true,
+ * the overlay stays visible. E2E tests use this to avoid a race
+ * where the RSC refresh completes between polling intervals,
+ * making the overlay impossible to observe.
+ */
+export declare function hideCompilingOverlay(): void;
 /**
  * Set up global error handlers that forward uncaught client-side
  * errors to the dev server via Vite's HMR channel.
  *
  * The server receives 'timber:client-error' events, and echoes them
  * back as Vite '{ type: "error" }' payloads to trigger the overlay.
+ *
+ * Errors that fire before the Vite HMR WebSocket has connected are
+ * buffered and flushed once the connection is established, so
+ * `hot.send()` never throws `SendBeforeConnectError`. See TIM-1509.
+ */
+export declare function setupClientErrorForwarding(hot: HotInterface): void;
+/**
+ * Detect errors whose `digest` marks them as a framework control-flow signal
+ * (RedirectSignal, DenySignal). These must never surface as dev overlays —
+ * they are expected during navigation and are handled by the error boundary
+ * and router. Exported for tests.
+ *
+ * See also: isControlFlowSignal() in server/signal-identity.ts (server-side,
+ * handles both instanceof and digest detection).
  */
-export declare function setupClientErrorForwarding(hot: Pick<HotInterface, 'send'>): void;
+export declare function isFrameworkSignalError(error: unknown): boolean;
 //# sourceMappingURL=browser-dev.d.ts.map

package/dist/client/browser-dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-dev.d.ts","sourceRoot":"","sources":["../../src/client/browser-dev.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,gDAAgD;AAChD,MAAM,WAAW,YAAY;IAC3B,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1D,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;CAC1C;AAqDD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,GAAG,IAAI,CAwBxE;AAID;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG,IAAI,CA8BhF"}
+{"version":3,"file":"browser-dev.d.ts","sourceRoot":"","sources":["../../src/client/browser-dev.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,gDAAgD;AAChD,MAAM,WAAW,YAAY;IAC3B,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1D,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;CAC1C;AAqDD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,GAAG,IAAI,CAwBxE;AAoED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAmB3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAc3C;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI,CAgElE;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAW9D"}

package/dist/client/browser-entry/action-dispatch.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Server Action Dispatch — registers the callServer callback.
+ *
+ * When React encounters a server reference (from `'use server'` modules),
+ * it calls `callServer(id, args)` to dispatch the action to the server.
+ * The RSC plugin delegates to `globalThis.__viteRscCallServer` which is
+ * set by `setServerCallback`.
+ *
+ * Actions are dispatched sequentially through a client-wide queue
+ * (TIM-1475): each action's POST starts only after the previous one has
+ * settled and its result has been applied. Navigations do not enter the
+ * queue — they preempt via the NavigationEpoch, marking any running
+ * action as discarded (TIM-1474). Queries (TIM-1415) will bypass the
+ * queue entirely.
+ *
+ * See design/08-forms-and-actions.md §"Client-Side Form Mechanics"
+ */
+export declare function setupServerActions(): void;
+//# sourceMappingURL=action-dispatch.d.ts.map

package/dist/client/browser-entry/action-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-dispatch.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/action-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAyBH,wBAAgB,kBAAkB,IAAI,IAAI,CAmMzC"}

package/dist/client/browser-entry/action-queue.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Sequential Action Queue — serialises server action dispatch.
+ *
+ * One action at a time. The next action's POST starts only after the
+ * previous one has settled AND its result has been applied (revalidation
+ * rendered or refresh awaited). Navigations do not enter the queue —
+ * they preempt via the NavigationEpoch. Queries (TIM-1415) bypass it
+ * entirely.
+ *
+ * See design/08-forms-and-actions.md §"Client-Side Form Mechanics"
+ * and design/19-client-navigation.md §State Update Invariants (TIM-1475).
+ */
+export interface ActionQueueDeps {
+    refreshWhenIdle: () => void;
+    /**
+     * Called once when an action's holds exceed `holdTimeoutMs`. The chain
+     * releases regardless; this is the recovery hook. It must not wait on
+     * the same thing the hold is stuck on — in dispatch the hold IS the
+     * router's own refresh/commit, so a deferred `refreshWhenIdle` would
+     * park forever. Dispatch forces a fresh `router.refresh()` instead,
+     * which supersedes the stuck owner (TIM-1485).
+     */
+    recoverStalledHold: () => void;
+    /**
+     * Maximum time (ms) the queue stays blocked on held promises after an
+     * action's result has been returned. A hung hold (e.g. a refresh commit
+     * awaiting a stalled flight stream) would otherwise brick the chain for
+     * the life of the page. `0` disables the guard. Default: 30s.
+     */
+    holdTimeoutMs?: number;
+}
+/**
+ * Passed into `work` so it can return a result to React immediately
+ * while keeping the queue blocked on a side effect (e.g. a refresh
+ * that must commit before the next action captures its epoch).
+ */
+export interface ActionQueueRun {
+    hold: (p: Promise<unknown>) => void;
+}
+export interface ActionQueue {
+    /**
+     * Enqueue `work` to run after all preceding actions have settled.
+     * Returns `work`'s own promise so the caller (React) gets the action
+     * result or rejection. If the preceding action rejected, `work` still
+     * runs — errors do not break the chain.
+     *
+     * `work` receives a `hold` handle: calling `hold(promise)` keeps the
+     * queue blocked until that promise settles, independent of `work`'s
+     * return value. Use it for "return the result NOW, await the refresh
+     * commit for sequencing."
+     */
+    run: <T>(work: (q: ActionQueueRun) => Promise<T>) => Promise<T>;
+    /**
+     * Mark that a discarded action would have revalidated. When the queue
+     * drains, one refresh fires via `deps.refreshWhenIdle`. If the queue is
+     * already idle — a hold settling after its timeout released the chain —
+     * the refresh fires immediately rather than waiting for a future
+     * action's drain (TIM-1485).
+     */
+    markNeedsRefresh: () => void;
+}
+export declare function createActionQueue(deps: ActionQueueDeps): ActionQueue;
+//# sourceMappingURL=action-queue.d.ts.map

package/dist/client/browser-entry/action-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-queue.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/action-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B;;;;;;;OAOG;IACH,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAgCD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;OAUG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAChE;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,IAAI,CAAC;CAC9B;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,WAAW,CAwDpE"}

package/dist/client/browser-entry/hmr.d.ts

@@ -0,0 +1,21 @@
+/**
+ * HMR & Dev Tooling — dev-only wiring for hot module replacement.
+ *
+ * Handles:
+ * - RSC module invalidation (rsc:update → router.refresh())
+ * - Dev warnings forwarded from server via WebSocket
+ * - Server console log replay in browser
+ * - Client error forwarding to Vite error overlay
+ *
+ * See design/21-dev-server.md §"HMR Wiring"
+ */
+import type { RouterInstance } from '#client-internal';
+/**
+ * Set up HMR and dev tool integration.
+ *
+ * Reads `import.meta.hot` to register dev-only event listeners.
+ * In production builds, `import.meta.hot` is undefined and this
+ * function is a no-op.
+ */
+export declare function setupHmr(router: RouterInstance): void;
+//# sourceMappingURL=hmr.d.ts.map

package/dist/client/browser-entry/hmr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/hmr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAavD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAqCrD"}

package/dist/client/browser-entry/hydrate.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Hydration — making the server-rendered page current and hydrating the
+ * React root with it.
+ *
+ * Handles two paths:
+ * 1. RSC payload available: hydrate the router's React root with the payload
+ * 2. No RSC payload: nothing to hydrate — the root is created by the first
+ *    render (client/react-root.ts) — but the page is still made current
+ *
+ * Either way the page becomes current through `RouterInstance.hydrate`, the
+ * same prepare-and-commit every navigation uses, committed before the tree
+ * is handed to React. The one ordering left is that the router exists
+ * before `hydrateRoot()`, so `useRouter()` works during render. Pathname
+ * and search reach the tree as props of its NavigationProvider, from the
+ * router's prepared navState — there is no store to seed first (TIM-1541).
+ *
+ * Params are not part of this sequence either. They arrive on the payload root and
+ * are published by `PayloadRoot` at the top of the tree, so
+ * `useSegmentParams()` is correct during hydration without anything having to
+ * run before it (TIM-1294, TIM-1297).
+ *
+ * See design/19-client-navigation.md §"NavigationContext"
+ */
+import type { ReactRootHost } from '../react-root.ts';
+import type { RscStreamResult } from './rsc-stream.ts';
+import type { RouterInitResult } from './router-init.ts';
+interface HydrateOptions {
+    /** RSC stream result (null if no inlined payload) */
+    rscResult: RscStreamResult | null;
+    /** The router's React root — the one every navigation renders through. */
+    reactRoot: ReactRootHost;
+    /** Makes the page current and builds its tree — see `RouterInitResult.hydrate`. */
+    hydrate: RouterInitResult['hydrate'];
+}
+/**
+ * Make the server-rendered page current, and hydrate the React tree with it
+ * when an RSC payload is available.
+ *
+ * Wraps the payload with the router's chain (NavigationProvider,
+ * TimberNuqsAdapter, the slot content cache, ...) and hydrates the router's
+ * React root with it, on the document.
+ *
+ * When no RSC payload is available (JS-only client) the page is committed
+ * at once and there is nothing to hydrate: the root must not be created at
+ * bootstrap —
+ * `createRoot(document).render()` would take React ownership of the entire
+ * document and blank the SSR HTML — so the router's first render, i.e. the
+ * first navigation or revalidation, creates it with the tree it renders
+ * (`createReactRoot`, TIM-600 / TIM-580).
+ */
+export declare function hydrateApp({ rscResult, reactRoot, hydrate }: HydrateOptions): void;
+export {};
+//# sourceMappingURL=hydrate.d.ts.map

package/dist/client/browser-entry/hydrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/hydrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAwCzD,UAAU,cAAc;IACtB,qDAAqD;IACrD,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;IAClC,0EAA0E;IAC1E,SAAS,EAAE,aAAa,CAAC;IACzB,mFAAmF;IACnF,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;CACtC;AAcD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,cAAc,GAAG,IAAI,CAmClF"}

package/dist/client/browser-entry/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Browser Entry — Client-side hydration and navigation bootstrap.
+ *
+ * This is the thin orchestrator that coordinates the bootstrap sequence.
+ * Each responsibility is extracted into a focused module:
+ *
+ *   action-dispatch.ts  — server action callServer callback
+ *   rsc-stream.ts       — __timber_f chunk handling + ReadableStream
+ *   router-init.ts      — createRouter + Navigation API setup
+ *   hydrate.ts          — makes the server page current + hydrates the root
+ *   post-hydration.ts   — popstate, scroll
+ *   hmr.ts              — dev-only HMR + error forwarding
+ *   scroll.ts           — getScrollY helper
+ *
+ * Bootstrap call order contract:
+ *
+ *   1. setupServerActions()      — register callServer (independent)
+ *   2. createRscPayloadStream()  — decode inlined RSC payload
+ *   3. createReactRoot() +       — the root host the router renders through,
+ *      createTimberRouter()        then the router + Navigation API
+ *   4. hydrateApp()              — make the page current through the router,
+ *                                   hydrate the root (no root without a payload)
+ *   5. setupPostHydration()      — popstate, scroll
+ *   6. setupHmr()                — dev-only HMR wiring
+ *   7. timber-ready signal       — E2E test readiness indicator
+ *
+ * Design docs: 18-build-system.md §"Entry Files", 19-client-navigation.md
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/client/browser-entry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG"}

package/dist/client/browser-entry/post-hydration.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Post-Hydration Wiring — popstate and scroll.
+ *
+ * Sets up everything that needs to happen after the React root exists:
+ * - Initializes scroll state for the initial entry
+ * - Registers popstate handler for back/forward navigation
+ * - Sets up debounced scroll position saving
+ *
+ * The initial page's history entry and segment cache are not written here:
+ * they are the router's, and hydration makes the page current through
+ * `RouterInstance.hydrate` like any other commit (TIM-1541).
+ *
+ * See design/19-client-navigation.md §"History Stack"
+ */
+import type { RouterInstance } from '#client-internal';
+import type { NavigationApiController } from '../navigation-api.ts';
+interface PostHydrationOptions {
+    router: RouterInstance;
+    navApiController: NavigationApiController | null;
+}
+/**
+ * Wire up post-hydration event handlers and state.
+ */
+export declare function setupPostHydration({ router, navApiController }: PostHydrationOptions): void;
+export {};
+//# sourceMappingURL=post-hydration.d.ts.map

package/dist/client/browser-entry/post-hydration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-hydration.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/post-hydration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAIpE,UAAU,oBAAoB;IAC5B,MAAM,EAAE,cAAc,CAAC;IACvB,gBAAgB,EAAE,uBAAuB,GAAG,IAAI,CAAC;CAClD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,EAAE,oBAAoB,GAAG,IAAI,CAsE3F"}

package/dist/client/browser-entry/router-init.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Router Initialization — creates the timber router with all dependencies.
+ *
+ * Wires up RouterDeps (fetch, history, scroll, RSC decoding, render
+ * callbacks) and optionally sets up Navigation API integration.
+ *
+ * See design/19-client-navigation.md §"Navigation API Integration"
+ */
+import type { RouterInstance } from '#client-internal';
+import type { HydrationPage } from '../router-types.ts';
+import type { NavigationRender } from '../navigation-root.tsx';
+import { type NavigationApiController } from '../navigation-api.ts';
+export interface RouterInitOptions {
+    /**
+     * The router's React root (`createReactRoot().render`). Every path that puts
+     * a page on screen renders through it — it is the synchronous transition
+     * around `root.render`, and the `publish` it takes runs on React's commit.
+     */
+    render: NavigationRender;
+    clientSegmentCache?: boolean;
+}
+export interface RouterInitResult {
+    router: RouterInstance;
+    navApiController: NavigationApiController | null;
+    /**
+     * Make the server-rendered page current and hand its tree to React
+     * hydration. `hydrateRoot` receives the tree, built by the same
+     * `renderTree` every navigation renders through. With no payload there is
+     * no tree to hydrate and `hydrateRoot` is not called.
+     */
+    hydrate: (page: HydrationPage, hydrateRoot: (element: React.ReactElement) => void) => void;
+}
+/**
+ * Create and register the global timber router.
+ *
+ * Must be called before hydrateRoot so `useRouter()` works during
+ * the initial render (methods lazily resolve the router at invocation,
+ * not render time, but initRouter must still run first).
+ */
+export declare function createTimberRouter(options: RouterInitOptions): RouterInitResult;
+//# sourceMappingURL=router-init.d.ts.map

package/dist/client/browser-entry/router-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router-init.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/router-init.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAIxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAK9B,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,MAAM,EAAE,gBAAgB,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,gBAAgB,EAAE,uBAAuB,GAAG,IAAI,CAAC;IACjD;;;;;OAKG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,KAAK,IAAI,CAAC;CAC5F;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAwV/E"}

package/dist/client/browser-entry/rsc-stream.d.ts

@@ -0,0 +1,32 @@
+/**
+ * RSC Stream Bootstrap — decodes the server-inlined RSC payload.
+ *
+ * The RSC payload is embedded in the HTML as progressive inline script
+ * tags that call `self.__timber_f.push([type, data])` as RSC chunks arrive.
+ * Typed tuples: [0] = bootstrap signal, [1, string] = Flight data chunk.
+ *
+ * This module sets up a ReadableStream fed by those push() calls so
+ * `createFromReadableStream` can decode the Flight protocol progressively.
+ *
+ * See design/18-build-system.md §"Entry Files"
+ */
+import { type PublishedParams } from '../../shared/payload-root.ts';
+export interface RscStreamResult {
+    /** The decoded RSC element (thenable/lazy — resolved by React during render) */
+    element: unknown;
+    /**
+     * The params the same payload published beside that tree. A promise: the
+     * inlined Flight stream is still arriving when this runs, and hydration must
+     * not wait for it. `PayloadRoot` suspends on it at the position React was
+     * going to suspend on `element` anyway (TIM-1297).
+     */
+    params: Promise<PublishedParams>;
+}
+/**
+ * Create the RSC payload stream from server-inlined `__timber_f` chunks.
+ *
+ * Returns null if no RSC payload was inlined (e.g., JS-only client).
+ * When a payload exists, returns the decoded element for hydration.
+ */
+export declare function createRscPayloadStream(): RscStreamResult | null;
+//# sourceMappingURL=rsc-stream.d.ts.map

package/dist/client/browser-entry/rsc-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc-stream.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/rsc-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAItF,MAAM,WAAW,eAAe;IAC9B,gFAAgF;IAChF,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CAClC;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,eAAe,GAAG,IAAI,CA2G/D"}

package/dist/client/browser-entry/scroll.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Scroll position helpers for the browser entry.
+ *
+ * Reads scroll position from the document viewport or explicitly marked
+ * `data-timber-scroll-restoration` containers.
+ *
+ * See design/19-client-navigation.md §"Overflow Scroll Containers".
+ */
+/**
+ * Read the current scroll position.
+ *
+ * Checks window scroll first, then explicit `data-timber-scroll-restoration`
+ * containers. With segment tree merging, shared layouts are reconciled in
+ * place via `cloneElement` — React preserves their DOM and scroll state
+ * naturally. We don't need to auto-detect overflow containers; only
+ * explicitly marked containers are tracked.
+ */
+/**
+ * Scroll the element matching a URL #fragment into view.
+ *
+ * Mirrors browser anchor behavior: looks up the decoded fragment by id,
+ * then by anchor name. Returns true when a matching element was found and
+ * scrolled; false otherwise (the router falls back to scroll-to-top, same
+ * as a full page load with an unknown fragment). See TIM-1035.
+ */
+export declare function scrollToHashTarget(hash: string): boolean;
+export declare function getScrollY(): number;
+//# sourceMappingURL=scroll.d.ts.map

package/dist/client/browser-entry/scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.d.ts","sourceRoot":"","sources":["../../../src/client/browser-entry/scroll.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;GAQG;AACH;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAaxD;AAED,wBAAgB,UAAU,IAAI,MAAM,CAQnC"}

package/dist/client/deny-last-resort.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The deny chain's terminal, in client form.
+ *
+ * design/10-error-handling.md §"Fallback Chain" ends every chain in the
+ * framework default page. On a document load that page is the HTML string in
+ * `server/default-status-page.ts`. This is the same terminal for a deny that
+ * streamed to the client as an error row and reached the root boundary with
+ * nothing in between able to render it — which happens in exactly one shape:
+ * a server component rendered by a layout's own chrome denied, and no status
+ * file exists at or above that layout. Files *below* the denying layout are
+ * not candidates: rendering any of them means executing that layout again,
+ * which denies again. So there is no user file to show, and this renders the
+ * default one. See TIM-1450, design/04-authorization.md §"Where a Deny Page
+ * Renders".
+ *
+ * A plain reload button, not an automatic navigation: the status and phrase
+ * are already on screen and tell the reader what happened; the button hands
+ * them the one recovery the framework can offer (a document request, which
+ * takes the re-render fallback) without doing it behind their back. An
+ * effect-driven reload could not be told apart from a loop.
+ *
+ * Same content rules as the HTML page: the status code is the only thing
+ * interpolated, and it is clamped by `statusReasonPhrase`. No URL, no error
+ * message, no stack. See design/13-security.md principle 4.
+ */
+export declare function DenyLastResort({ status }: {
+    status: number;
+}): import("react").JSX.Element;
+//# sourceMappingURL=deny-last-resort.d.ts.map

package/dist/client/deny-last-resort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deny-last-resort.d.ts","sourceRoot":"","sources":["../../src/client/deny-last-resort.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,+BAwB5D"}

package/dist/client/error-boundary.d.ts

@@ -3,9 +3,9 @@
  *
  * Catches errors thrown by children and renders a fallback component
  * with the appropriate props based on error type:
- *   - DenySignal (4xx) → { status, dangerouslyPassData }
- *   - RenderError (5xx) → { error, digest, reset }
- *   - Unhandled error → { error, digest: null, reset }
+ *   - DenySignal (4xx) → { status, data }
+ *   - Unhandled error (500) → { error, digest, reset }, where `digest` is the
+ *     ID the server logged the error with (shared/error-digest.ts)
  *
  * The `status` prop controls which errors this boundary catches:
  *   - Specific code (e.g. 403) → only that status
@@ -16,21 +16,50 @@
  * See design/10-error-handling.md §"Status-Code Files"
  */
 import { Component, type ReactNode } from 'react';
+/**
+ * Tracks the chain of segment keys from root to the current boundary.
+ * Each keyed `TimberErrorBoundary` appends its `segmentKey`; unkeyed
+ * slot boundaries pass the parent value through. The claim rule uses
+ * this to find the first *reachable* owner from the `owners` list,
+ * eliminating the owner-below-throw-site escape. See TIM-1450.
+ */
+declare const DenyAncestryContext: import("react").Context<readonly string[]>;
+export { DenyAncestryContext };
 export interface TimberErrorBoundaryProps {
     /** The component to render when an error is caught. */
-    fallbackComponent: (...args: unknown[]) => ReactNode;
+    fallbackComponent?: (...args: unknown[]) => ReactNode;
     /**
      * Status code filter. If set, only catches errors matching this status.
      * 400 = any 4xx, 500 = any 5xx, specific number = exact match.
      */
     status?: number;
     /**
-     * When true, catching a DenySignal sets _denyHandledByBoundary on the
-     * nav context to prevent page-level deny promotion. Only slot catch-all
-     * boundaries should set this — segment boundaries (403.tsx, 4xx.tsx,
-     * error.tsx) must NOT, otherwise normal page denies get swallowed.
+     * When true, this boundary wraps a parallel slot. Slot denials are
+     * graceful degradation: the boundary claims any addressed deny that
+     * reaches it and leaves the page's segment chain unmarked.
      */
     isSlotBoundary?: boolean;
+    /**
+     * Segment key of the segment that declared this boundary. Only meaningful
+     * against a deny digest carrying `owners`. See the decline rule in
+     * `render()` and TIM-1356.
+     */
+    segmentKey?: string;
+    /**
+     * Catch denies only; re-throw everything else. Set on the copy of a
+     * segment's boundaries placed outside its layout, which gives a deny thrown
+     * from that layout's own chrome a catcher keyed to the segment — without
+     * changing where a 5xx from the same chrome goes. See TIM-1450.
+     */
+    denyOnly?: boolean;
+    /**
+     * The deny chain's terminal: the outermost framework boundary, which claims
+     * any deny that streamed past every segment boundary and renders the
+     * framework default page. Implies `denyOnly`. Only a deny thrown from a
+     * layout's chrome with no status file at or above that layout gets here —
+     * the segment copies (`denyOnly`) claim every other shape. See TIM-1450.
+     */
+    lastResort?: boolean;
     children: ReactNode;
 }
 interface TimberErrorBoundaryState {
@@ -40,10 +69,30 @@ interface TimberErrorBoundaryState {
 export declare class TimberErrorBoundary extends Component<TimberErrorBoundaryProps, TimberErrorBoundaryState> {
     constructor(props: TimberErrorBoundaryProps);
     static getDerivedStateFromError(error: Error): TimberErrorBoundaryState;
+    componentDidCatch(error: Error): void;
     componentDidUpdate(prevProps: TimberErrorBoundaryProps): void;
     /** Reset the error state so children re-render. */
     private reset;
+    static contextType: import("react").Context<readonly string[]>;
+    context: readonly string[];
+    private get childAncestry();
     render(): ReactNode;
+    /**
+     * The status page this boundary shows for a row it claimed. Its shape is
+     * the file's documented contract: TSX status files get `{ status,
+     * data }`, `error.tsx` gets `{ error, digest, reset }` (plus
+     * the deny extras for dual-shape implementations — without the error prop,
+     * an error.tsx reading error.message crashes on deny fall-through, TIM-1081).
+     */
+    private renderFallback;
+    /**
+     * A status page (or, for a redirect row, nothing at all) replaced part of
+     * the main route, and the segment cache must not learn a chain that never
+     * mounted; the marker tells the navigation that commits this tree. A boundary that declined in `render()` re-threw
+     * before getting here, so only the boundary that put a page on screen
+     * speaks. A slot degrading leaves the page and its chain intact, so slot
+     * boundaries stay silent. See `status-page-marker.tsx` (TIM-1495).
+     */
+    private markStatusPage;
 }
-export {};
 //# sourceMappingURL=error-boundary.d.ts.map

package/dist/client/error-boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-boundary.d.ts","sourceRoot":"","sources":["../../src/client/error-boundary.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,SAAS,EAAiB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AA6CjE,MAAM,WAAW,wBAAwB;IACvC,uDAAuD;IACvD,iBAAiB,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,SAAS,CAAC;IACrD;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,UAAU,wBAAwB;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAID,qBAAa,mBAAoB,SAAQ,SAAS,CAChD,wBAAwB,EACxB,wBAAwB,CACzB;gBACa,KAAK,EAAE,wBAAwB;IAK3C,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,wBAAwB;IAYvE,kBAAkB,CAAC,SAAS,EAAE,wBAAwB,GAAG,IAAI;IAS7D,mDAAmD;IACnD,OAAO,CAAC,KAAK,CAEX;IAEF,MAAM,IAAI,SAAS;CAyDpB"}
+{"version":3,"file":"error-boundary.d.ts","sourceRoot":"","sources":["../../src/client/error-boundary.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,SAAS,EAA4C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAc5F;;;;;;GAMG;AACH,QAAA,MAAM,mBAAmB,4CAAuC,CAAC;AAEjE,OAAO,EAAE,mBAAmB,EAAE,CAAC;AA8B/B,MAAM,WAAW,wBAAwB;IACvC,uDAAuD;IACvD,iBAAiB,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,SAAS,CAAC;IACtD;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,UAAU,wBAAwB;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAsBD,qBAAa,mBAAoB,SAAQ,SAAS,CAChD,wBAAwB,EACxB,wBAAwB,CACzB;IACC,YAAY,KAAK,EAAE,wBAAwB,EAG1C;IAED,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,wBAAwB,CAUtE;IAED,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAWpC;IAED,kBAAkB,CAAC,SAAS,EAAE,wBAAwB,GAAG,IAAI,CAO5D;IAED,mDAAmD;IACnD,OAAO,CAAC,KAAK,CAEX;IAEF,OAAgB,WAAW,6CAAuB;IAC1C,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAEnC,OAAO,KAAK,aAAa,GAMxB;IAED,MAAM,IAAI,SAAS,CAwIlB;IAED;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAyBtB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;CAIvB"}