@timber-js/app 0.2.0-alpha.208 → 0.2.0-alpha.209

package/dist/_chunks/{navigation-context-D0TU0Jog.js → segment-context-xtPUGfdq.js}

@@ -1,4 +1,4 @@
-import { createContext, createElement, useContext } from "react";
+import { createContext, createElement, useContext, useMemo } from "react";
 //#region src/client/navigation-context.ts
 /**
 * NavigationContext — React context for navigation state.
@@ -12,8 +12,8 @@ import { createContext, createElement, useContext } from "react";
 *
 * Segment params are NOT here — see the note on NavigationState below.
 *
-* By wrapping the RSC payload element in NavigationProvider inside
-* renderRoot(), the context value and the element tree are passed to
+* By wrapping the RSC payload element in NavigationProvider inside the
+* router's `renderTree` (browser-entry/router-init.ts), the context value and the element tree are passed to
 * reactRoot.render() in the same call — atomic by construction.
 * All consumers (usePathname, useSearchParams) see the new values in the
 * same render pass as the new tree.
@@ -76,41 +76,13 @@ function useNavigationContext() {
 /**
 * Wraps children with NavigationContext.Provider.
 *
-* Used in browser-entry.ts renderRoot to wrap the RSC payload element
+* Used in browser-entry/router-init.ts `renderTree` to wrap the RSC payload element
 * so that navigation state updates atomically with the tree render.
 */
 function NavigationProvider({ value, children }) {
 	return createElement(getOrCreateContext().Provider, { value }, children);
 }
 /**
-* Navigation state communicated between the router and renderRoot.
-*
-* The router calls setNavigationState() before renderRoot(). The
-* renderRoot callback reads via getNavigationState() to create the
-* NavigationProvider with the correct params/pathname.
-*
-* This is NOT used by hooks directly — hooks read from React context.
-*
-* Stored on globalThis (like the context instances above) because the
-* router lives in one chunk while renderRoot lives in another. Module-
-* level variables would be separate per chunk.
-*/
-var NAV_STATE_KEY = Symbol.for("__timber_nav_state");
-function _getNavStateStore() {
-	const g = globalThis;
-	if (!g[NAV_STATE_KEY]) g[NAV_STATE_KEY] = { current: {
-		pathname: "/",
-		search: ""
-	} };
-	return g[NAV_STATE_KEY];
-}
-function setNavigationState(state) {
-	_getNavStateStore().current = state;
-}
-function getNavigationState() {
-	return _getNavStateStore().current;
-}
-/**
 * There was a second React context here — `PendingNavigationContext`, holding
 * the in-flight navigation URL, provided by `NavigationRoot` out of a
 * `useState` — plus a `usePendingNavigationUrl()` reader for it. Both are gone
@@ -130,6 +102,36 @@ function getNavigationState() {
 * design/19-client-navigation.md §"How Pending State Works".
 */
 //#endregion
-export { useNavigationContext as i, getNavigationState as n, setNavigationState as r, NavigationProvider as t };
+//#region src/client/segment-context.ts
+/**
+* Segment Context — provides layout segment position for useSelectedLayoutSegment hooks.
+*
+* Each layout in the segment tree is wrapped with a SegmentProvider that stores
+* the URL segments from root to the current layout level. The hooks read this
+* context to determine which child segments are active below the calling layout.
+*
+* The context value is intentionally minimal: just the segment path array and
+* parallel route keys. No internal cache details are exposed.
+*
+* Design docs: design/19-client-navigation.md, design/14-ecosystem.md
+*/
+var SegmentContext = createContext(null);
+/** Read the segment context. Returns null if no provider is above this component. */
+function useSegmentContext() {
+	return useContext(SegmentContext);
+}
+/**
+* Wraps each layout to provide segment position context.
+* Injected by rsc-entry.ts during element tree construction.
+*/
+function SegmentProvider({ segments, segmentId: _segmentId, parallelRouteKeys, children }) {
+	const value = useMemo(() => ({
+		segments,
+		parallelRouteKeys
+	}), [segments, parallelRouteKeys]);
+	return createElement(SegmentContext.Provider, { value }, children);
+}
+//#endregion
+export { useNavigationContext as i, useSegmentContext as n, NavigationProvider as r, SegmentProvider as t };
 
-//# sourceMappingURL=navigation-context-D0TU0Jog.js.map
+//# sourceMappingURL=segment-context-xtPUGfdq.js.map

package/dist/_chunks/segment-context-xtPUGfdq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-context-xtPUGfdq.js","names":[],"sources":["../../src/client/navigation-context.ts","../../src/client/segment-context.ts"],"sourcesContent":["'use client';\n\n/**\n * NavigationContext — React context for navigation state.\n *\n * Holds the current pathname and search, updated atomically with the RSC\n * tree on each navigation. This replaces the previous useSyncExternalStore\n * approach for usePathname() and useSearchParams(), which suffered from a\n * timing gap: the new tree could commit before the external store\n * re-renders fired, causing a frame where both old and new active states\n * were visible simultaneously.\n *\n * Segment params are NOT here — see the note on NavigationState below.\n *\n * By wrapping the RSC payload element in NavigationProvider inside the\n * router's `renderTree` (browser-entry/router-init.ts), the context value and the element tree are passed to\n * reactRoot.render() in the same call — atomic by construction.\n * All consumers (usePathname, useSearchParams) see the new values in the\n * same render pass as the new tree.\n *\n * During SSR, the wrapper chain mounts this same provider with the\n * request's pathname and raw search string (TIM-1424), so the hooks\n * resolve through the identical code path on both sides. Per-request\n * isolation is by construction — the value is part of the request's\n * element tree.\n *\n * This module is `'use client'` and is never evaluated in the RSC\n * environment. The shims plugin resolves next/navigation to\n * navigation-rsc.ts in RSC, which has throwing stubs (TIM-1420).\n *\n * SINGLETON GUARANTEE: All shared mutable state uses globalThis via\n * Symbol.for keys. The RSC client bundler can duplicate this module\n * across chunks (browser-entry graph + client-reference graph). With\n * ESM output, each chunk gets its own module scope — module-level\n * variables would create separate singleton instances per chunk.\n * globalThis guarantees a single instance regardless of duplication.\n *\n * This workaround will be removed when Rolldown ships `format: 'app'`\n * (module registry format that deduplicates like webpack/Turbopack).\n * See design/27-chunking-strategy.md.\n *\n * See design/19-client-navigation.md §\"NavigationContext\"\n */\n\nimport { createContext, useContext, createElement, type ReactNode } from 'react';\n\n// ---------------------------------------------------------------------------\n// Context type\n// ---------------------------------------------------------------------------\n\n/**\n * What the browser knows about the current location.\n *\n * Params are deliberately absent: they are a property of the tree the server\n * rendered, not of the address bar, and they now travel inside the payload as\n * the payload root. Keeping a copy here meant the router had to thread\n * the record from a response header into context on every path — navigation,\n * traversal, prefetch, revalidation — and each of those was a place to drop it\n * (TIM-1294).\n */\nexport interface NavigationState {\n  pathname: string;\n  search: string;\n}\n\n// ---------------------------------------------------------------------------\n// Lazy context initialization\n// ---------------------------------------------------------------------------\n\n/**\n * Context instances are stored on globalThis (NOT in module-level\n * variables) because the ESM bundler can duplicate this module across\n * chunks. Module-level variables would create separate instances per\n * chunk — the provider in NavigationRoot (index chunk) would use\n * context A while the consumer in usePendingNavigation (shared chunk)\n * reads from context B. globalThis guarantees a single instance.\n *\n * This module is `'use client'` so it is never evaluated in the RSC\n * environment — `createContext` and `useContext` are always available.\n * The shims plugin resolves next/navigation to navigation-rsc.ts in RSC,\n * which has throwing stubs for the hooks (TIM-1420).\n *\n * See design/27-chunking-strategy.md §\"Singleton Safety\"\n */\n\nconst NAV_CTX_KEY = Symbol.for('__timber_nav_ctx');\n\nfunction getOrCreateContext(): import('react').Context<NavigationState | null> {\n  const existing = (globalThis as Record<symbol, unknown>)[NAV_CTX_KEY] as\n    | import('react').Context<NavigationState | null>\n    | undefined;\n  if (existing !== undefined) return existing;\n  const ctx = createContext<NavigationState | null>(null);\n  (globalThis as Record<symbol, unknown>)[NAV_CTX_KEY] = ctx;\n  return ctx;\n}\n\n/**\n * Read the navigation context. Returns null only when no provider is above\n * the caller — a component rendered outside the timber app.\n *\n * Internal — used by usePathname() and useSearchParams().\n */\nexport function useNavigationContext(): NavigationState | null {\n  return useContext(getOrCreateContext());\n}\n\n// ---------------------------------------------------------------------------\n// Provider component\n// ---------------------------------------------------------------------------\n\nexport interface NavigationProviderProps {\n  value: NavigationState;\n  children?: ReactNode;\n}\n\n/**\n * Wraps children with NavigationContext.Provider.\n *\n * Used in browser-entry/router-init.ts `renderTree` to wrap the RSC payload element\n * so that navigation state updates atomically with the tree render.\n */\nexport function NavigationProvider({\n  value,\n  children,\n}: NavigationProviderProps): import('react').ReactElement {\n  return createElement(getOrCreateContext().Provider, { value }, children);\n}\n\n// ---------------------------------------------------------------------------\n// Pending navigation state lives in the router, not here\n// ---------------------------------------------------------------------------\n\n/**\n * There was a second React context here — `PendingNavigationContext`, holding\n * the in-flight navigation URL, provided by `NavigationRoot` out of a\n * `useState` — plus a `usePendingNavigationUrl()` reader for it. Both are gone\n * (TIM-1307).\n *\n * Nothing read them. `usePendingNavigation()` (use-pending-navigation.ts) and\n * `TopLoader` both subscribe to the router's external pending store via\n * `useSyncExternalStore`: sync priority, immune to transition entanglement,\n * and cleared by `runNavigation`'s supersession-guarded `finally` (TIM-1034).\n * The context was a parallel representation of the same fact that no consumer\n * ever migrated to, and one that could not even agree with the store — a\n * navigation superseded by a cached popstate replay left its URL set until the\n * next full navigation, because the staleness guard skipped the clear and no\n * other path touched it.\n *\n * One representation, and it is the router's. See\n * design/19-client-navigation.md §\"How Pending State Works\".\n */\n","/**\n * Segment Context — provides layout segment position for useSelectedLayoutSegment hooks.\n *\n * Each layout in the segment tree is wrapped with a SegmentProvider that stores\n * the URL segments from root to the current layout level. The hooks read this\n * context to determine which child segments are active below the calling layout.\n *\n * The context value is intentionally minimal: just the segment path array and\n * parallel route keys. No internal cache details are exposed.\n *\n * Design docs: design/19-client-navigation.md, design/14-ecosystem.md\n */\n\n'use client';\n\nimport { createContext, useContext, createElement, useMemo } from 'react';\n\n// ─── Types ───────────────────────────────────────────────────────\n\nexport interface SegmentContextValue {\n  /** URL segments from root to this layout (e.g. ['', 'dashboard', 'settings']) */\n  segments: string[];\n  /** Parallel route slot keys available at this layout level (e.g. ['sidebar', 'modal']) */\n  parallelRouteKeys: string[];\n}\n\n// ─── Context ─────────────────────────────────────────────────────\n\nconst SegmentContext = createContext<SegmentContextValue | null>(null);\n\n/** Read the segment context. Returns null if no provider is above this component. */\nexport function useSegmentContext(): SegmentContextValue | null {\n  return useContext(SegmentContext);\n}\n\n// ─── Provider ────────────────────────────────────────────────────\n\ninterface SegmentProviderProps {\n  segments: string[];\n  /**\n   * Unique identifier for this segment, used by the client-side segment\n   * merger for element caching. For route groups this includes the group\n   * name (e.g., \"/(marketing)\") since groups share their parent's urlPath.\n   * Falls back to the reconstructed path from `segments` if not provided.\n   */\n  segmentId?: string;\n  parallelRouteKeys: string[];\n  children: React.ReactNode;\n}\n\n/**\n * Wraps each layout to provide segment position context.\n * Injected by rsc-entry.ts during element tree construction.\n */\nexport function SegmentProvider({\n  segments,\n  segmentId: _segmentId,\n  parallelRouteKeys,\n  children,\n}: SegmentProviderProps) {\n  const value = useMemo(\n    () => ({ segments, parallelRouteKeys }),\n    // segments and parallelRouteKeys are static per layout — the layout's\n    // position in the tree is fixed. The arrays are used directly as deps\n    // (React Compiler requires simple expressions here). Referential stability\n    // of the context value doesn't matter: every consumer\n    // (useSelectedLayoutSegment/useSelectedLayoutSegments) also calls\n    // usePathname(), so it re-renders on every navigation regardless.\n    [segments, parallelRouteKeys]\n  );\n  return createElement(SegmentContext.Provider, { value }, children);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqFA,IAAM,cAAc,OAAO,IAAI,kBAAkB;AAEjD,SAAS,qBAAsE;CAC7E,MAAM,WAAY,WAAuC;CAGzD,IAAI,aAAa,KAAA,GAAW,OAAO;CACnC,MAAM,MAAM,cAAsC,IAAI;CACtD,WAAwC,eAAe;CACvD,OAAO;AACT;;;;;;;AAQA,SAAgB,uBAA+C;CAC7D,OAAO,WAAW,mBAAmB,CAAC;AACxC;;;;;;;AAiBA,SAAgB,mBAAmB,EACjC,OACA,YACwD;CACxD,OAAO,cAAc,mBAAmB,CAAC,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ;AACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnGA,IAAM,iBAAiB,cAA0C,IAAI;;AAGrE,SAAgB,oBAAgD;CAC9D,OAAO,WAAW,cAAc;AAClC;;;;;AAqBA,SAAgB,gBAAgB,EAC9B,UACA,WAAW,YACX,mBACA,YACuB;CACvB,MAAM,QAAQ,eACL;EAAE;EAAU;CAAkB,IAOrC,CAAC,UAAU,iBAAiB,CAC9B;CACA,OAAO,cAAc,eAAe,UAAU,EAAE,MAAM,GAAG,QAAQ;AACnE"}

package/dist/_chunks/{singleflight-2lUWfcAk.js → singleflight-BeVMMKi0.js}

@@ -20,8 +20,9 @@ function createSingleflight(opts) {
 			let promise;
 			if (timeoutMs != null && timeoutMs > 0) promise = new Promise((resolve, reject) => {
 				const timer = setTimeout(() => {
-					ac.abort();
-					reject(new SingleflightTimeoutError(key, timeoutMs));
+					const timeout = new SingleflightTimeoutError(key, timeoutMs);
+					ac.abort(timeout);
+					reject(timeout);
 				}, timeoutMs);
 				try {
 					fn(ac.signal).then((value) => {
@@ -51,4 +52,4 @@ function createSingleflight(opts) {
 //#endregion
 export { createSingleflight as n, SingleflightTimeoutError as t };
 
-//# sourceMappingURL=singleflight-2lUWfcAk.js.map
+//# sourceMappingURL=singleflight-BeVMMKi0.js.map

package/dist/_chunks/{singleflight-2lUWfcAk.js.map → singleflight-BeVMMKi0.js.map}

@@ -1 +1 @@
-{"version":3,"file":"singleflight-2lUWfcAk.js","names":[],"sources":["../../src/cache/singleflight.ts"],"sourcesContent":["/**\n * Singleflight coalesces concurrent calls with the same key into a single\n * execution. All callers receive the same result (or error).\n *\n * Per-process, in-memory. Each process coalesces independently.\n *\n * An optional `timeoutMs` prevents hung `fn()` calls from permanently\n * blocking all future callers for that key. When set, `fn()` is raced\n * against a timeout — if the timeout fires first, the promise rejects\n * with `SingleflightTimeoutError`, `finally` cleans up the key, and\n * subsequent callers can retry. See TIM-518.\n */\n\nexport interface SingleflightOptions {\n  /** Maximum time (ms) a coalesced call may run before being rejected. */\n  timeoutMs?: number;\n}\n\nexport interface Singleflight {\n  do<T>(key: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  /** Return the in-flight promise for a key, or undefined if none. */\n  get(key: string): Promise<unknown> | undefined;\n}\n\n/**\n * Error thrown when a singleflight call exceeds `timeoutMs`.\n * Exported so callers can distinguish timeout from other errors.\n */\nexport class SingleflightTimeoutError extends Error {\n  constructor(key: string, timeoutMs: number) {\n    super(`Singleflight timeout: key \"${key}\" exceeded ${timeoutMs}ms`);\n    this.name = 'SingleflightTimeoutError';\n  }\n}\n\nexport function createSingleflight(opts?: SingleflightOptions): Singleflight {\n  const inflight = new Map<string, Promise<unknown>>();\n  const timeoutMs = opts?.timeoutMs;\n\n  return {\n    do<T>(key: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {\n      const existing = inflight.get(key);\n      if (existing) return existing as Promise<T>;\n\n      const ac = new AbortController();\n      let promise: Promise<T>;\n\n      if (timeoutMs != null && timeoutMs > 0) {\n        // Race fn() against a timeout to prevent hung calls from\n        // permanently blocking the key. See TIM-518.\n        // Abort the signal on timeout so the callback can skip\n        // side effects (e.g. cache writes). See TIM-1092.\n        promise = new Promise<T>((resolve, reject) => {\n          const timer = setTimeout(() => {\n            ac.abort();\n            reject(new SingleflightTimeoutError(key, timeoutMs));\n          }, timeoutMs);\n          try {\n            fn(ac.signal).then(\n              (value) => {\n                clearTimeout(timer);\n                resolve(value);\n              },\n              (err) => {\n                clearTimeout(timer);\n                reject(err);\n              }\n            );\n          } catch (err) {\n            clearTimeout(timer);\n            reject(err);\n          }\n        });\n      } else {\n        promise = fn(ac.signal);\n      }\n\n      const tracked = promise.finally(() => {\n        inflight.delete(key);\n      });\n\n      inflight.set(key, tracked);\n      return tracked as Promise<T>;\n    },\n    get(key: string): Promise<unknown> | undefined {\n      return inflight.get(key);\n    },\n  };\n}\n"],"mappings":";;;;;AA4BA,IAAa,2BAAb,cAA8C,MAAM;CAClD,YAAY,KAAa,WAAmB;EAC1C,MAAM,8BAA8B,IAAI,aAAa,UAAU,GAAG;EAClE,KAAK,OAAO;CACd;AACF;AAEA,SAAgB,mBAAmB,MAA0C;CAC3E,MAAM,2BAAW,IAAI,IAA8B;CACnD,MAAM,YAAY,MAAM;CAExB,OAAO;EACL,GAAM,KAAa,IAAqD;GACtE,MAAM,WAAW,SAAS,IAAI,GAAG;GACjC,IAAI,UAAU,OAAO;GAErB,MAAM,KAAK,IAAI,gBAAgB;GAC/B,IAAI;GAEJ,IAAI,aAAa,QAAQ,YAAY,GAKnC,UAAU,IAAI,SAAY,SAAS,WAAW;IAC5C,MAAM,QAAQ,iBAAiB;KAC7B,GAAG,MAAM;KACT,OAAO,IAAI,yBAAyB,KAAK,SAAS,CAAC;IACrD,GAAG,SAAS;IACZ,IAAI;KACF,GAAG,GAAG,MAAM,CAAC,CAAC,MACX,UAAU;MACT,aAAa,KAAK;MAClB,QAAQ,KAAK;KACf,IACC,QAAQ;MACP,aAAa,KAAK;MAClB,OAAO,GAAG;KACZ,CACF;IACF,SAAS,KAAK;KACZ,aAAa,KAAK;KAClB,OAAO,GAAG;IACZ;GACF,CAAC;QAED,UAAU,GAAG,GAAG,MAAM;GAGxB,MAAM,UAAU,QAAQ,cAAc;IACpC,SAAS,OAAO,GAAG;GACrB,CAAC;GAED,SAAS,IAAI,KAAK,OAAO;GACzB,OAAO;EACT;EACA,IAAI,KAA2C;GAC7C,OAAO,SAAS,IAAI,GAAG;EACzB;CACF;AACF"}
+{"version":3,"file":"singleflight-BeVMMKi0.js","names":[],"sources":["../../src/cache/singleflight.ts"],"sourcesContent":["/**\n * Singleflight coalesces concurrent calls with the same key into a single\n * execution. All callers receive the same result (or error).\n *\n * Per-process, in-memory. Each process coalesces independently.\n *\n * An optional `timeoutMs` prevents hung `fn()` calls from permanently\n * blocking all future callers for that key. When set, `fn()` is raced\n * against a timeout — if the timeout fires first, the promise rejects\n * with `SingleflightTimeoutError`, `finally` cleans up the key, and\n * subsequent callers can retry. See TIM-518.\n */\n\nexport interface SingleflightOptions {\n  /** Maximum time (ms) a coalesced call may run before being rejected. */\n  timeoutMs?: number;\n}\n\nexport interface Singleflight {\n  do<T>(key: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;\n  /** Return the in-flight promise for a key, or undefined if none. */\n  get(key: string): Promise<unknown> | undefined;\n}\n\n/**\n * Error thrown when a singleflight call exceeds `timeoutMs`.\n * Exported so callers can distinguish timeout from other errors.\n */\nexport class SingleflightTimeoutError extends Error {\n  constructor(key: string, timeoutMs: number) {\n    super(`Singleflight timeout: key \"${key}\" exceeded ${timeoutMs}ms`);\n    this.name = 'SingleflightTimeoutError';\n  }\n}\n\nexport function createSingleflight(opts?: SingleflightOptions): Singleflight {\n  const inflight = new Map<string, Promise<unknown>>();\n  const timeoutMs = opts?.timeoutMs;\n\n  return {\n    do<T>(key: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {\n      const existing = inflight.get(key);\n      if (existing) return existing as Promise<T>;\n\n      const ac = new AbortController();\n      let promise: Promise<T>;\n\n      if (timeoutMs != null && timeoutMs > 0) {\n        // Race fn() against a timeout to prevent hung calls from\n        // permanently blocking the key. See TIM-518.\n        // Abort the signal on timeout so the callback can skip\n        // side effects (e.g. cache writes). See TIM-1092.\n        promise = new Promise<T>((resolve, reject) => {\n          const timer = setTimeout(() => {\n            // The timeout error is also the signal's reason, so the body\n            // can tell why it was aborted (runBackgroundFlight reports it).\n            const timeout = new SingleflightTimeoutError(key, timeoutMs);\n            ac.abort(timeout);\n            reject(timeout);\n          }, timeoutMs);\n          try {\n            fn(ac.signal).then(\n              (value) => {\n                clearTimeout(timer);\n                resolve(value);\n              },\n              (err) => {\n                clearTimeout(timer);\n                reject(err);\n              }\n            );\n          } catch (err) {\n            clearTimeout(timer);\n            reject(err);\n          }\n        });\n      } else {\n        promise = fn(ac.signal);\n      }\n\n      const tracked = promise.finally(() => {\n        inflight.delete(key);\n      });\n\n      inflight.set(key, tracked);\n      return tracked as Promise<T>;\n    },\n    get(key: string): Promise<unknown> | undefined {\n      return inflight.get(key);\n    },\n  };\n}\n"],"mappings":";;;;;AA4BA,IAAa,2BAAb,cAA8C,MAAM;CAClD,YAAY,KAAa,WAAmB;EAC1C,MAAM,8BAA8B,IAAI,aAAa,UAAU,GAAG;EAClE,KAAK,OAAO;CACd;AACF;AAEA,SAAgB,mBAAmB,MAA0C;CAC3E,MAAM,2BAAW,IAAI,IAA8B;CACnD,MAAM,YAAY,MAAM;CAExB,OAAO;EACL,GAAM,KAAa,IAAqD;GACtE,MAAM,WAAW,SAAS,IAAI,GAAG;GACjC,IAAI,UAAU,OAAO;GAErB,MAAM,KAAK,IAAI,gBAAgB;GAC/B,IAAI;GAEJ,IAAI,aAAa,QAAQ,YAAY,GAKnC,UAAU,IAAI,SAAY,SAAS,WAAW;IAC5C,MAAM,QAAQ,iBAAiB;KAG7B,MAAM,UAAU,IAAI,yBAAyB,KAAK,SAAS;KAC3D,GAAG,MAAM,OAAO;KAChB,OAAO,OAAO;IAChB,GAAG,SAAS;IACZ,IAAI;KACF,GAAG,GAAG,MAAM,CAAC,CAAC,MACX,UAAU;MACT,aAAa,KAAK;MAClB,QAAQ,KAAK;KACf,IACC,QAAQ;MACP,aAAa,KAAK;MAClB,OAAO,GAAG;KACZ,CACF;IACF,SAAS,KAAK;KACZ,aAAa,KAAK;KAClB,OAAO,GAAG;IACZ;GACF,CAAC;QAED,UAAU,GAAG,GAAG,MAAM;GAGxB,MAAM,UAAU,QAAQ,cAAc;IACpC,SAAS,OAAO,GAAG;GACrB,CAAC;GAED,SAAS,IAAI,KAAK,OAAO;GACzB,OAAO;EACT;EACA,IAAI,KAA2C;GAC7C,OAAO,SAAS,IAAI,GAAG;EACzB;CACF;AACF"}

package/dist/_chunks/{sizeof-lXffQ1Vr.js → sizeof-UwzwB1uM.js}

@@ -1,3 +1,4 @@
+import { _ as swallow } from "./logger-DiDt5ppH.js";
 //#region src/cache/sizeof.ts
 /**
 * Lightweight byte-size estimation for cache entries.
@@ -25,11 +26,11 @@ function estimateByteSize(value) {
 		if (json === void 0) return 0;
 		return json.length * 2;
 	} catch (e) {
-		console.debug("[timber] sizeof estimation failed:", e instanceof Error ? e.message : e);
+		swallow(e, "sizeof estimation failed", { level: "debug" });
 		return 0;
 	}
 }
 //#endregion
 export { estimateByteSize as t };
 
-//# sourceMappingURL=sizeof-lXffQ1Vr.js.map
+//# sourceMappingURL=sizeof-UwzwB1uM.js.map

package/dist/_chunks/sizeof-UwzwB1uM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sizeof-UwzwB1uM.js","names":[],"sources":["../../src/cache/sizeof.ts"],"sourcesContent":["/**\n * Lightweight byte-size estimation for cache entries.\n *\n * Estimates the in-memory byte cost of a JavaScript value using\n * JSON.stringify().length * 2 (UTF-16 char width). This is a rough\n * approximation — it doesn't account for V8 object overhead, Map\n * metadata, or non-serializable values — but it's fast and good\n * enough for cache budget enforcement.\n *\n * Values that fail JSON serialization (circular references, BigInt,\n * etc.) return 0, allowing the entry to be cached without counting\n * toward the byte budget. This is a conservative choice: it's better\n * to cache and undercount than to reject the entry.\n */\n\nimport { swallow } from '../server/logger.ts';\n\n/**\n * Estimate the byte size of a value.\n *\n * Uses `JSON.stringify(value).length * 2` to approximate UTF-16\n * in-memory size. Returns 0 if the value is not serializable.\n */\nexport function estimateByteSize(value: unknown): number {\n  try {\n    const json = JSON.stringify(value);\n    if (json === undefined) return 0;\n    // Each JS string character is 2 bytes (UTF-16)\n    return json.length * 2;\n  } catch (e) {\n    // Circular reference or non-serializable value\n    swallow(e, 'sizeof estimation failed', { level: 'debug' });\n    return 0;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,iBAAiB,OAAwB;CACvD,IAAI;EACF,MAAM,OAAO,KAAK,UAAU,KAAK;EACjC,IAAI,SAAS,KAAA,GAAW,OAAO;EAE/B,OAAO,KAAK,SAAS;CACvB,SAAS,GAAG;EAEV,QAAQ,GAAG,4BAA4B,EAAE,OAAO,QAAQ,CAAC;EACzD,OAAO;CACT;AACF"}

package/dist/_chunks/ssr-data-nA3I70_n.js

@@ -0,0 +1,49 @@
+import { d as ssrDataProvider, i as _setSsrDataProvider } from "./state-BhNGPsdi.js";
+//#region src/client/ssr-data.ts
+/**
+* SSR Data — per-request state for client hooks during server-side rendering.
+*
+* `useCookie()` and `<Link preserveSearchParams>` have no React context to
+* read their request values from during SSR, so the SSR entry hands them
+* the request's cookies and search string through this module.
+* `useSearchParams()` reads NavigationContext and uses getSsrData() only to
+* detect that it is rendering on the server. Route
+* params do not travel here — client components read them from
+* `ParamsContext`, decoded from the payload root.
+*
+* Request isolation: ssr-entry.ts registers an ALS-backed provider via
+* registerSsrDataProvider(), so getSsrData() reads the current request's
+* store even when Suspense boundaries resolve asynchronously across
+* concurrent requests. There is no module-level fallback: outside an SSR
+* render (in the browser, or before the provider is registered) there is no
+* request, and getSsrData() returns undefined.
+*
+* IMPORTANT: This module must NOT import node:async_hooks or any Node.js-only
+* APIs, as it's imported by 'use client' hooks that are bundled for the browser.
+* The ALS instance lives in ssr-entry.ts (server-only); this module only holds
+* a reference to the provider function.
+*
+* All mutable state is delegated to client/state.ts for singleton guarantees.
+* See design/18-build-system.md §"Singleton State Registry"
+*/
+/**
+* Register the SSR data provider. Called once at module load by
+* ssr-entry.ts to wire up per-request data via AsyncLocalStorage; tests
+* register their own provider (and `undefined` to reset).
+*/
+function registerSsrDataProvider(provider) {
+	_setSsrDataProvider(provider);
+}
+/**
+* Read the current request's SSR data. Returns undefined when called
+* outside an SSR render (i.e. on the client after hydration).
+*
+* Used by client hooks' server snapshot functions.
+*/
+function getSsrData() {
+	return ssrDataProvider?.();
+}
+//#endregion
+export { registerSsrDataProvider as n, getSsrData as t };
+
+//# sourceMappingURL=ssr-data-nA3I70_n.js.map

package/dist/_chunks/ssr-data-nA3I70_n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-data-nA3I70_n.js","names":[],"sources":["../../src/client/ssr-data.ts"],"sourcesContent":["/**\n * SSR Data — per-request state for client hooks during server-side rendering.\n *\n * `useCookie()` and `<Link preserveSearchParams>` have no React context to\n * read their request values from during SSR, so the SSR entry hands them\n * the request's cookies and search string through this module.\n * `useSearchParams()` reads NavigationContext and uses getSsrData() only to\n * detect that it is rendering on the server. Route\n * params do not travel here — client components read them from\n * `ParamsContext`, decoded from the payload root.\n *\n * Request isolation: ssr-entry.ts registers an ALS-backed provider via\n * registerSsrDataProvider(), so getSsrData() reads the current request's\n * store even when Suspense boundaries resolve asynchronously across\n * concurrent requests. There is no module-level fallback: outside an SSR\n * render (in the browser, or before the provider is registered) there is no\n * request, and getSsrData() returns undefined.\n *\n * IMPORTANT: This module must NOT import node:async_hooks or any Node.js-only\n * APIs, as it's imported by 'use client' hooks that are bundled for the browser.\n * The ALS instance lives in ssr-entry.ts (server-only); this module only holds\n * a reference to the provider function.\n *\n * All mutable state is delegated to client/state.ts for singleton guarantees.\n * See design/18-build-system.md §\"Singleton State Registry\"\n */\n\nimport { ssrDataProvider, _setSsrDataProvider } from './state.ts';\n\n// ─── Types ────────────────────────────────────────────────────────\n\nexport interface SsrData {\n  /**\n   * The request's raw app-visible query string (`''` or `?…`), matching what\n   * `window.location.search` will hold after hydration. The raw string is\n   * the only representation carried here: it preserves repeated keys\n   * (`?tag=a&tag=b`), which a collapsed `Record<string, string>` cannot\n   * (TIM-1428). Parse with `new URLSearchParams(search)` where needed.\n   */\n  search: string;\n  /** The request's cookies as name→value pairs */\n  cookies: Map<string, string>;\n}\n\n// ─── ALS-Backed Provider ─────────────────────────────────────────\n//\n// Server-side code (ssr-entry.ts) registers a provider that reads\n// from AsyncLocalStorage. This avoids importing node:async_hooks\n// in this browser-bundled module.\n//\n// Module singleton guarantee: In Vite's SSR environment, both\n// ssr-entry.ts (via #/client/ssr-data.js) and client component hooks\n// (via @timber-js/app/client) must resolve to the SAME module instance\n// of this file. The timber-shims plugin ensures this by remapping\n// @timber-js/app/client → src/client/index.ts in the SSR environment.\n// Without this remap, @timber-js/app/client resolves to dist/ (via\n// package.json exports), creating a split where registerSsrDataProvider\n// writes to one instance but getSsrData reads from another.\n// See timber-shims plugin resolveId for details.\n\n/**\n * Register the SSR data provider. Called once at module load by\n * ssr-entry.ts to wire up per-request data via AsyncLocalStorage; tests\n * register their own provider (and `undefined` to reset).\n */\nexport function registerSsrDataProvider(provider: (() => SsrData | undefined) | undefined): void {\n  _setSsrDataProvider(provider);\n}\n\n/**\n * Read the current request's SSR data. Returns undefined when called\n * outside an SSR render (i.e. on the client after hydration).\n *\n * Used by client hooks' server snapshot functions.\n */\nexport function getSsrData(): SsrData | undefined {\n  return ssrDataProvider?.();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,SAAgB,wBAAwB,UAAyD;CAC/F,oBAAoB,QAAQ;AAC9B;;;;;;;AAQA,SAAgB,aAAkC;CAChD,OAAO,kBAAkB;AAC3B"}

package/dist/_chunks/{state-FippDgxN.js → state-BhNGPsdi.js}

@@ -5,14 +5,12 @@ function _setGlobalRouter(router) {
 	globalRouter = router;
 }
 /**
-* ALS-backed SSR data provider. When registered, getSsrData() reads from
-* this function (ALS store) instead of module-level currentSsrData.
+* ALS-backed SSR data provider, registered by the SSR entry. getSsrData()
+* reads through it; unset in the browser.
 */
 var ssrDataProvider;
-/** Fallback SSR data for tests and environments without ALS. */
-var currentSsrData;
-function _setCurrentSsrData(data) {
-	currentSsrData = data;
+function _setSsrDataProvider(provider) {
+	ssrDataProvider = provider;
 }
 /** Cached search string — avoids reparsing when URL hasn't changed. */
 var cachedSearch = "";
@@ -47,6 +45,6 @@ function _setOnStatusPageRendered(handler) {
 	onStatusPageRendered = handler;
 }
 //#endregion
-export { _setStatusPageRendered as a, cachedSearchParams as c, onStatusPageRendered as d, ssrDataProvider as f, _setOnStatusPageRendered as i, currentSsrData as l, unloading as m, _setCurrentSsrData as n, _setUnloading as o, statusPageRendered as p, _setGlobalRouter as r, cachedSearch as s, _setCachedSearch as t, globalRouter as u };
+export { _setStatusPageRendered as a, cachedSearchParams as c, ssrDataProvider as d, statusPageRendered as f, _setSsrDataProvider as i, globalRouter as l, _setGlobalRouter as n, _setUnloading as o, unloading as p, _setOnStatusPageRendered as r, cachedSearch as s, _setCachedSearch as t, onStatusPageRendered as u };
 
-//# sourceMappingURL=state-FippDgxN.js.map
+//# sourceMappingURL=state-BhNGPsdi.js.map

package/dist/_chunks/state-BhNGPsdi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-BhNGPsdi.js","names":[],"sources":["../../src/client/state.ts"],"sourcesContent":["/**\n * Centralized client singleton state registry.\n *\n * ALL mutable module-level state that must have singleton semantics across\n * the client bundle lives here. Individual modules (router-ref.ts, ssr-data.ts,\n * use-segment-params.ts, use-search-params.ts, unload-guard.ts) import from this file\n * and re-export thin wrapper functions.\n *\n * Why: In Vite dev, a module is instantiated separately if reached via different\n * import paths (e.g., relative `./foo.js` vs barrel `@timber-js/app/client`).\n * By centralizing all mutable state in a single module that is always reached\n * through the same dependency chain (barrel → wrapper → state.ts), we guarantee\n * a single instance of every piece of shared state.\n *\n * DO NOT import this file from outside client/. Server code must never depend\n * on client state. The barrel (client/index.ts) is the public entry point.\n *\n * See design/18-build-system.md §\"Module Singleton Strategy\" and\n * §\"Singleton State Registry\".\n */\n\nimport type { RouterInstance } from './router-types.ts';\nimport type { SsrData } from './ssr-data.ts';\n\n// ─── Router (from router-ref.ts) ──────────────────────────────────────────\n\n/** The global router singleton — set once during bootstrap. */\nexport let globalRouter: RouterInstance | null = null;\n\nexport function _setGlobalRouter(router: RouterInstance | null): void {\n  globalRouter = router;\n}\n\n// ─── SSR Data Provider (from ssr-data.ts) ──────────────────────────────────\n\n/**\n * ALS-backed SSR data provider, registered by the SSR entry. getSsrData()\n * reads through it; unset in the browser.\n */\nexport let ssrDataProvider: (() => SsrData | undefined) | undefined;\n\nexport function _setSsrDataProvider(provider: (() => SsrData | undefined) | undefined): void {\n  ssrDataProvider = provider;\n}\n\n// ─── Search Params Cache (from use-search-params.ts) ────────────────────────\n\n/** Cached search string — avoids reparsing when URL hasn't changed. */\nexport let cachedSearch = '';\nexport let cachedSearchParams = new URLSearchParams();\n\nexport function _setCachedSearch(search: string, params: URLSearchParams): void {\n  cachedSearch = search;\n  cachedSearchParams = params;\n}\n\n// ─── Unload Guard (from unload-guard.ts) ─────────────────────────────────────\n\n/** Whether the page is currently being unloaded. */\nexport let unloading = false;\n\nexport function _setUnloading(value: boolean): void {\n  unloading = value;\n}\n\n// ─── Status Page Commit Flag (from navigation-commit.ts) ────────────────────\n\n/**\n * Whether a status page for the main route has rendered since the last\n * navigation was prepared. Raised by `StatusPageMarker`, consumed by the\n * navigation's commit. See navigation-commit.ts §\"What a status page\n * teaches the cache\".\n */\nexport let statusPageRendered = false;\n\nexport function _setStatusPageRendered(value: boolean): void {\n  statusPageRendered = value;\n}\n\n/**\n * What a status page report does beyond raising the flag: registered by the\n * router's committer so the report can clear the segment cache at once, for\n * the commits no navigation consumes (a row arriving inside Suspense after\n * its navigation published, a status document being hydrated).\n */\nexport let onStatusPageRendered: (() => void) | undefined;\n\nexport function _setOnStatusPageRendered(handler: (() => void) | undefined): void {\n  onStatusPageRendered = handler;\n}\n"],"mappings":";;AA2BA,IAAW,eAAsC;AAEjD,SAAgB,iBAAiB,QAAqC;CACpE,eAAe;AACjB;;;;;AAQA,IAAW;AAEX,SAAgB,oBAAoB,UAAyD;CAC3F,kBAAkB;AACpB;;AAKA,IAAW,eAAe;AAC1B,IAAW,qBAAqB,IAAI,gBAAgB;AAEpD,SAAgB,iBAAiB,QAAgB,QAA+B;CAC9E,eAAe;CACf,qBAAqB;AACvB;;AAKA,IAAW,YAAY;AAEvB,SAAgB,cAAc,OAAsB;CAClD,YAAY;AACd;;;;;;;AAUA,IAAW,qBAAqB;AAEhC,SAAgB,uBAAuB,OAAsB;CAC3D,qBAAqB;AACvB;;;;;;;AAQA,IAAW;AAEX,SAAgB,yBAAyB,SAAyC;CAChF,uBAAuB;AACzB"}

package/dist/_chunks/{status-page-marker-CNbpUOPB.js → status-page-marker-gaihi0KZ.js}

@@ -1,6 +1,5 @@
-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 { n as createSingleflight } from "./singleflight-BeVMMKi0.js";
+import { a as _setStatusPageRendered, f as statusPageRendered, r as _setOnStatusPageRendered, u as onStatusPageRendered } from "./state-BhNGPsdi.js";
 import { useLayoutEffect } from "react";
 //#region src/shared/rsc-error-envelope.ts
 /**
@@ -388,6 +387,37 @@ var PrefetchCache = class PrefetchCache {
 	}
 };
 //#endregion
+//#region src/client/router-url.ts
+/**
+* How the client router reads the URLs it is handed.
+*
+* One parser, so the places that key or compare by URL — the history stack,
+* the navigation state a page renders with, the departing page sent as
+* `X-Timber-URL` — cannot disagree about what a URL says. They did: a
+* history entry stored under `navigate('/café')`'s spelling was looked up
+* under the address bar's `/caf%C3%A9`, and missed (TIM-1541).
+*/
+var BASE = "http://localhost";
+/**
+* Parse a router URL. A URL that starts with "/" is a path — including one
+* that starts with "//": that is the pathname a document at
+* `https://host//a/b` reports, and resolved against a base it would parse as
+* a scheme-relative reference to host `a`. Anything else resolves against a
+* placeholder origin, so an absolute URL keeps its own.
+*/
+function parseRouterUrl(url) {
+	return url.startsWith("/") ? new URL(BASE + url) : new URL(url, BASE);
+}
+/**
+* The spelling a URL is stored and looked up under: the browser's own
+* pathname + search, so `/a?` and `/a`, `/café` and `/caf%C3%A9`, are one
+* key. The fragment is dropped — it is client-only.
+*/
+function routerUrlKey(url) {
+	const parsed = parseRouterUrl(url);
+	return parsed.pathname + parsed.search;
+}
+//#endregion
 //#region src/client/navigation-commit.ts
 /**
 * What it means for a page to be "current" on the client.
@@ -425,10 +455,11 @@ 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
+* The metadata a committed page keeps — on its history entry, and as the
+* current page's `committedSegmentInfo()`. `skipped` describes the
+* *response* — "this slot's content was omitted" — and neither stores such
+* a payload (the entry stores null). Kept, the flag outlives the response:
+* `applyActionResult()` reuses the current page's metadata beside a full
 * re-render and would have that judged non-replayable too.
 */
 function storedSegmentInfo(segmentInfo) {
@@ -438,14 +469,12 @@ function storedSegmentInfo(segmentInfo) {
 /**
 * 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.
+* Pure. The value travels with the tree it describes — callers pass it to
+* `wrapPayload`, and the router's record of the displayed tree keeps it
+* beside that tree — so there is no store to publish it to (TIM-1541).
 */
 function deriveNavigationState(url) {
-	const parsed = new URL(url, "http://localhost");
+	const parsed = parseRouterUrl(url);
 	return {
 		pathname: parsed.pathname || "/",
 		search: parsed.search
@@ -453,6 +482,7 @@ function deriveNavigationState(url) {
 }
 function createNavigationCommitter(deps) {
 	const { segmentCache, historyStack } = deps;
+	let committedSegmentInfo = null;
 	_setOnStatusPageRendered(() => segmentCache.clear());
 	/**
 	* Update the segment cache from server-provided segment metadata.
@@ -463,12 +493,11 @@ function createNavigationCommitter(deps) {
 	* `currentStateTree`.
 	*/
 	function updateSegmentCache(segmentInfo) {
-		if (!segmentInfo || segmentInfo.length === 0) return;
 		const tree = buildSegmentTree(segmentInfo);
 		if (tree) segmentCache.set("/", tree);
 	}
 	return {
-		updateSegmentCache,
+		committedSegmentInfo: () => committedSegmentInfo,
 		isSegmentReuseSuppressed: () => segmentCache.isReuseSuppressed(),
 		restoreSegmentReuse: () => segmentCache.restoreReuse(),
 		/**
@@ -503,9 +532,13 @@ function createNavigationCommitter(deps) {
 		* 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
+		* 2. The current page's segment metadata (`committedSegmentInfo`)
 		* 3. History stack — store the payload for instant back/forward replay
 		*
+		* Pathname and search are not written here: they are the returned
+		* `navState`, which the tree renders with and the router's record of the
+		* displayed tree keeps (browser-entry/router-init.ts `publishTree`).
+		*
 		* 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
@@ -530,11 +563,11 @@ function createNavigationCommitter(deps) {
 					const segmentInfo = cacheable ? opts.segmentInfo : [];
 					if (segmentInfo && segmentInfo.length > 0) updateSegmentCache(segmentInfo);
 					else if (segmentInfo?.length === 0 || opts.clearSegmentCacheOnEmpty) segmentCache.clear();
-					setNavigationState(navState);
+					committedSegmentInfo = storedSegmentInfo(segmentInfo) ?? null;
 					historyStack.push(url, {
 						payload,
 						params: opts.params,
-						segmentInfo: storedSegmentInfo(segmentInfo)
+						segmentInfo: committedSegmentInfo
 					});
 				}
 			};
@@ -570,6 +603,6 @@ function StatusPageMarker({ children }) {
 	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 };
+export { routerUrlKey as a, prefetchScopeOf as c, parseRouterUrl as i, TIMBER_ERROR_HEADER as l, createNavigationCommitter as n, PrefetchCache as o, isPartialNavigation as r, SegmentCache as s, StatusPageMarker as t };
 
-//# sourceMappingURL=status-page-marker-CNbpUOPB.js.map
+//# sourceMappingURL=status-page-marker-gaihi0KZ.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"status-page-marker-gaihi0KZ.js","names":[],"sources":["../../src/shared/rsc-error-envelope.ts","../../src/client/segment-cache.ts","../../src/client/router-url.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   * Monotonic counter. Bumped by `invalidateReuse()` (TIM-1466).\n   * `serializeStateTree` suppresses `segments` and `slots` when\n   * `reuseInvalidatedAt > reuseRestoredAt`. Only `restoreReuse()`\n   * advances `reuseRestoredAt` — `set()` does not, because a\n   * pre-invalidation navigation's commit thunk would lift suppression\n   * before a post-invalidation request has been sent (codex on #1167).\n   */\n  private reuseInvalidatedAt = 0;\n  private reuseRestoredAt = 0;\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    this.reuseRestoredAt = this.reuseInvalidatedAt;\n  }\n\n  /**\n   * Suppress segment and slot reuse without destroying the tree\n   * structure (TIM-1466). `serializeStateTree` sends empty\n   * `segments`/`slots` (forcing a full render) while `treePaths`\n   * still reflects the mounted tree for interception scoping.\n   * Call `restoreReuse()` once post-invalidation data has been\n   * fetched and committed.\n   */\n  invalidateReuse(): void {\n    this.reuseInvalidatedAt++;\n  }\n\n  /**\n   * Lift reuse suppression. Called after the segment cache has been\n   * rebuilt from a response that was fetched with suppression active\n   * (i.e. the server sent a full render). Safe to call idempotently.\n   */\n  restoreReuse(): void {\n    this.reuseRestoredAt = this.reuseInvalidatedAt;\n  }\n\n  /** Whether segment/slot reuse is currently suppressed (TIM-1466). */\n  isReuseSuppressed(): boolean {\n    return this.reuseInvalidatedAt > this.reuseRestoredAt;\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    const suppressed = this.reuseInvalidatedAt > this.reuseRestoredAt;\n    if (this.root) {\n      if (!suppressed) {\n        collectSyncSegments(this.root, segments, mergeableFilter);\n        collectSyncSlots(this.root, slots);\n      }\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 * Extract the destination URL from a length-prefixed map key.\n * Key format: `${from.length}:${from}:${scope.length}:${scope}:${url}`\n */\nfunction extractUrlFromMapKey(mapKey: string): string | null {\n  // Parse from-length prefix\n  const firstColon = mapKey.indexOf(':');\n  if (firstColon === -1) return null;\n  const fromLen = parseInt(mapKey.slice(0, firstColon), 10);\n  if (Number.isNaN(fromLen)) return null;\n  // Skip past `from.length:from:`\n  const scopeStart = firstColon + 1 + fromLen + 1;\n  // Parse scope-length prefix\n  const secondColon = mapKey.indexOf(':', scopeStart);\n  if (secondColon === -1) return null;\n  const scopeLen = parseInt(mapKey.slice(scopeStart, secondColon), 10);\n  if (Number.isNaN(scopeLen)) return null;\n  // Skip past `scope.length:scope:` — remainder is the URL\n  return mapKey.slice(secondColon + 1 + scopeLen + 1);\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.\n *  `startGen` is the eviction generation at flight start — joiners that\n *  started after a gen bump must reject pre-invalidation results (TIM-1464). */\nexport type FlightOutcome =\n  | { kind: 'ready'; result: PrefetchResult; startGen: number }\n  | { kind: 'non-route'; startGen: number };\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    // The starting gen is also included in the outcome so joiners\n    // that started after a gen bump can detect pre-invalidation\n    // results (TIM-1464).\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, startGen: genAtStart };\n      } catch (err) {\n        if (isNonRoute(err)) {\n          if (!signal.aborted && this.evictionGen === genAtStart) this.setNegative(key);\n          return { kind: 'non-route' as const, startGen: genAtStart };\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 entries whose destination URL matches (TIM-1454).\n   *\n   * When `url` has no search string, evicts all entries sharing that\n   * pathname — `/products` evicts `/products?page=1` too, because\n   * `revalidatePath('/products')` invalidates the route regardless of\n   * query (TIM-1465).\n   *\n   * When `url` has a search string, only the exact URL is evicted.\n   *\n   * Also bumps the eviction generation so in-flight singleflight\n   * flights for the invalidated URL(s) discard their results on\n   * completion (TIM-1464).\n   */\n  invalidateUrl(url: string): void {\n    const hasSearch = url.includes('?');\n    const pathname = hasSearch ? null : url;\n\n    for (const [mapKey] of this.entries) {\n      // The map key is `${from.length}:${from}:${scope.length}:${scope}:${url}`.\n      // The destination URL is the suffix after the last unescaped colon pair.\n      if (hasSearch) {\n        if (mapKey.endsWith(':' + url)) {\n          this.entries.delete(mapKey);\n        }\n      } else {\n        // Extract the URL suffix — everything after the scope block.\n        // Match any entry whose URL pathname matches.\n        const entryUrl = extractUrlFromMapKey(mapKey);\n        if (entryUrl !== null) {\n          const qIndex = entryUrl.indexOf('?');\n          const entryPathname = qIndex === -1 ? entryUrl : entryUrl.slice(0, qIndex);\n          if (entryPathname === pathname) {\n            this.entries.delete(mapKey);\n          }\n        }\n      }\n    }\n\n    // Fence in-flight flights so a prefetch that started before\n    // invalidation cannot store its stale result (TIM-1464).\n    this.evictionGen++;\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 * How the client router reads the URLs it is handed.\n *\n * One parser, so the places that key or compare by URL — the history stack,\n * the navigation state a page renders with, the departing page sent as\n * `X-Timber-URL` — cannot disagree about what a URL says. They did: a\n * history entry stored under `navigate('/café')`'s spelling was looked up\n * under the address bar's `/caf%C3%A9`, and missed (TIM-1541).\n */\n\nconst BASE = 'http://localhost';\n\n/**\n * Parse a router URL. A URL that starts with \"/\" is a path — including one\n * that starts with \"//\": that is the pathname a document at\n * `https://host//a/b` reports, and resolved against a base it would parse as\n * a scheme-relative reference to host `a`. Anything else resolves against a\n * placeholder origin, so an absolute URL keeps its own.\n */\nexport function parseRouterUrl(url: string): URL {\n  return url.startsWith('/') ? new URL(BASE + url) : new URL(url, BASE);\n}\n\n/**\n * The spelling a URL is stored and looked up under: the browser's own\n * pathname + search, so `/a?` and `/a`, `/café` and `/caf%C3%A9`, are one\n * key. The fragment is dropped — it is client-only.\n */\nexport function routerUrlKey(url: string): string {\n  const parsed = parseRouterUrl(url);\n  return parsed.pathname + parsed.search;\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 type { NavigationState } from './navigation-context.ts';\nimport { parseRouterUrl } from './router-url.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 committed page keeps — on its history entry, and as the\n * current page's `committedSegmentInfo()`. `skipped` describes the\n * *response* — \"this slot's content was omitted\" — and neither stores such\n * a payload (the entry stores null). Kept, the flag outlives the response:\n * `applyActionResult()` reuses the current page'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  /**\n   * The segment metadata of the page the last commit made current, as that\n   * commit recorded it — null when it carried none.\n   *\n   * Server-action responses carry no segment metadata, so a revalidation\n   * re-renders the current page with this. It is the committer's own record\n   * rather than a history-stack lookup: the stack is keyed by the URL string\n   * a navigation was asked for, and the current page is known by\n   * `window.location`'s spelling of it, and the two need not agree\n   * (`/a?` against `/a`, a percent-encoded path against a decoded one).\n   */\n  committedSegmentInfo(): SegmentInfo[] | null;\n  /** Whether segment reuse is currently suppressed (TIM-1466). */\n  isSegmentReuseSuppressed(): boolean;\n  /** Lift segment reuse suppression after fresh data has been fetched (TIM-1466). */\n  restoreSegmentReuse(): void;\n}\n\n/**\n * Derive the navigation state (pathname + search) a URL renders with.\n *\n * Pure. The value travels with the tree it describes — callers pass it to\n * `wrapPayload`, and the router's record of the displayed tree keeps it\n * beside that tree — so there is no store to publish it to (TIM-1541).\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 = parseRouterUrl(url);\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 `committedSegmentInfo`. Written only by a commit.\n  let committedSegmentInfo: SegmentInfo[] | null = null;\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[]): void {\n    const tree = buildSegmentTree(segmentInfo);\n    if (tree) {\n      segmentCache.set('/', tree);\n    }\n  }\n\n  return {\n    committedSegmentInfo: () => committedSegmentInfo,\n    isSegmentReuseSuppressed: () => segmentCache.isReuseSuppressed(),\n    restoreSegmentReuse: () => segmentCache.restoreReuse(),\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. The current page's segment metadata (`committedSegmentInfo`)\n     * 3. History stack — store the payload for instant back/forward replay\n     *\n     * Pathname and search are not written here: they are the returned\n     * `navState`, which the tree renders with and the router's record of the\n     * displayed tree keeps (browser-entry/router-init.ts `publishTree`).\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          committedSegmentInfo = storedSegmentInfo(segmentInfo) ?? null;\n\n          historyStack.push(url, {\n            payload,\n            params: opts.params,\n            segmentInfo: committedSegmentInfo,\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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"}

package/dist/_chunks/{walkers-CN2N_bA-.js → walkers-BXExhzzk.js}

@@ -1,6 +1,6 @@
 import { n as classifyUrlSegment } from "./segment-classify-C539Pa2O.js";
 import { t as readFileCached } from "./file-cache-Dw6BJPG7.js";
-import { n as findSchemaFile, r as parseExistingSchemaKeys } from "./cli-schema-sync--LZKs8Zn.js";
+import { n as findSchemaFile, r as parseExistingSchemaKeys } from "./cli-schema-sync-CbT2AUUI.js";
 //#region src/routing/schema-validation.ts
 /**
 * Schema key/value validation against the filesystem route tree.
@@ -141,4 +141,4 @@ function walk(node, chain, result, includeSlots) {
 //#endregion
 export { collectDynamicSegmentsFromTree as n, validateSchemaAgainstRoutes as r, collectLeafRoutes as t };
 
-//# sourceMappingURL=walkers-CN2N_bA-.js.map
+//# sourceMappingURL=walkers-BXExhzzk.js.map