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

package/dist/_chunks/status-page-marker-DwQBrLBz.js

@@ -0,0 +1,496 @@
+import { n as createSingleflight } from "./singleflight-2lUWfcAk.js";
+import { r as setNavigationState } from "./navigation-context-D0TU0Jog.js";
+import { a as _setStatusPageRendered, d as onStatusPageRendered, i as _setOnStatusPageRendered, p as statusPageRendered } from "./state-FippDgxN.js";
+import { useLayoutEffect } from "react";
+//#region src/shared/rsc-error-envelope.ts
+/**
+* The hard-navigate error envelope shared by the server and the client router.
+*
+* A client-navigation (RSC) request cannot carry an error *page* — the response
+* body must be Flight data or the decoder crashes. Instead the server answers
+* with this envelope: an `X-Timber-Error: 1` header and a minimal JSON body.
+* The client treats it as "give up on SPA navigation and hard-navigate", and
+* the resulting document request renders the real error page as HTML.
+*
+* The header name lives here so the four server producers and the single
+* client consumer cannot drift apart. See design/10-error-handling.md
+* §"Error Page Rendering for Client Navigation".
+*/
+/** Header the client checks to decide whether to hard-navigate. */
+var TIMBER_ERROR_HEADER = "X-Timber-Error";
+//#endregion
+//#region src/client/segment-cache.ts
+/**
+* Maintains the client-side segment tree representing currently mounted
+* layouts and pages. Used for navigation reconciliation — the router diffs
+* new routes against this tree to determine which segments to re-fetch.
+*/
+var SegmentCache = class {
+	root;
+	get(segment) {
+		if (segment === "/" || segment === this.root?.segment) return this.root;
+	}
+	set(segment, node) {
+		if (segment === "/" || !this.root) this.root = node;
+	}
+	clear() {
+		this.root = void 0;
+	}
+	/**
+	* Serialize the mounted segment tree for the X-Timber-State-Tree header.
+	* Only includes sync segments — async segments are excluded because the
+	* server must always re-render them (they may depend on request context).
+	*
+	* When mergeableFilter is provided, only segments whose paths are in the
+	* set are included. This ensures the server only skips segments that the
+	* 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) {
+		const segments = [];
+		const slots = [];
+		const treePaths = [];
+		if (this.root) {
+			collectSyncSegments(this.root, segments, mergeableFilter);
+			collectSyncSlots(this.root, slots);
+			collectTreePaths(this.root, treePaths);
+		}
+		const tree = { segments };
+		if (slots.length > 0) tree.slots = slots;
+		if (treePaths.length > 0) tree.treePaths = treePaths;
+		return tree;
+	}
+};
+/** Recursively collect sync segment paths from the tree */
+function collectSyncSegments(node, out, mergeableFilter) {
+	if (!node.isRequestDependent && (!mergeableFilter || mergeableFilter.has(node.segment))) out.push(node.segment);
+	for (const child of node.children.values()) collectSyncSegments(child, out, mergeableFilter);
+}
+/**
+* Recursively collect the `app/` directory path of every mounted segment.
+*
+* Slots are not walked: a slot's own sub-tree can never own an intercepting
+* slot's scope, because scopes are always ordinary segments (`interception.ts`
+* derives one from the slot owner's ancestor chain).
+*/
+function collectTreePaths(node, out) {
+	if (node.treePath) out.push(node.treePath);
+	for (const child of node.children.values()) collectTreePaths(child, out);
+}
+/**
+* Recursively collect content keys from cacheable slots.
+*
+* The server advertises a content key per slot on every render (TIM-1370),
+* encoding the owner's URL parts, the slot name, the matched entry file,
+* and the slot's params. The client stores this key and sends it back on
+* the next navigation so the server can decide skips by key membership —
+* no departing URL reconstruction needed.
+*/
+function collectSyncSlots(node, out) {
+	if (node.slots) {
+		for (const slot of node.slots.values()) if (!slot.isRequestDependent && !slot.denied && slot.contentKey) out.push(slot.contentKey);
+	}
+	for (const child of node.children.values()) collectSyncSlots(child, out);
+}
+/**
+* Build a SegmentNode tree from flat segment metadata.
+*
+* Takes an ordered list of segment descriptors (root → leaf) from the
+* server's X-Timber-Segments header and constructs the hierarchical
+* tree structure that SegmentCache expects.
+*
+* Each segment is nested as a child of the previous one, forming a
+* linear chain from root to leaf. The leaf segment (page) is excluded
+* from the tree — pages are never cached across navigations.
+*/
+function buildSegmentTree(segments) {
+	if (segments.length === 0) return void 0;
+	const segmentEntries = [];
+	const slotEntries = [];
+	for (const info of segments) if (info.slot) slotEntries.push(info);
+	else segmentEntries.push(info);
+	let root;
+	let parent;
+	const nodeById = /* @__PURE__ */ new Map();
+	for (const info of segmentEntries) {
+		const id = info.segmentId ?? info.path;
+		const node = {
+			segment: id,
+			treePath: info.treePath,
+			payload: null,
+			isRequestDependent: info.isRequestDependent,
+			children: /* @__PURE__ */ new Map()
+		};
+		nodeById.set(id, node);
+		if (!root) root = node;
+		if (parent) parent.children.set(id, node);
+		parent = node;
+	}
+	for (const slotInfo of slotEntries) {
+		const parentId = slotInfo.parentSegment;
+		const parentNode = parentId ? nodeById.get(parentId) : root;
+		if (!parentNode) continue;
+		const slotId = slotInfo.segmentId ?? slotInfo.path;
+		const slotNode = {
+			segment: slotId,
+			payload: null,
+			isRequestDependent: slotInfo.isRequestDependent,
+			children: /* @__PURE__ */ new Map(),
+			denied: slotInfo.denied,
+			contentKey: slotInfo.contentKey
+		};
+		if (!parentNode.slots) parentNode.slots = /* @__PURE__ */ new Map();
+		parentNode.slots.set(slotId, slotNode);
+	}
+	return root;
+}
+/** Sentinel value for negative cache entries (URL is not a route). */
+var NEGATIVE_ENTRY = Object.freeze({ payload: null });
+/**
+* Timeout for the in-flight singleflight (TIM-1438). Per CLAUDE.md's
+* singleflight rule: "Never write a coalescing Map without a timeout."
+* A hung prefetch cannot block clicks or suppress hovers forever.
+*/
+var PREFETCH_SINGLEFLIGHT_TIMEOUT_MS = 5e3;
+/**
+* Compose the map key. Length-prefixed rather than delimiter-joined for the
+* same reason `shared/rsc-cache-key.ts` is: any delimiter is forgeable by a
+* value containing it, and a URL may contain any character a delimiter could.
+*/
+function prefetchMapKey(key) {
+	return `${key.from.length}:${key.from}:${key.scope.length}:${key.scope}:${key.url}`;
+}
+/**
+* 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.
+*/
+function prefetchScopeOf(stateTree) {
+	return stateTree?.treePaths?.join("\0") ?? "";
+}
+/**
+* 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.
+*/
+var PrefetchCache = class PrefetchCache {
+	static TTL_MS = 3e4;
+	entries = /* @__PURE__ */ new Map();
+	flights = createSingleflight({ timeoutMs: PREFETCH_SINGLEFLIGHT_TIMEOUT_MS });
+	evictionGen = 0;
+	set(key, result) {
+		this.entries.set(prefetchMapKey(key), {
+			result,
+			expiresAt: Date.now() + PrefetchCache.TTL_MS
+		});
+	}
+	get(key) {
+		const mapKey = prefetchMapKey(key);
+		const entry = this.entries.get(mapKey);
+		if (!entry) return void 0;
+		if (Date.now() >= entry.expiresAt) {
+			this.entries.delete(mapKey);
+			return;
+		}
+		return entry.result;
+	}
+	/** True if a ready or negative entry exists for this key. */
+	has(key) {
+		return this.get(key) !== void 0;
+	}
+	/** Get and remove the entry (used when navigation consumes a prefetch) */
+	consume(key) {
+		const result = this.get(key);
+		if (result !== void 0) this.entries.delete(prefetchMapKey(key));
+		return result;
+	}
+	/**
+	* 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, doFetch, isNonRoute) {
+		const genAtStart = this.evictionGen;
+		return this.flights.do(prefetchMapKey(key), async (signal) => {
+			try {
+				const result = await doFetch(signal);
+				if (!signal.aborted && this.evictionGen === genAtStart) this.set(key, result);
+				return {
+					kind: "ready",
+					result
+				};
+			} catch (err) {
+				if (isNonRoute(err)) {
+					if (!signal.aborted && this.evictionGen === genAtStart) this.setNegative(key);
+					return { kind: "non-route" };
+				}
+				throw err;
+			}
+		});
+	}
+	/**
+	* 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) {
+		return this.flights.get(prefetchMapKey(key));
+	}
+	/**
+	* 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) {
+		this.set(key, NEGATIVE_ENTRY);
+	}
+	/** Check if the entry is a negative cache entry (URL is not a route). */
+	isNegative(key) {
+		return this.get(key) === NEGATIVE_ENTRY;
+	}
+	/**
+	* 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) {
+		for (const [mapKey] of this.entries) if (mapKey.endsWith(":" + url)) this.entries.delete(mapKey);
+	}
+	/**
+	* 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() {
+		this.entries.clear();
+		this.evictionGen++;
+	}
+	getEvictionGen() {
+		return this.evictionGen;
+	}
+};
+//#endregion
+//#region src/client/navigation-commit.ts
+/**
+* What it means for a page to be "current" on the client.
+*
+* One module owns every write that makes a navigation's destination the
+* current page, and the read that describes the current page back to the
+* server. Keeping them together is the point: `X-Timber-State-Tree` is
+* derived from the segment cache, so the thing that publishes and the thing
+* that reports have to agree about when a page becomes current.
+*
+* See design/19-client-navigation.md §"State Update Invariants".
+*/
+/**
+* Record that a status page for the main route is on screen. Called from
+* `StatusPageMarker`'s layout effect; consumed by the commit of the
+* navigation whose tree it belongs to, and acted on immediately for the
+* commits that have none.
+*/
+function reportStatusPageRendered() {
+	_setStatusPageRendered(true);
+	onStatusPageRendered?.();
+}
+/** Whether a response skipped layouts — its payload merges over the tree on screen. */
+function isPartialNavigation(skippedSegments) {
+	return skippedSegments != null && skippedSegments.length > 0;
+}
+/**
+* Whether a payload can stand on its own when replayed from the history
+* stack. See `NavigationCommitInput.skippedSegments`.
+*/
+function isReplayable(opts) {
+	return !isPartialNavigation(opts.skippedSegments) && !hasSkippedSlot(opts.segmentInfo);
+}
+function hasSkippedSlot(segmentInfo) {
+	return segmentInfo?.some((s) => s.slot && s.skipped) ?? false;
+}
+/**
+* The metadata a history entry keeps. `skipped` describes the *response*
+* — "this slot's content was omitted" — and the entry stores no such
+* payload (it stores null). Left on the entry, the flag outlives the
+* response: `applyActionResult()` reuses the entry's metadata beside a full
+* re-render and would have that judged non-replayable too.
+*/
+function storedSegmentInfo(segmentInfo) {
+	if (!hasSkippedSlot(segmentInfo)) return segmentInfo;
+	return segmentInfo.map(({ skipped: _skipped, ...rest }) => rest);
+}
+/**
+* Derive the navigation state (pathname + search) a URL renders with.
+*
+* Pure: publishing it — the module-level fallback for tests and SSR, and the
+* globalThis bridge — is `prepareNavigation`'s commit, which runs only once
+* the render is known to have won (TIM-1301). Callers pass the returned value
+* explicitly to renderRoot/wrapPayload, so a render never depends on the
+* publish having happened first.
+*/
+function deriveNavigationState(url) {
+	const parsed = new URL(url, "http://localhost");
+	return {
+		pathname: parsed.pathname || "/",
+		search: parsed.search
+	};
+}
+function createNavigationCommitter(deps) {
+	const { segmentCache, historyStack } = deps;
+	_setOnStatusPageRendered(() => segmentCache.clear());
+	/**
+	* Update the segment cache from server-provided segment metadata.
+	*
+	* Runs whether or not `clientSegmentCache` is enabled: the tree is also
+	* where the mounted tree paths come from, and those cross on every
+	* navigation. What the flag gates is which parts get serialized — see
+	* `currentStateTree`.
+	*/
+	function updateSegmentCache(segmentInfo) {
+		if (!segmentInfo || segmentInfo.length === 0) return;
+		const tree = buildSegmentTree(segmentInfo);
+		if (tree) segmentCache.set("/", tree);
+	}
+	return {
+		updateSegmentCache,
+		/**
+		* The X-Timber-State-Tree to send with the next RSC request.
+		*
+		* Two different things travel on one header. `segments`/`slots` are the
+		* caching opt-in and are omitted unless `clientSegmentCache` is on.
+		* `treePaths` is how the server learns which route is actually mounted,
+		* which stops being derivable from the address bar as soon as a modal is
+		* open — so it crosses regardless (TIM-1282). Undefined when there is
+		* nothing to say, so a no-op header never enters the `_rsc` cache key.
+		*
+		* Reads what the last *committed* navigation published, so a superseded
+		* navigation's destination can never end up describing the mounted tree
+		* (TIM-1301).
+		*/
+		currentStateTree() {
+			const tree = segmentCache.serializeStateTree();
+			if (deps.clientSegmentCache()) return tree;
+			return tree.treePaths ? {
+				segments: [],
+				treePaths: tree.treePaths
+			} : void 0;
+		},
+		/**
+		* Prepare all navigation-owned state for a new page — without publishing
+		* any of it. Every code path that changes the "current page" must go
+		* through this function, which is what makes "forgot a field" impossible
+		* by construction.
+		*
+		* Returns the destination's `NavigationState`, which is a pure function of
+		* the URL and is what the incoming tree is *rendered* with, plus a
+		* `commit` thunk that performs the writes that make a page current:
+		* 1. Segment cache — update from server-provided segment metadata
+		* 2. Navigation state — pathname/search for usePathname/useSearchParams
+		* 3. History stack — store the payload for instant back/forward replay
+		*
+		* Nothing is written until `commit()` runs, and on a transitioned
+		* navigation it runs only once the transition is known to have won — see
+		* `renderViaTransition` and `NavigationRoot`. A navigation superseded
+		* while its payload was in flight never calls it, so the cache, the
+		* pathname the client reports and the history stack all keep describing
+		* the route still on screen (TIM-1301).
+		*
+		* Callers with state of their own to publish — the address bar, the
+		* client's record of the mounted tree — wrap this thunk rather than
+		* commit beside it, so there stays exactly one moment at which a page
+		* becomes current.
+		*/
+		prepareNavigation(url, opts) {
+			const navState = deriveNavigationState(url);
+			const payload = isReplayable(opts) ? opts.payload : null;
+			_setStatusPageRendered(false);
+			return {
+				navState,
+				commit() {
+					const cacheable = !statusPageRendered;
+					_setStatusPageRendered(false);
+					const segmentInfo = cacheable ? opts.segmentInfo : [];
+					if (segmentInfo && segmentInfo.length > 0) updateSegmentCache(segmentInfo);
+					else if (segmentInfo?.length === 0 || opts.clearSegmentCacheOnEmpty) segmentCache.clear();
+					setNavigationState(navState);
+					historyStack.push(url, {
+						payload,
+						params: opts.params,
+						segmentInfo: storedSegmentInfo(segmentInfo)
+					});
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/client/status-page-marker.tsx
+/**
+* The one way a status page tells the router it is on screen.
+*
+* A status page replaces a subtree, and the segment cache must not learn a
+* chain that never mounted (see `navigation-commit.ts` §"What a status page
+* teaches the cache"). Status pages are produced in three places — an
+* in-tree catch site rendering the page it owns, the server's fallback
+* renderers, and a client boundary rendering its fallback for a Flight row —
+* and every one of them wraps the page in this marker, so the report does
+* not depend on which producer it was. In particular the in-tree case, the
+* common `access.ts` deny, never involves a client boundary at all.
+*
+* A layout effect, on every commit that renders the marker rather than on
+* mount only: React reuses the fiber when one status page is replaced by
+* another at the same position, and the second one must report too. Layout
+* effects run child-before-parent, so the report lands before the ancestor
+* `NavigationRoot` publishes the same commit, and never for a render React
+* discards. Idempotent, so StrictMode's double invocation and a status page
+* re-rendering on its own state are harmless. See TIM-1495.
+*/
+function StatusPageMarker({ children }) {
+	useLayoutEffect(() => {
+		reportStatusPageRendered();
+	});
+	return children;
+}
+//#endregion
+export { SegmentCache as a, PrefetchCache as i, createNavigationCommitter as n, prefetchScopeOf as o, isPartialNavigation as r, TIMBER_ERROR_HEADER as s, StatusPageMarker as t };
+
+//# sourceMappingURL=status-page-marker-DwQBrLBz.js.map

package/dist/_chunks/status-page-marker-DwQBrLBz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-page-marker-DwQBrLBz.js","names":[],"sources":["../../src/shared/rsc-error-envelope.ts","../../src/client/segment-cache.ts","../../src/client/navigation-commit.ts","../../src/client/status-page-marker.tsx"],"sourcesContent":["/**\n * The hard-navigate error envelope shared by the server and the client router.\n *\n * A client-navigation (RSC) request cannot carry an error *page* — the response\n * body must be Flight data or the decoder crashes. Instead the server answers\n * with this envelope: an `X-Timber-Error: 1` header and a minimal JSON body.\n * The client treats it as \"give up on SPA navigation and hard-navigate\", and\n * the resulting document request renders the real error page as HTML.\n *\n * The header name lives here so the four server producers and the single\n * client consumer cannot drift apart. See design/10-error-handling.md\n * §\"Error Page Rendering for Client Navigation\".\n */\n\n/** Header the client checks to decide whether to hard-navigate. */\nexport const TIMBER_ERROR_HEADER = 'X-Timber-Error';\n","// Segment Cache — stores the mounted segment tree and prefetched payloads\n// See design/19-client-navigation.md for architecture details.\n\nimport type { PublishedParams } from '../shared/payload-root.ts';\nimport type { SegmentInfo, StateTree } from '../shared/segment-info.ts';\nimport { createSingleflight } from '../cache/singleflight.ts';\n\n// ─── Types ───────────────────────────────────────────────────────\n\n/** A prefetched RSC result with optional segment metadata. */\nexport interface PrefetchResult {\n  payload: unknown;\n  /**\n   * Completion of the full Flight stream, when the prefetch is still decoding.\n   * Carried through to the navigation that consumes the entry so a decode\n   * failure reaches *that* navigation's recovery rather than dying with the\n   * prefetch (TIM-1275).\n   */\n  decodePromise?: Promise<void> | null;\n  /** Segment metadata from X-Timber-Segments header for populating the segment cache. */\n  segmentInfo?: SegmentInfo[] | null;\n  /**\n   * The params published beside `payload`, split off the same payload root.\n   * Carried so a consumed prefetch publishes the params of the tree it is\n   * about to render, and not the ones already on screen.\n   */\n  params?: PublishedParams | Promise<PublishedParams>;\n  /** Segment paths skipped by the server (for client-side merging). */\n  skippedSegments?: string[] | null;\n}\n\n/**\n * A node in the client-side segment tree. Each node represents a mounted\n * layout or page segment with its RSC flight payload.\n */\nexport interface SegmentNode {\n  /** The segment's URL pattern (e.g., \"/\", \"/dashboard\", \"/projects/[id]\") */\n  segment: string;\n  /**\n   * The segment's `app/` directory path, groups included (e.g. `/(browse)/feed`).\n   * Undefined for slot nodes and for servers that predate the field.\n   */\n  treePath?: string;\n  /** The RSC flight payload for this segment (opaque to the cache) */\n  payload: unknown;\n  /**\n   * Whether the segment/slot is request-dependent (calls getHeaders,\n   * getSearchParams, cookies, etc.). Request-dependent segments always\n   * re-render on navigation. For segments, this is still based on the\n   * AsyncFunction heuristic (to be replaced separately). For slots,\n   * this is taint-tracked via ALS.\n   */\n  isRequestDependent: boolean;\n  /** Child segments keyed by segment path */\n  children: Map<string, SegmentNode>;\n  /** Parallel route slots keyed by slot path (e.g., \"/@sidebar\") */\n  slots?: Map<string, SegmentNode>;\n  /** Whether this slot's access.ts denied on its last render. */\n  denied?: boolean;\n  /**\n   * Content key for slot nodes — opaque string the server computed from\n   * owner parts, slot name, entry file, and slot params. Advertised back\n   * to the server so it can decide skips by key membership (TIM-1370).\n   */\n  contentKey?: string;\n}\n\n// ─── Segment Cache ───────────────────────────────────────────────\n\n/**\n * Maintains the client-side segment tree representing currently mounted\n * layouts and pages. Used for navigation reconciliation — the router diffs\n * new routes against this tree to determine which segments to re-fetch.\n */\nexport class SegmentCache {\n  private root: SegmentNode | undefined;\n\n  get(segment: string): SegmentNode | undefined {\n    if (segment === '/' || segment === this.root?.segment) {\n      return this.root;\n    }\n    return undefined;\n  }\n\n  set(segment: string, node: SegmentNode): void {\n    if (segment === '/' || !this.root) {\n      this.root = node;\n    }\n  }\n\n  clear(): void {\n    this.root = undefined;\n  }\n\n  /**\n   * Serialize the mounted segment tree for the X-Timber-State-Tree header.\n   * Only includes sync segments — async segments are excluded because the\n   * server must always re-render them (they may depend on request context).\n   *\n   * When mergeableFilter is provided, only segments whose paths are in the\n   * set are included. This ensures the server only skips segments that the\n   * client can actually merge (i.e., segments whose cached element tree\n   * contains an inner SegmentProvider the merger can splice into).\n   *\n   * `treePaths` is collected UNFILTERED, unlike `segments` and `slots`. Those\n   * two answer \"what may the server skip re-rendering?\", so every reason a\n   * segment cannot be reused is a reason to leave it out. `treePaths` answers\n   * \"what is mounted right now?\" for interception scoping — a request-dependent\n   * layout is still on screen, and dropping it would silently narrow the scope\n   * the server sees and cancel a modal that should open (TIM-1282).\n   *\n   * This is a performance optimization only, NOT a security boundary.\n   * The server always runs all access.ts files regardless of the state tree.\n   */\n  serializeStateTree(mergeableFilter?: Set<string>): StateTree {\n    const segments: string[] = [];\n    const slots: string[] = [];\n    const treePaths: string[] = [];\n    if (this.root) {\n      collectSyncSegments(this.root, segments, mergeableFilter);\n      collectSyncSlots(this.root, slots);\n      collectTreePaths(this.root, treePaths);\n    }\n    const tree: StateTree = { segments };\n    if (slots.length > 0) {\n      tree.slots = slots;\n    }\n    if (treePaths.length > 0) {\n      tree.treePaths = treePaths;\n    }\n    return tree;\n  }\n}\n\n/** Recursively collect sync segment paths from the tree */\nfunction collectSyncSegments(\n  node: SegmentNode,\n  out: string[],\n  mergeableFilter?: Set<string>\n): void {\n  if (!node.isRequestDependent && (!mergeableFilter || mergeableFilter.has(node.segment))) {\n    out.push(node.segment);\n  }\n  for (const child of node.children.values()) {\n    collectSyncSegments(child, out, mergeableFilter);\n  }\n}\n\n/**\n * Recursively collect the `app/` directory path of every mounted segment.\n *\n * Slots are not walked: a slot's own sub-tree can never own an intercepting\n * slot's scope, because scopes are always ordinary segments (`interception.ts`\n * derives one from the slot owner's ancestor chain).\n */\nfunction collectTreePaths(node: SegmentNode, out: string[]): void {\n  if (node.treePath) out.push(node.treePath);\n  for (const child of node.children.values()) {\n    collectTreePaths(child, out);\n  }\n}\n\n/**\n * Recursively collect content keys from cacheable slots.\n *\n * The server advertises a content key per slot on every render (TIM-1370),\n * encoding the owner's URL parts, the slot name, the matched entry file,\n * and the slot's params. The client stores this key and sends it back on\n * the next navigation so the server can decide skips by key membership —\n * no departing URL reconstruction needed.\n */\nfunction collectSyncSlots(node: SegmentNode, out: string[]): void {\n  if (node.slots) {\n    for (const slot of node.slots.values()) {\n      if (!slot.isRequestDependent && !slot.denied && slot.contentKey) {\n        out.push(slot.contentKey);\n      }\n    }\n  }\n  for (const child of node.children.values()) {\n    collectSyncSlots(child, out);\n  }\n}\n\n// ─── Segment Tree Builder ────────────────────────────────────────\n\n/**\n * Build a SegmentNode tree from flat segment metadata.\n *\n * Takes an ordered list of segment descriptors (root → leaf) from the\n * server's X-Timber-Segments header and constructs the hierarchical\n * tree structure that SegmentCache expects.\n *\n * Each segment is nested as a child of the previous one, forming a\n * linear chain from root to leaf. The leaf segment (page) is excluded\n * from the tree — pages are never cached across navigations.\n */\nexport function buildSegmentTree(segments: SegmentInfo[]): SegmentNode | undefined {\n  // Need at least a root segment to build a tree\n  if (segments.length === 0) return undefined;\n\n  // Separate slot entries from segment entries. Slots are attached to\n  // their parent segment node after the main chain is built.\n  const segmentEntries: SegmentInfo[] = [];\n  const slotEntries: SegmentInfo[] = [];\n  for (const info of segments) {\n    if (info.slot) {\n      slotEntries.push(info);\n    } else {\n      segmentEntries.push(info);\n    }\n  }\n\n  // Build the main segment chain.\n  let root: SegmentNode | undefined;\n  let parent: SegmentNode | undefined;\n  const nodeById = new Map<string, SegmentNode>();\n\n  for (const info of segmentEntries) {\n    const id = info.segmentId ?? info.path;\n    const node: SegmentNode = {\n      segment: id,\n      treePath: info.treePath,\n      payload: null,\n      isRequestDependent: info.isRequestDependent,\n      children: new Map(),\n    };\n\n    nodeById.set(id, node);\n\n    if (!root) {\n      root = node;\n    }\n\n    if (parent) {\n      parent.children.set(id, node);\n    }\n\n    parent = node;\n  }\n\n  // Attach slot entries to their parent segment nodes.\n  for (const slotInfo of slotEntries) {\n    const parentId = slotInfo.parentSegment;\n    const parentNode = parentId ? nodeById.get(parentId) : root;\n    if (!parentNode) continue;\n\n    const slotId = slotInfo.segmentId ?? slotInfo.path;\n    const slotNode: SegmentNode = {\n      segment: slotId,\n      payload: null,\n      isRequestDependent: slotInfo.isRequestDependent,\n      children: new Map(),\n      denied: slotInfo.denied,\n      contentKey: slotInfo.contentKey,\n    };\n\n    if (!parentNode.slots) {\n      parentNode.slots = new Map();\n    }\n    parentNode.slots.set(slotId, slotNode);\n  }\n\n  return root;\n}\n\n// ─── Prefetch Cache ──────────────────────────────────────────────\n\ninterface ReadyEntry {\n  result: PrefetchResult;\n  expiresAt: number;\n}\n\n/** Sentinel value for negative cache entries (URL is not a route). */\nconst NEGATIVE_ENTRY: PrefetchResult = Object.freeze({ payload: null });\n\n/**\n * Timeout for the in-flight singleflight (TIM-1438). Per CLAUDE.md's\n * singleflight rule: \"Never write a coalescing Map without a timeout.\"\n * A hung prefetch cannot block clicks or suppress hovers forever.\n */\nconst PREFETCH_SINGLEFLIGHT_TIMEOUT_MS = 5_000;\n\n/**\n * Identifies a prefetched payload. A payload is addressed by *every* input that\n * changes the server's answer, not by the destination alone.\n *\n * The server's answer for a destination depends on where the request came\n * from — that is the whole mechanism behind intercepting routes, and it also\n * drives slot-skip resolution. A prefetch issued from `/gallery` is a modal\n * payload; the same URL prefetched from `/` is the full page. Keying on the\n * destination alone let the first click after a hover be answered with\n * whichever variant happened to be fetched (TIM-1265).\n *\n * `from` alone stopped being enough in TIM-1282. It is a pathname, and once\n * interception scope comes from the rendered tree rather than the address, one\n * pathname no longer names one source tree: `/photo/1` is the address both for\n * a modal open over `(browse)` and for `(landing)`'s canonical page. A key\n * without the scope hands the modal payload to the canonical page's click,\n * which renders it without the server's scope check ever running.\n *\n * The two reads happen at different instants — `scope` is sampled at hover and\n * again at click — which is why a tree that changed in between produces a\n * *miss* and a refetch rather than a wrong hit.\n */\nexport interface PrefetchKey {\n  /** Destination URL — hash-less `pathname + search`, as navigate() fetches it. */\n  url: string;\n  /** Departing pathname — the `X-Timber-URL` the prefetch was issued with. */\n  from: string;\n  /**\n   * The rendered scope the prefetch was issued with — the `treePaths` half of\n   * `X-Timber-State-Tree`, joined. Empty when none crossed.\n   */\n  scope: string;\n}\n\n/**\n * Compose the map key. Length-prefixed rather than delimiter-joined for the\n * same reason `shared/rsc-cache-key.ts` is: any delimiter is forgeable by a\n * value containing it, and a URL may contain any character a delimiter could.\n */\nfunction prefetchMapKey(key: PrefetchKey): string {\n  return `${key.from.length}:${key.from}:${key.scope.length}:${key.scope}:${key.url}`;\n}\n\n/**\n * The `scope` half of a `PrefetchKey`, derived from the state tree that will\n * actually be sent. Taking it from the header value rather than re-walking the\n * cache is the point: the key varies by exactly what the request varies by.\n */\nexport function prefetchScopeOf(stateTree: StateTree | undefined): string {\n  return stateTree?.treePaths?.join('\\u0000') ?? '';\n}\n\n/** Outcome of a prefetch flight — discriminated so NonRscResponse is a\n *  success (stores a negative entry) rather than a rejection. */\nexport type FlightOutcome = { kind: 'ready'; result: PrefetchResult } | { kind: 'non-route' };\n\n/**\n * Short-lived cache for hover-triggered prefetches. Entries expire after\n * 30 seconds. When a link is clicked, the prefetched payload is consumed\n * (moved to the history stack) and removed from this cache.\n *\n * In-flight dedup (TIM-1438): concurrent fetches for the same key are\n * coalesced by a `createSingleflight` instance. A hover starts a flight;\n * a click for the same key joins it instead of issuing a duplicate. The\n * singleflight enforces a 5-second timeout and cleans up automatically\n * on settlement.\n *\n * timber.js does NOT prefetch on viewport intersection — only explicit\n * hover on <Link prefetch> triggers a prefetch.\n */\nexport class PrefetchCache {\n  private static readonly TTL_MS = 30_000;\n  private entries = new Map<string, ReadyEntry>();\n  private flights = createSingleflight({ timeoutMs: PREFETCH_SINGLEFLIGHT_TIMEOUT_MS });\n  private evictionGen = 0;\n\n  set(key: PrefetchKey, result: PrefetchResult): void {\n    this.entries.set(prefetchMapKey(key), {\n      result,\n      expiresAt: Date.now() + PrefetchCache.TTL_MS,\n    });\n  }\n\n  get(key: PrefetchKey): PrefetchResult | undefined {\n    const mapKey = prefetchMapKey(key);\n    const entry = this.entries.get(mapKey);\n    if (!entry) return undefined;\n    if (Date.now() >= entry.expiresAt) {\n      this.entries.delete(mapKey);\n      return undefined;\n    }\n    return entry.result;\n  }\n\n  /** True if a ready or negative entry exists for this key. */\n  has(key: PrefetchKey): boolean {\n    return this.get(key) !== undefined;\n  }\n\n  /** Get and remove the entry (used when navigation consumes a prefetch) */\n  consume(key: PrefetchKey): PrefetchResult | undefined {\n    const result = this.get(key);\n    if (result !== undefined) {\n      this.entries.delete(prefetchMapKey(key));\n    }\n    return result;\n  }\n\n  /**\n   * Fetch or coalesce with an in-flight fetch for this key (TIM-1438).\n   *\n   * Concurrent callers (hover + click, repeated hovers) get the same\n   * promise. On success the result is stored as a ready entry. On\n   * NonRscResponse a negative entry is stored and the outcome is\n   * `{ kind: 'non-route' }`. Other errors (network, version skew)\n   * reject — the singleflight cleans up the key and subsequent callers\n   * retry.\n   *\n   * The singleflight signal is passed to `doFetch` so a timed-out flight\n   * aborts the underlying fetch rather than leaving it running.\n   */\n  fetchOrCoalesce(\n    key: PrefetchKey,\n    doFetch: (signal: AbortSignal) => Promise<PrefetchResult>,\n    isNonRoute: (error: unknown) => boolean\n  ): Promise<FlightOutcome> {\n    // Capture the eviction generation before the flight starts. If an\n    // action evicts caches while this flight is in progress, the gen\n    // will have bumped and the stale result is discarded (TIM-1476).\n    const genAtStart = this.evictionGen;\n    return this.flights.do(prefetchMapKey(key), async (signal) => {\n      try {\n        const result = await doFetch(signal);\n        if (!signal.aborted && this.evictionGen === genAtStart) this.set(key, result);\n        return { kind: 'ready' as const, result };\n      } catch (err) {\n        if (isNonRoute(err)) {\n          if (!signal.aborted && this.evictionGen === genAtStart) this.setNegative(key);\n          return { kind: 'non-route' as const };\n        }\n        throw err;\n      }\n    });\n  }\n\n  /**\n   * Join an in-flight singleflight fetch if one exists for this key.\n   * Returns the in-flight promise or undefined. Used by the click path to\n   * coalesce with a hover prefetch without starting a new flight — when no\n   * flight exists, the click issues its own fetch with the navigation's\n   * abort signal so superseded navigations abort immediately (TIM-1438).\n   */\n  joinInflight(key: PrefetchKey): Promise<FlightOutcome> | undefined {\n    return this.flights.get(prefetchMapKey(key)) as Promise<FlightOutcome> | undefined;\n  }\n\n  /**\n   * Store a negative entry — the URL is not a route (non-RSC Content-Type).\n   *\n   * Keyed like every other entry even though \"not a route\" does not actually\n   * vary by departing URL: a source-independent negative would be a second\n   * keying rule to keep correct, and the only cost of the uniform one is a\n   * repeated fetch for a link hovered from a second page.\n   */\n  setNegative(key: PrefetchKey): void {\n    this.set(key, NEGATIVE_ENTRY);\n  }\n\n  /** Check if the entry is a negative cache entry (URL is not a route). */\n  isNegative(key: PrefetchKey): boolean {\n    return this.get(key) === NEGATIVE_ENTRY;\n  }\n\n  /**\n   * Invalidate all entries whose destination URL matches (TIM-1454).\n   * Used by `revalidatePath` on a non-current route so the next navigation\n   * fetches fresh data instead of replaying a stale prefetch.\n   */\n  invalidateUrl(url: string): void {\n    for (const [mapKey] of this.entries) {\n      if (mapKey.endsWith(':' + url)) {\n        this.entries.delete(mapKey);\n      }\n    }\n  }\n\n  /**\n   * Evict all ready entries and fence in-flight singleflights (TIM-1476).\n   * Called after a server action that revalidated data — the mutation may\n   * affect any route, not just the paths the server named. In-flight\n   * singleflights are not aborted (they may carry post-mutation data),\n   * but their results are discarded if they complete after eviction:\n   * `fetchOrCoalesce` captures the generation before the flight and\n   * skips the store when it has been bumped.\n   *\n   * Consumers that join an in-flight flight via `joinInflight` must\n   * check `getEvictionGen()` before and after the await: if the gen\n   * changed, the result predates the eviction and must be discarded\n   * (codex on #1131 round 2).\n   */\n  clearReady(): void {\n    this.entries.clear();\n    this.evictionGen++;\n  }\n\n  getEvictionGen(): number {\n    return this.evictionGen;\n  }\n}\n","/**\n * What it means for a page to be \"current\" on the client.\n *\n * One module owns every write that makes a navigation's destination the\n * current page, and the read that describes the current page back to the\n * server. Keeping them together is the point: `X-Timber-State-Tree` is\n * derived from the segment cache, so the thing that publishes and the thing\n * that reports have to agree about when a page becomes current.\n *\n * See design/19-client-navigation.md §\"State Update Invariants\".\n */\n\nimport { buildSegmentTree, type SegmentCache } from './segment-cache.ts';\nimport type { HistoryStack } from './history.ts';\nimport type { SegmentInfo, StateTree } from '../shared/segment-info.ts';\nimport type { ParamsSource } from '../shared/payload-root.ts';\nimport { setNavigationState, type NavigationState } from './navigation-context.ts';\nimport {\n  statusPageRendered,\n  _setStatusPageRendered,\n  onStatusPageRendered,\n  _setOnStatusPageRendered,\n} from './state.ts';\n\n// ─── What a status page teaches the cache ─────────────────────────────────\n//\n// A status page replaces a subtree: a deny page lands at the segment owning\n// the matched file and nothing below it mounts; an `error.tsx` fallback\n// discards everything under the boundary that rendered it. `X-Timber-Segments`\n// nonetheless describes the whole chain the payload was built against — it\n// must, because a partial navigation picks its merge point out of it — so the\n// cache has to be told not to learn from such a tree.\n//\n// The HTTP status used to say so, and could not be trusted to: an RSC payload\n// response commits one macrotask after its first chunk, and a nested\n// component that denies after I/O puts its row in the stream after the\n// status line has gone out (TIM-1489). The only thing that reliably knows a\n// status page rendered is the status page itself, and the only moment that\n// matters is the commit that puts it on screen — so every status page the\n// framework produces is wrapped in `StatusPageMarker`, whose layout effect\n// reports on each commit that renders it. Layout effects run child-before-\n// parent, so the report lands before `NavigationRoot`'s publish of that\n// same commit, and never for a render React discards. Without Suspense\n// around the row, the transition cannot commit until the row has arrived, so\n// this covers the delayed nested case too, which no status ever could.\n//\n// The report also clears the cache on the spot, because not every commit\n// has a navigation to consume it: a deny row arriving inside a Suspense\n// boundary after its navigation published, or a status document being\n// hydrated, would otherwise leave a tree in the cache that is no longer on\n// screen. Consuming the flag at commit is what keeps the same navigation from\n// re-seeding it a moment later. Both are over-approximations — a page-level\n// deny leaves every layout standing — at the cost of one full render on the\n// next navigation.\n//\n// Slot boundaries do not report: a slot degrading is the page staying, and\n// the chain it mounted is the chain the header describes. See TIM-1356,\n// TIM-1495, design/04-authorization.md §\"Where a Deny Page Renders\".\n\n/**\n * Record that a status page for the main route is on screen. Called from\n * `StatusPageMarker`'s layout effect; consumed by the commit of the\n * navigation whose tree it belongs to, and acted on immediately for the\n * commits that have none.\n */\nexport function reportStatusPageRendered(): void {\n  _setStatusPageRendered(true);\n  onStatusPageRendered?.();\n}\n\n/** Everything a commit needs to describe the page it makes current. */\nexport interface NavigationCommitInput {\n  payload: unknown;\n  /** The params that payload published — replayed with it on popstate. */\n  params: ParamsSource;\n  /**\n   * The rendered chain's metadata, or null/undefined when this commit\n   * carries none at all — a revalidation payload, or a history entry\n   * stored before the channel existed.\n   *\n   * An empty *array* is a different statement from an absent one: the\n   * server rendered a route with no layout-bearing segments (a layoutless\n   * app — the missing-root-layout check is a warning, not an error), so\n   * the correct tree is the empty one. Collapsing the two left the\n   * departing route's tree in place, which `treePaths` then reported as\n   * mounted — enough to select an intercepting rewrite whose slot is not\n   * on screen (TIM-1282).\n   */\n  segmentInfo?: SegmentInfo[] | null;\n  /** When true, clear the segment cache if segmentInfo is absent\n   *  (popstate replay for entries without layout metadata). */\n  clearSegmentCacheOnEmpty?: boolean;\n  /**\n   * Layouts the server skipped on this response (`X-Timber-Skipped-Segments`),\n   * when it came from a fetch. Omitted by replays and revalidation.\n   *\n   * Together with `skipped` slot entries in `segmentInfo`, this decides\n   * whether the payload can be *replayed*. A partial payload only renders\n   * merged over the tree on screen, and a `skip=true` outlet resolves against\n   * the slot content cache at render time — so a stored copy of either,\n   * replayed later, shows whatever the client holds *then*, not what was on\n   * screen when the entry committed. Such entries store a null payload and\n   * traversals to them fetch instead. Decided here, not at the fetch call\n   * sites, because there are three of those (`performNavigationFetch`,\n   * `refresh()`, and uncached traversal) and a rule applied at one of them\n   * holds by accident: `performNavigationFetch` had the check and\n   * `fetchCommitAndRender` did not, so a back/forward fetch that was\n   * answered with skips stored the holes (TIM-1432).\n   */\n  skippedSegments?: string[] | null;\n}\n\n/** Whether a response skipped layouts — its payload merges over the tree on screen. */\nexport function isPartialNavigation(skippedSegments: string[] | null | undefined): boolean {\n  return skippedSegments != null && skippedSegments.length > 0;\n}\n\n/**\n * Whether a payload can stand on its own when replayed from the history\n * stack. See `NavigationCommitInput.skippedSegments`.\n */\nfunction isReplayable(opts: NavigationCommitInput): boolean {\n  return !isPartialNavigation(opts.skippedSegments) && !hasSkippedSlot(opts.segmentInfo);\n}\n\nfunction hasSkippedSlot(segmentInfo: SegmentInfo[] | null | undefined): boolean {\n  return segmentInfo?.some((s) => s.slot && s.skipped) ?? false;\n}\n\n/**\n * The metadata a history entry keeps. `skipped` describes the *response*\n * — \"this slot's content was omitted\" — and the entry stores no such\n * payload (it stores null). Left on the entry, the flag outlives the\n * response: `applyActionResult()` reuses the entry's metadata beside a full\n * re-render and would have that judged non-replayable too.\n */\nfunction storedSegmentInfo(segmentInfo: SegmentInfo[] | null | undefined) {\n  if (!hasSkippedSlot(segmentInfo)) return segmentInfo;\n  return segmentInfo!.map(({ skipped: _skipped, ...rest }) => rest);\n}\n\n/**\n * A navigation's destination, split into what a render needs and what a\n * commit publishes.\n */\nexport interface PreparedNavigation {\n  /** The state the incoming tree renders with. Pure — safe before winning. */\n  navState: NavigationState;\n  /** Publishes the destination. Call only once the render has won. */\n  commit: () => void;\n}\n\nexport interface NavigationCommitter {\n  prepareNavigation(url: string, opts: NavigationCommitInput): PreparedNavigation;\n  currentStateTree(): StateTree | undefined;\n  updateSegmentCache(segmentInfo: SegmentInfo[] | null | undefined): void;\n}\n\n/**\n * Derive the navigation state (pathname + search) a URL renders with.\n *\n * Pure: publishing it — the module-level fallback for tests and SSR, and the\n * globalThis bridge — is `prepareNavigation`'s commit, which runs only once\n * the render is known to have won (TIM-1301). Callers pass the returned value\n * explicitly to renderRoot/wrapPayload, so a render never depends on the\n * publish having happened first.\n */\nexport function deriveNavigationState(url: string): NavigationState {\n  // Params are not part of it. They travel with the payload and are published\n  // by the one client-owned `ParamsProvider` as the new tree renders, which is\n  // also what clears the previous route's — a route with no params of its own\n  // still publishes an empty record (TIM-1294/TIM-1297, and the clearing\n  // requirement from TIM-1285).\n  const parsed = new URL(url, 'http://localhost');\n  return { pathname: parsed.pathname || '/', search: parsed.search };\n}\n\nexport function createNavigationCommitter(deps: {\n  segmentCache: SegmentCache;\n  historyStack: HistoryStack;\n  /** Read at call time — the router's `clientSegmentCache` opt-in. */\n  clientSegmentCache: () => boolean | undefined;\n}): NavigationCommitter {\n  const { segmentCache, historyStack } = deps;\n\n  // See `reportStatusPageRendered`: a status page that commits with no\n  // navigation to consume the report still empties the cache.\n  _setOnStatusPageRendered(() => segmentCache.clear());\n\n  /**\n   * Update the segment cache from server-provided segment metadata.\n   *\n   * Runs whether or not `clientSegmentCache` is enabled: the tree is also\n   * where the mounted tree paths come from, and those cross on every\n   * navigation. What the flag gates is which parts get serialized — see\n   * `currentStateTree`.\n   */\n  function updateSegmentCache(segmentInfo: SegmentInfo[] | null | undefined): void {\n    if (!segmentInfo || segmentInfo.length === 0) return;\n    const tree = buildSegmentTree(segmentInfo);\n    if (tree) {\n      segmentCache.set('/', tree);\n    }\n  }\n\n  return {\n    updateSegmentCache,\n\n    /**\n     * The X-Timber-State-Tree to send with the next RSC request.\n     *\n     * Two different things travel on one header. `segments`/`slots` are the\n     * caching opt-in and are omitted unless `clientSegmentCache` is on.\n     * `treePaths` is how the server learns which route is actually mounted,\n     * which stops being derivable from the address bar as soon as a modal is\n     * open — so it crosses regardless (TIM-1282). Undefined when there is\n     * nothing to say, so a no-op header never enters the `_rsc` cache key.\n     *\n     * Reads what the last *committed* navigation published, so a superseded\n     * navigation's destination can never end up describing the mounted tree\n     * (TIM-1301).\n     */\n    currentStateTree(): StateTree | undefined {\n      const tree = segmentCache.serializeStateTree();\n      if (deps.clientSegmentCache()) return tree;\n      return tree.treePaths ? { segments: [], treePaths: tree.treePaths } : undefined;\n    },\n\n    /**\n     * Prepare all navigation-owned state for a new page — without publishing\n     * any of it. Every code path that changes the \"current page\" must go\n     * through this function, which is what makes \"forgot a field\" impossible\n     * by construction.\n     *\n     * Returns the destination's `NavigationState`, which is a pure function of\n     * the URL and is what the incoming tree is *rendered* with, plus a\n     * `commit` thunk that performs the writes that make a page current:\n     * 1. Segment cache — update from server-provided segment metadata\n     * 2. Navigation state — pathname/search for usePathname/useSearchParams\n     * 3. History stack — store the payload for instant back/forward replay\n     *\n     * Nothing is written until `commit()` runs, and on a transitioned\n     * navigation it runs only once the transition is known to have won — see\n     * `renderViaTransition` and `NavigationRoot`. A navigation superseded\n     * while its payload was in flight never calls it, so the cache, the\n     * pathname the client reports and the history stack all keep describing\n     * the route still on screen (TIM-1301).\n     *\n     * Callers with state of their own to publish — the address bar, the\n     * client's record of the mounted tree — wrap this thunk rather than\n     * commit beside it, so there stays exactly one moment at which a page\n     * becomes current.\n     */\n    prepareNavigation(url: string, opts: NavigationCommitInput): PreparedNavigation {\n      const navState = deriveNavigationState(url);\n      const payload = isReplayable(opts) ? opts.payload : null;\n\n      // The tree this navigation renders has not rendered yet. Whatever a\n      // boundary reported before now belongs to a commit that had no\n      // navigation to consume it — a hydration, a row that arrived inside a\n      // Suspense boundary after its navigation had published — and must not\n      // be charged to this one.\n      _setStatusPageRendered(false);\n\n      return {\n        navState,\n        commit() {\n          // A tree in which a boundary rendered a status page is not one to\n          // cache — see the module note. Read at commit rather than at\n          // prepare because that is when the boundary has spoken: the row it\n          // renders may not have existed when the response headers were read.\n          // The history entry records the same thing, or a traversal back to\n          // this URL would replay the metadata this drops.\n          const cacheable = !statusPageRendered;\n          _setStatusPageRendered(false);\n          const segmentInfo = cacheable ? opts.segmentInfo : [];\n\n          if (segmentInfo && segmentInfo.length > 0) {\n            updateSegmentCache(segmentInfo);\n          } else if (segmentInfo?.length === 0 || opts.clearSegmentCacheOnEmpty) {\n            segmentCache.clear();\n          }\n\n          setNavigationState(navState);\n\n          historyStack.push(url, {\n            payload,\n            params: opts.params,\n            segmentInfo: storedSegmentInfo(segmentInfo),\n          });\n        },\n      };\n    },\n  };\n}\n","'use client';\n\n/**\n * The one way a status page tells the router it is on screen.\n *\n * A status page replaces a subtree, and the segment cache must not learn a\n * chain that never mounted (see `navigation-commit.ts` §\"What a status page\n * teaches the cache\"). Status pages are produced in three places — an\n * in-tree catch site rendering the page it owns, the server's fallback\n * renderers, and a client boundary rendering its fallback for a Flight row —\n * and every one of them wraps the page in this marker, so the report does\n * not depend on which producer it was. In particular the in-tree case, the\n * common `access.ts` deny, never involves a client boundary at all.\n *\n * A layout effect, on every commit that renders the marker rather than on\n * mount only: React reuses the fiber when one status page is replaced by\n * another at the same position, and the second one must report too. Layout\n * effects run child-before-parent, so the report lands before the ancestor\n * `NavigationRoot` publishes the same commit, and never for a render React\n * discards. Idempotent, so StrictMode's double invocation and a status page\n * re-rendering on its own state are harmless. See TIM-1495.\n */\n\nimport { useLayoutEffect, type ReactNode } from 'react';\nimport { reportStatusPageRendered } from './navigation-commit.ts';\n\nexport function StatusPageMarker({ children }: { children: ReactNode }): ReactNode {\n  useLayoutEffect(() => {\n    reportStatusPageRendered();\n  });\n  return children;\n}\n"],"mappings":"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"}