@timber-js/app 0.2.0-alpha.2 → 0.2.0-alpha.200

package/dist/client/segment-cache.d.ts

@@ -1,12 +1,23 @@
-import type { HeadElement } from './head';
-/** A prefetched RSC result with optional head elements and segment metadata. */
+import type { PublishedParams } from '../shared/payload-root.ts';
+import type { SegmentInfo, StateTree } from '../shared/segment-info.ts';
+/** A prefetched RSC result with optional segment metadata. */
 export interface PrefetchResult {
     payload: unknown;
-    headElements: HeadElement[] | null;
+    /**
+     * Completion of the full Flight stream, when the prefetch is still decoding.
+     * Carried through to the navigation that consumes the entry so a decode
+     * failure reaches *that* navigation's recovery rather than dying with the
+     * prefetch (TIM-1275).
+     */
+    decodePromise?: Promise<void> | null;
     /** Segment metadata from X-Timber-Segments header for populating the segment cache. */
     segmentInfo?: SegmentInfo[] | null;
-    /** Route params from X-Timber-Params header for populating useParams(). */
-    params?: Record<string, string | string[]> | null;
+    /**
+     * The params published beside `payload`, split off the same payload root.
+     * Carried so a consumed prefetch publishes the params of the tree it is
+     * about to render, and not the ones already on screen.
+     */
+    params?: PublishedParams | Promise<PublishedParams>;
     /** Segment paths skipped by the server (for client-side merging). */
     skippedSegments?: string[] | null;
 }
@@ -17,19 +28,33 @@ export interface PrefetchResult {
 export interface SegmentNode {
     /** The segment's URL pattern (e.g., "/", "/dashboard", "/projects/[id]") */
     segment: string;
+    /**
+     * The segment's `app/` directory path, groups included (e.g. `/(browse)/feed`).
+     * Undefined for slot nodes and for servers that predate the field.
+     */
+    treePath?: string;
     /** The RSC flight payload for this segment (opaque to the cache) */
     payload: unknown;
-    /** Whether the segment is async (async layouts always re-render on navigation) */
-    isAsync: boolean;
+    /**
+     * Whether the segment/slot is request-dependent (calls getHeaders,
+     * getSearchParams, cookies, etc.). Request-dependent segments always
+     * re-render on navigation. For segments, this is still based on the
+     * AsyncFunction heuristic (to be replaced separately). For slots,
+     * this is taint-tracked via ALS.
+     */
+    isRequestDependent: boolean;
     /** Child segments keyed by segment path */
     children: Map<string, SegmentNode>;
-}
-/**
- * Serialized state tree sent via X-Timber-State-Tree header.
- * Only sync segments are included — async segments always re-render.
- */
-export interface StateTree {
-    segments: string[];
+    /** Parallel route slots keyed by slot path (e.g., "/@sidebar") */
+    slots?: Map<string, SegmentNode>;
+    /** Whether this slot's access.ts denied on its last render. */
+    denied?: boolean;
+    /**
+     * Content key for slot nodes — opaque string the server computed from
+     * owner parts, slot name, entry file, and slot params. Advertised back
+     * to the server so it can decide skips by key membership (TIM-1370).
+     */
+    contentKey?: string;
 }
 /**
  * Maintains the client-side segment tree representing currently mounted
@@ -51,19 +76,18 @@ export declare class SegmentCache {
      * client can actually merge (i.e., segments whose cached element tree
      * contains an inner SegmentProvider the merger can splice into).
      *
+     * `treePaths` is collected UNFILTERED, unlike `segments` and `slots`. Those
+     * two answer "what may the server skip re-rendering?", so every reason a
+     * segment cannot be reused is a reason to leave it out. `treePaths` answers
+     * "what is mounted right now?" for interception scoping — a request-dependent
+     * layout is still on screen, and dropping it would silently narrow the scope
+     * the server sees and cancel a modal that should open (TIM-1282).
+     *
      * This is a performance optimization only, NOT a security boundary.
      * The server always runs all access.ts files regardless of the state tree.
      */
     serializeStateTree(mergeableFilter?: Set<string>): StateTree;
 }
-/**
- * Segment metadata from the server, sent via X-Timber-Segments header.
- * Describes a rendered segment's path and whether it's async.
- */
-export interface SegmentInfo {
-    path: string;
-    isAsync: boolean;
-}
 /**
  * Build a SegmentNode tree from flat segment metadata.
  *
@@ -76,20 +100,132 @@ export interface SegmentInfo {
  * from the tree — pages are never cached across navigations.
  */
 export declare function buildSegmentTree(segments: SegmentInfo[]): SegmentNode | undefined;
+/**
+ * Identifies a prefetched payload. A payload is addressed by *every* input that
+ * changes the server's answer, not by the destination alone.
+ *
+ * The server's answer for a destination depends on where the request came
+ * from — that is the whole mechanism behind intercepting routes, and it also
+ * drives slot-skip resolution. A prefetch issued from `/gallery` is a modal
+ * payload; the same URL prefetched from `/` is the full page. Keying on the
+ * destination alone let the first click after a hover be answered with
+ * whichever variant happened to be fetched (TIM-1265).
+ *
+ * `from` alone stopped being enough in TIM-1282. It is a pathname, and once
+ * interception scope comes from the rendered tree rather than the address, one
+ * pathname no longer names one source tree: `/photo/1` is the address both for
+ * a modal open over `(browse)` and for `(landing)`'s canonical page. A key
+ * without the scope hands the modal payload to the canonical page's click,
+ * which renders it without the server's scope check ever running.
+ *
+ * The two reads happen at different instants — `scope` is sampled at hover and
+ * again at click — which is why a tree that changed in between produces a
+ * *miss* and a refetch rather than a wrong hit.
+ */
+export interface PrefetchKey {
+    /** Destination URL — hash-less `pathname + search`, as navigate() fetches it. */
+    url: string;
+    /** Departing pathname — the `X-Timber-URL` the prefetch was issued with. */
+    from: string;
+    /**
+     * The rendered scope the prefetch was issued with — the `treePaths` half of
+     * `X-Timber-State-Tree`, joined. Empty when none crossed.
+     */
+    scope: string;
+}
+/**
+ * The `scope` half of a `PrefetchKey`, derived from the state tree that will
+ * actually be sent. Taking it from the header value rather than re-walking the
+ * cache is the point: the key varies by exactly what the request varies by.
+ */
+export declare function prefetchScopeOf(stateTree: StateTree | undefined): string;
+/** Outcome of a prefetch flight — discriminated so NonRscResponse is a
+ *  success (stores a negative entry) rather than a rejection. */
+export type FlightOutcome = {
+    kind: 'ready';
+    result: PrefetchResult;
+} | {
+    kind: 'non-route';
+};
 /**
  * Short-lived cache for hover-triggered prefetches. Entries expire after
  * 30 seconds. When a link is clicked, the prefetched payload is consumed
  * (moved to the history stack) and removed from this cache.
  *
+ * In-flight dedup (TIM-1438): concurrent fetches for the same key are
+ * coalesced by a `createSingleflight` instance. A hover starts a flight;
+ * a click for the same key joins it instead of issuing a duplicate. The
+ * singleflight enforces a 5-second timeout and cleans up automatically
+ * on settlement.
+ *
  * timber.js does NOT prefetch on viewport intersection — only explicit
  * hover on <Link prefetch> triggers a prefetch.
  */
 export declare class PrefetchCache {
     private static readonly TTL_MS;
     private entries;
-    set(url: string, result: PrefetchResult): void;
-    get(url: string): PrefetchResult | undefined;
+    private flights;
+    private evictionGen;
+    set(key: PrefetchKey, result: PrefetchResult): void;
+    get(key: PrefetchKey): PrefetchResult | undefined;
+    /** True if a ready or negative entry exists for this key. */
+    has(key: PrefetchKey): boolean;
     /** Get and remove the entry (used when navigation consumes a prefetch) */
-    consume(url: string): PrefetchResult | undefined;
+    consume(key: PrefetchKey): PrefetchResult | undefined;
+    /**
+     * Fetch or coalesce with an in-flight fetch for this key (TIM-1438).
+     *
+     * Concurrent callers (hover + click, repeated hovers) get the same
+     * promise. On success the result is stored as a ready entry. On
+     * NonRscResponse a negative entry is stored and the outcome is
+     * `{ kind: 'non-route' }`. Other errors (network, version skew)
+     * reject — the singleflight cleans up the key and subsequent callers
+     * retry.
+     *
+     * The singleflight signal is passed to `doFetch` so a timed-out flight
+     * aborts the underlying fetch rather than leaving it running.
+     */
+    fetchOrCoalesce(key: PrefetchKey, doFetch: (signal: AbortSignal) => Promise<PrefetchResult>, isNonRoute: (error: unknown) => boolean): Promise<FlightOutcome>;
+    /**
+     * Join an in-flight singleflight fetch if one exists for this key.
+     * Returns the in-flight promise or undefined. Used by the click path to
+     * coalesce with a hover prefetch without starting a new flight — when no
+     * flight exists, the click issues its own fetch with the navigation's
+     * abort signal so superseded navigations abort immediately (TIM-1438).
+     */
+    joinInflight(key: PrefetchKey): Promise<FlightOutcome> | undefined;
+    /**
+     * Store a negative entry — the URL is not a route (non-RSC Content-Type).
+     *
+     * Keyed like every other entry even though "not a route" does not actually
+     * vary by departing URL: a source-independent negative would be a second
+     * keying rule to keep correct, and the only cost of the uniform one is a
+     * repeated fetch for a link hovered from a second page.
+     */
+    setNegative(key: PrefetchKey): void;
+    /** Check if the entry is a negative cache entry (URL is not a route). */
+    isNegative(key: PrefetchKey): boolean;
+    /**
+     * Invalidate all entries whose destination URL matches (TIM-1454).
+     * Used by `revalidatePath` on a non-current route so the next navigation
+     * fetches fresh data instead of replaying a stale prefetch.
+     */
+    invalidateUrl(url: string): void;
+    /**
+     * Evict all ready entries and fence in-flight singleflights (TIM-1476).
+     * Called after a server action that revalidated data — the mutation may
+     * affect any route, not just the paths the server named. In-flight
+     * singleflights are not aborted (they may carry post-mutation data),
+     * but their results are discarded if they complete after eviction:
+     * `fetchOrCoalesce` captures the generation before the flight and
+     * skips the store when it has been bumped.
+     *
+     * Consumers that join an in-flight flight via `joinInflight` must
+     * check `getEvictionGen()` before and after the await: if the gen
+     * changed, the result predates the eviction and must be discarded
+     * (codex on #1131 round 2).
+     */
+    clearReady(): void;
+    getEvictionGen(): number;
 }
 //# sourceMappingURL=segment-cache.d.ts.map

package/dist/client/segment-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment-cache.d.ts","sourceRoot":"","sources":["../../src/client/segment-cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAI1C,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IACnC,uFAAuF;IACvF,WAAW,CAAC,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IACnC,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IAClD,qEAAqE;IACrE,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CACnC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,OAAO,EAAE,OAAO,CAAC;IACjB,kFAAkF;IAClF,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAID;;;;GAIG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,IAAI,CAA0B;IAEtC,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAO7C,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI;IAM7C,KAAK,IAAI,IAAI;IAIb;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,SAAS;CAO7D;AAkBD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,WAAW,GAAG,SAAS,CA+BjF;AASD;;;;;;;GAOG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAU;IACxC,OAAO,CAAC,OAAO,CAAoC;IAEnD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI;IAO9C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAU5C,0EAA0E;IAC1E,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;CAOjD"}
+{"version":3,"file":"segment-cache.d.ts","sourceRoot":"","sources":["../../src/client/segment-cache.ts"],"names":[],"mappings":"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"}

package/dist/client/segment-context.d.ts

@@ -34,6 +34,6 @@ interface SegmentProviderProps {
  * Wraps each layout to provide segment position context.
  * Injected by rsc-entry.ts during element tree construction.
  */
-export declare function SegmentProvider({ segments, segmentId: _segmentId, parallelRouteKeys, children }: SegmentProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<SegmentContextValue | null>>;
+export declare function SegmentProvider({ segments, segmentId: _segmentId, parallelRouteKeys, children, }: SegmentProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<SegmentContextValue | null>>;
 export {};
 //# sourceMappingURL=segment-context.d.ts.map

package/dist/client/segment-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment-context.d.ts","sourceRoot":"","sources":["../../src/client/segment-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH,MAAM,WAAW,mBAAmB;IAClC,iFAAiF;IACjF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,0FAA0F;IAC1F,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAMD,qFAAqF;AACrF,wBAAgB,iBAAiB,IAAI,mBAAmB,GAAG,IAAI,CAE9D;AAID,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,iBAAiB,EAAE,QAAQ,EAAE,EAAE,oBAAoB,uGASrH"}
+{"version":3,"file":"segment-context.d.ts","sourceRoot":"","sources":["../../src/client/segment-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH,MAAM,WAAW,mBAAmB;IAClC,iFAAiF;IACjF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,0FAA0F;IAC1F,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAMD,qFAAqF;AACrF,wBAAgB,iBAAiB,IAAI,mBAAmB,GAAG,IAAI,CAE9D;AAID,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,SAAS,EAAE,UAAU,EACrB,iBAAiB,EACjB,QAAQ,GACT,EAAE,oBAAoB,uGAYtB"}

package/dist/client/segment-outlet.d.ts

@@ -0,0 +1,68 @@
+/**
+ * SegmentOutlet — client component boundary at each layout segment.
+ *
+ * Each layout in the segment tree is wrapped with a SegmentOutlet that:
+ * 1. Knows its segment path (prop from the server)
+ * 2. Reads from SegmentUpdateContext for partial navigation updates
+ * 3. Reads from — and, at commit, writes to — the router's slot content
+ *    cache, so a skipped parallel slot keeps showing what it last committed
+ *
+ * On full navigation: receives new children via props and renders them.
+ * On partial navigation (this segment skipped): the context map has no entry
+ * for this path, so the outlet renders its children — which, because the
+ * router re-wraps the *retained* tree, are the same elements as before,
+ * preserving layout state.
+ * On partial navigation (this segment updated): the context map has content
+ * for this path, so the outlet renders the update.
+ * On a skipped parallel slot (`skip=true`, children null): the outlet renders
+ * the content it last committed for this path.
+ *
+ * Uses React context instead of useSyncExternalStore to stay compatible
+ * with concurrent rendering (transitions). All outlets re-render when the
+ * context value changes, but each bails out quickly if its segment has
+ * no update — same approach as Next.js LayoutRouter.
+ *
+ * Render is a pure read. The only write — recording committed slot content —
+ * happens in a layout effect, so a render React throws away (a superseded
+ * transition, a Suspense retry) cannot poison what a later `skip=true`
+ * resolves to (TIM-1423). See client/slot-content-cache-context.ts.
+ *
+ * Security: performance optimization only. The server always runs all
+ * access.ts files regardless of segment skipping.
+ * See design/13-security.md §"State tree manipulation".
+ */
+import { type ReactNode } from 'react';
+export interface SegmentOutletProps {
+    /**
+     * Unique identifier for this segment. For normal segments this is the
+     * urlPath (e.g., "/", "/dashboard"). For route groups this includes the
+     * group name (e.g., "/(marketing)") to distinguish siblings that share
+     * the same urlPath. For slots this includes the slot name (e.g., "/@sidebar").
+     * Must match the segmentId used in state-tree-diff.ts.
+     */
+    segmentPath: string;
+    /** The segment's React subtree (layout + inner content). */
+    children: ReactNode;
+    /**
+     * When true, the outlet renders the content it last committed for this
+     * path instead of `children`. Used for skipped parallel route slots — the
+     * server sends an empty SegmentOutlet with skip=true, and the client keeps
+     * the previously committed slot content.
+     */
+    skip?: boolean;
+}
+/**
+ * Client component boundary at each layout segment in the element tree.
+ *
+ * Resolution order, all reads:
+ *   1. An update in SegmentUpdateContext for this path → render it.
+ *   2. `skip` → render the committed content for this path (null if none —
+ *      a fresh outlet with nothing committed yet renders empty and is fully
+ *      rendered on the next navigation).
+ *   3. Otherwise → render `children`.
+ *
+ * Whatever a non-skip render resolves to is recorded once React commits it.
+ * A skip render records nothing: it displayed the cache, it did not add to it.
+ */
+export declare function SegmentOutlet({ segmentPath, children, skip }: SegmentOutletProps): ReactNode;
+//# sourceMappingURL=segment-outlet.d.ts.map

package/dist/client/segment-outlet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-outlet.d.ts","sourceRoot":"","sources":["../../src/client/segment-outlet.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,OAAO,EAA+B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIpE,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB,4DAA4D;IAC5D,QAAQ,EAAE,SAAS,CAAC;IAEpB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,kBAAkB,aAoBhF"}

package/dist/client/segment-update-context.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SegmentUpdateContext — React context for partial navigation updates.
+ *
+ * During partial navigation (server skips unchanged sync layouts), the
+ * router builds a Map of segment path → ReactNode updates and passes it
+ * as the context value. Mounted SegmentOutlet components read from this
+ * context to decide whether to render the update or their cached content.
+ *
+ * Singleton across bundler-duplicated chunks via `createGlobalContext`.
+ * See design/19-client-navigation.md §"Singleton Guarantee via globalThis"
+ */
+import type { ReactNode } from 'react';
+export declare const EMPTY_SEGMENT_UPDATES: Map<string, ReactNode>;
+export declare const SegmentUpdateContext: import("react").Context<Map<string, ReactNode>>;
+//# sourceMappingURL=segment-update-context.d.ts.map

package/dist/client/segment-update-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-update-context.d.ts","sourceRoot":"","sources":["../../src/client/segment-update-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,eAAO,MAAM,qBAAqB,wBAA+B,CAAC;AAElE,eAAO,MAAM,oBAAoB,iDAGhC,CAAC"}

package/dist/client/shallow-url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shallow URL replacement — update the browser URL bar without triggering
+ * RSC navigation, TopLoader, or any server round-trip.
+ *
+ * Uses the Navigation API's `info: { shallow: true }` when available (Chrome),
+ * which the navigate event handler intercepts with a no-op handler. Falls back
+ * to raw `history.replaceState` (Safari/Firefox — no navigate event fired).
+ */
+export declare function replaceUrl(url: string): void;
+//# sourceMappingURL=shallow-url.d.ts.map

package/dist/client/shallow-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shallow-url.d.ts","sourceRoot":"","sources":["../../src/client/shallow-url.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAU5C"}

package/dist/client/slot-content-cache-context.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SlotContentCacheContext — the router-owned record of slot content the
+ * client has *committed*.
+ *
+ * The server omits a parallel slot's content when the client advertised a
+ * matching content key (`skip=true`, TIM-1370), and the outlet at that
+ * position must render what it displayed before. This Map, keyed by
+ * segmentPath, is where that content lives.
+ *
+ * Ownership and write discipline (TIM-1423):
+ *
+ * - **One instance per router.** `createTimberRouter` creates the Map and
+ *   provides it above every tree it hands to React — hydration included,
+ *   which builds its chain through the same `renderTree`. It is not a
+ *   module or `globalThis` singleton: a process-wide Map executed during
+ *   SSR would be shared by concurrent requests.
+ * - **Written only at commit.** `SegmentOutlet` writes from a layout effect,
+ *   never during render. A render React discards — a transition superseded
+ *   before it commits, a Suspense retry — leaves the Map untouched, so a
+ *   later `skip=true` can only ever resolve to content the user actually saw.
+ *   The content-key record the client advertises (`SegmentCache`, published
+ *   by `NavigationRoot`'s layout effect on the same commit) and this Map
+ *   are therefore written by the same React commit and cannot describe
+ *   different trees.
+ * - **`null` outside a router.** SSR renders no provider and the outlet then
+ *   neither reads nor writes: the server never emits `skip` during SSR, and
+ *   layout effects do not run there. The default is `null` rather than a
+ *   shared Map so that "no provider" cannot silently become "shared cache".
+ *
+ * Singleton across bundler-duplicated chunks via `createGlobalContext`.
+ */
+import type { ReactNode } from 'react';
+export type SlotContentCache = Map<string, ReactNode>;
+export declare const SlotContentCacheContext: import("react").Context<SlotContentCache | null>;
+//# sourceMappingURL=slot-content-cache-context.d.ts.map

package/dist/client/slot-content-cache-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-content-cache-context.d.ts","sourceRoot":"","sources":["../../src/client/slot-content-cache-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,MAAM,MAAM,gBAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAEtD,eAAO,MAAM,uBAAuB,kDAGnC,CAAC"}

package/dist/client/slot-context.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SlotContext — delivers live slot content to SlotOutlet holes inside
+ * cached component shells (TIM-1173).
+ *
+ * A `cache.component(Fn, { slots: [...] })` shell is captured with a
+ * stable <SlotOutlet slot={name} /> client reference in place of each
+ * declared slot prop. At request time the revived shell is wrapped in a
+ * SlotsProvider carrying the live slot values; each outlet reads its
+ * value from this context by name.
+ *
+ * Providers MERGE per-key with their parent: an inner SlotsProvider
+ * inherits the outer's values and overrides only the keys it declares.
+ * Two sibling instances each have their own provider and resolve
+ * independently. Layouts use a reserved slot name (LAYOUT_CHILDREN_SLOT)
+ * that cannot collide with user-declared slot names (TIM-1191).
+ *
+ * Generalizes the original layout children pattern (TIM-1181) from a
+ * single implicit `children` hole on layouts to explicitly declared,
+ * named slot props on any cached component. Layouts use this same
+ * context with the reserved LAYOUT_CHILDREN_SLOT key (TIM-1191).
+ *
+ * SINGLETON GUARANTEE: globalThis + Symbol.for — the RSC client bundler
+ * can duplicate this module across chunks; globalThis guarantees a single
+ * context instance.
+ *
+ * See design/45-cache-lifetimes.md §Slot Components.
+ */
+import React, { type ReactNode } from 'react';
+export type SlotValues = Record<string, ReactNode>;
+export declare const SlotContext: React.Context<SlotValues | null>;
+//# sourceMappingURL=slot-context.d.ts.map

package/dist/client/slot-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-context.d.ts","sourceRoot":"","sources":["../../src/client/slot-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAiBnD,eAAO,MAAM,WAAW,kCAAuB,CAAC"}

package/dist/client/slot-outlet.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SlotOutlet — the hole in a cached component shell (TIM-1173).
+ *
+ * At capture time the prebuilt runtime renders the wrapped component with
+ * <SlotOutlet slot={name} /> in place of each declared slot prop. Being a
+ * client component, it serializes into the flight payload as a stable,
+ * deterministic client reference — the same bytes regardless of what live
+ * content will fill the hole. At request time the revived shell sits under
+ * a SlotsProvider and each outlet reads its live value from SlotContext.
+ *
+ * See design/45-cache-lifetimes.md §Slot Components.
+ */
+export declare function SlotOutlet({ slot }: {
+    slot: string;
+}): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+//# sourceMappingURL=slot-outlet.d.ts.map

package/dist/client/slot-outlet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-outlet.d.ts","sourceRoot":"","sources":["../../src/client/slot-outlet.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,kZAGpD"}

package/dist/client/slot-provider.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SlotsProvider — wraps a revived cached shell to supply live slot content
+ * to the SlotOutlet holes inside it (TIM-1173).
+ *
+ * Values MERGE with the nearest parent provider so that nesting a
+ * cache.component SlotsProvider inside a layout SlotsProvider preserves
+ * the layout's `children` slot while adding the component's own slots.
+ * Inner values override outer ones with the same name (spread order).
+ *
+ * Tree structure per cached-component instance:
+ *   SlotsProvider(values={children: <Live />})
+ *     └── revived shell
+ *          └── SlotOutlet(slot="children") → reads context → <Live />
+ *
+ * See design/45-cache-lifetimes.md §Slot Components.
+ */
+import { type ReactNode } from 'react';
+import { type SlotValues } from './slot-context.ts';
+interface SlotsProviderProps {
+    values: SlotValues;
+    children: ReactNode;
+}
+export declare function SlotsProvider({ values, children }: SlotsProviderProps): import("react").FunctionComponentElement<import("react").ProviderProps<SlotValues | null>>;
+export {};
+//# sourceMappingURL=slot-provider.d.ts.map

package/dist/client/slot-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-provider.d.ts","sourceRoot":"","sources":["../../src/client/slot-provider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAClE,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEjE,UAAU,kBAAkB;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,kBAAkB,8FAIrE"}

package/dist/client/ssr-data.d.ts

@@ -21,22 +21,44 @@
  * All mutable state is delegated to client/state.ts for singleton guarantees.
  * See design/18-build-system.md §"Singleton State Registry"
  */
+import type { CoercedParams } from '../shared/param-value.ts';
+import type { SlotParamsRecord } from '../shared/slot-params.ts';
 export interface SsrData {
     /** The request's URL pathname (e.g. '/dashboard/settings') */
     pathname: string;
-    /** The request's search params as a plain record */
-    searchParams: Record<string, string>;
+    /**
+     * The request's raw app-visible query string (`''` or `?…`), matching what
+     * `window.location.search` will hold after hydration. The raw string is
+     * the only representation carried here: it preserves repeated keys
+     * (`?tag=a&tag=b`), which a collapsed `Record<string, string>` cannot
+     * (TIM-1428). Parse with `new URLSearchParams(search)` where needed.
+     */
+    search: string;
     /** The request's cookies as name→value pairs */
     cookies: Map<string, string>;
     /** The request's route params (e.g. { id: '123' }) */
-    params: Record<string, string | string[]>;
+    params: CoercedParams;
+    /**
+     * Per-slot params keyed by slot tree path, absent when the request rendered
+     * no slot with params of its own (TIM-1285).
+     */
+    slotParams?: SlotParamsRecord;
     /**
-     * Mutable reference to NavContext for error boundary → RSC communication.
-     * When TimberErrorBoundary catches a DenySignal, it sets
-     * `_navContext._denyHandledByBoundary = true` to prevent the RSC entry
-     * from promoting the denial to page-level. See LOCAL-298.
+     * Mutable reference to NavContext for error boundary → pipeline communication.
+     *
+     * When TimberErrorBoundary catches a DenySignal during SSR, it:
+     * 1. Sets `statusCode` to the deny status (e.g., 403) — so the HTTP
+     *    Response has the correct status code without a re-render.
+     * 2. Sets `_denyHandledByBoundary = true` — so the pipeline skips
+     *    the redundant renderDenyPage() re-render.
+     *
+     * This runs synchronously during Fizz rendering, BEFORE onShellReady,
+     * so the status code is committed before any bytes are sent.
+     *
+     * See TIM-664, design/04-authorization.md §"React.cache Scope in Deny/Error Re-renders"
      */
     _navContext?: {
+        statusCode?: number;
         _denyHandledByBoundary?: boolean;
     };
 }

package/dist/client/ssr-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr-data.d.ts","sourceRoot":"","sources":["../../src/client/ssr-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAWH,MAAM,WAAW,OAAO;IACtB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,gDAAgD;IAChD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC1C;;;;;OAKG;IACH,WAAW,CAAC,EAAE;QAAE,sBAAsB,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACpD;AAkBD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,OAAO,GAAG,SAAS,GAAG,IAAI,CAEjF;AAMD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,IAAI,OAAO,GAAG,SAAS,CAKhD"}
+{"version":3,"file":"ssr-data.d.ts","sourceRoot":"","sources":["../../src/client/ssr-data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAQH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAIjE,MAAM,WAAW,OAAO;IACtB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,sDAAsD;IACtD,MAAM,EAAE,aAAa,CAAC;IACtB;;;OAGG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,sBAAsB,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACzE;AAkBD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,OAAO,GAAG,SAAS,GAAG,IAAI,CAEjF;AAMD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,IAAI,OAAO,GAAG,SAAS,CAKhD"}

package/dist/client/stale-client.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Stale Client — knowing when this bundle has been superseded.
+ *
+ * Layer 1 of version skew handling (see design/33-version-skew.md) is
+ * proactive: the server compares `X-Timber-Deployment-Id` against the current
+ * build and answers a stale client with `X-Timber-Reload: 1`. That covers
+ * every RSC navigation and every server action — as long as there is a server
+ * in the request path.
+ *
+ * This module is the reactive half, plus the state both halves feed. It
+ * recognizes the two error shapes a stale client produces on its own:
+ *
+ * 1. **Stale client references** — React's Flight client throws
+ *    "Could not find the module …" when an RSC payload names a client module
+ *    ID that isn't in this bundle's manifest.
+ * 2. **Chunk load failures** — a content-hashed chunk that no longer exists on
+ *    the CDN fails to `import()`. Every engine words this differently.
+ *
+ * It matters most for `output: 'static'`, where there is no server to send the
+ * reload header and this is the *only* skew detection that can run.
+ *
+ * **Nothing here reloads the page.** A stale client is recorded, not acted on;
+ * the router turns the next user-initiated navigation into a full document
+ * load. See design/33-version-skew.md §"Recovery on the next navigation" for
+ * why — a self-issued `location.reload()` cannot tell a recovery from a bounce
+ * between two live deployments, and mid-rollout it produces exactly that loop.
+ *
+ * See TIM-1260, TIM-1275.
+ */
+/**
+ * True when the error is React's "client reference not in this manifest"
+ * failure — the payload was produced by a build this bundle doesn't match.
+ */
+export declare function isStaleClientReference(error: unknown): boolean;
+/**
+ * True when the error is a failed dynamic import or CSS preload — the
+ * content-hashed chunk this bundle asks for is gone from the CDN.
+ */
+export declare function isChunkLoadError(error: unknown): boolean;
+/** Whether this client has been superseded by a newer deployment. */
+export declare function isClientStale(): boolean;
+/**
+ * Record that the origin has told us this client is stale — the `X-Timber-Reload`
+ * header on an RSC or action response. Authoritative, so it is not gated on
+ * anything: a dev server never sends the header in the first place.
+ */
+export declare function markClientStale(): void;
+/**
+ * Record staleness if `error` is one of the shapes a superseded bundle
+ * produces. Returns whether it did, so a caller mid-navigation can decide to
+ * hard-navigate instead of surfacing the error.
+ *
+ * Inference, unlike {@link markClientStale}, so it is gated on being a
+ * production build. This is the single place that gate lives — call sites
+ * cannot see each other, and "remember to gate the next one too" is not a
+ * guarantee.
+ */
+export declare function markStaleFromError(error: unknown): boolean;
+/**
+ * Arm the module, and register the listeners that catch stale-client errors
+ * never passing through the router: a lazily imported client component, a
+ * preloaded stylesheet, anything that rejects outside a navigation.
+ *
+ * No-op when `deploymentId` is null — that is dev. Called from the browser
+ * entry before hydration, so it precedes any render or navigation that could
+ * throw.
+ */
+export declare function initStaleClient(deploymentId: string | null): void;
+//# sourceMappingURL=stale-client.d.ts.map

package/dist/client/stale-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stale-client.d.ts","sourceRoot":"","sources":["../../src/client/stale-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AA4CH;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE9D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAIxD;AAuBD,qEAAqE;AACrE,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAgB1D;AAeD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAejE"}