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

package/dist/client/rsc-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rsc-fetch.d.ts","sourceRoot":"","sources":["../../src/client/rsc-fetch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAI3C,uFAAuF;AACvF,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IACnC,uFAAuF;IACvF,WAAW,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IAClC,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IACjD,+EAA+E;IAC/E,eAAe,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CAClC;AAID,eAAO,MAAM,gBAAgB,qBAAqB,CAAC;AA2BnD,wBAAgB,eAAe,CAC7B,SAAS,EAAE;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,EAC7C,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAID;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,EAAE,GAAG,IAAI,CAQ5E;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,EAAE,GAAG,IAAI,CAQ3E;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAAE,GAAG,IAAI,CAS1E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAQ1F;AAID;;;GAGG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBACjB,GAAG,EAAE,MAAM;CAIxB;AAID;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,UAAU,EAChB,SAAS,CAAC,EAAE;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,EAClC,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,WAAW,CAAC,CAuDtB"}
+{"version":3,"file":"rsc-fetch.d.ts","sourceRoot":"","sources":["../../src/client/rsc-fetch.ts"],"names":[],"mappings":"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"}

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
@@ -38,9 +63,36 @@ export interface StateTree {
  */
 export declare class SegmentCache {
     private root;
+    /**
+     * Monotonic counter. Bumped by `invalidateReuse()` (TIM-1466).
+     * `serializeStateTree` suppresses `segments` and `slots` when
+     * `reuseInvalidatedAt > reuseRestoredAt`. Only `restoreReuse()`
+     * advances `reuseRestoredAt` — `set()` does not, because a
+     * pre-invalidation navigation's commit thunk would lift suppression
+     * before a post-invalidation request has been sent (codex on #1167).
+     */
+    private reuseInvalidatedAt;
+    private reuseRestoredAt;
     get(segment: string): SegmentNode | undefined;
     set(segment: string, node: SegmentNode): void;
     clear(): void;
+    /**
+     * Suppress segment and slot reuse without destroying the tree
+     * structure (TIM-1466). `serializeStateTree` sends empty
+     * `segments`/`slots` (forcing a full render) while `treePaths`
+     * still reflects the mounted tree for interception scoping.
+     * Call `restoreReuse()` once post-invalidation data has been
+     * fetched and committed.
+     */
+    invalidateReuse(): void;
+    /**
+     * Lift reuse suppression. Called after the segment cache has been
+     * rebuilt from a response that was fetched with suppression active
+     * (i.e. the server sent a full render). Safe to call idempotently.
+     */
+    restoreReuse(): void;
+    /** Whether segment/slot reuse is currently suppressed (TIM-1466). */
+    isReuseSuppressed(): boolean;
     /**
      * Serialize the mounted segment tree for the X-Timber-State-Tree header.
      * Only includes sync segments — async segments are excluded because the
@@ -51,19 +103,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 +127,130 @@ 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.
+ *  `startGen` is the eviction generation at flight start — joiners that
+ *  started after a gen bump must reject pre-invalidation results (TIM-1464). */
+export type FlightOutcome = {
+    kind: 'ready';
+    result: PrefetchResult;
+    startGen: number;
+} | {
+    kind: 'non-route';
+    startGen: number;
+};
 /**
  * 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;
+    /**
+     * 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.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,EAC9B,QAAQ,EACR,SAAS,EAAE,UAAU,EACrB,iBAAiB,EACjB,QAAQ,GACT,EAAE,oBAAoB,uGAStB"}
+{"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"}