@timber-js/app 0.2.0-alpha.207 → 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-DwQBrLBz.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
 /**
@@ -27,6 +26,16 @@ var TIMBER_ERROR_HEADER = "X-Timber-Error";
 */
 var SegmentCache = class {
 	root;
+	/**
+	* Monotonic counter. Bumped by `invalidateReuse()` (TIM-1466).
+	* `serializeStateTree` suppresses `segments` and `slots` when
+	* `reuseInvalidatedAt > reuseRestoredAt`. Only `restoreReuse()`
+	* advances `reuseRestoredAt` — `set()` does not, because a
+	* pre-invalidation navigation's commit thunk would lift suppression
+	* before a post-invalidation request has been sent (codex on #1167).
+	*/
+	reuseInvalidatedAt = 0;
+	reuseRestoredAt = 0;
 	get(segment) {
 		if (segment === "/" || segment === this.root?.segment) return this.root;
 	}
@@ -35,6 +44,30 @@ var SegmentCache = class {
 	}
 	clear() {
 		this.root = void 0;
+		this.reuseRestoredAt = this.reuseInvalidatedAt;
+	}
+	/**
+	* Suppress segment and slot reuse without destroying the tree
+	* structure (TIM-1466). `serializeStateTree` sends empty
+	* `segments`/`slots` (forcing a full render) while `treePaths`
+	* still reflects the mounted tree for interception scoping.
+	* Call `restoreReuse()` once post-invalidation data has been
+	* fetched and committed.
+	*/
+	invalidateReuse() {
+		this.reuseInvalidatedAt++;
+	}
+	/**
+	* Lift reuse suppression. Called after the segment cache has been
+	* rebuilt from a response that was fetched with suppression active
+	* (i.e. the server sent a full render). Safe to call idempotently.
+	*/
+	restoreReuse() {
+		this.reuseRestoredAt = this.reuseInvalidatedAt;
+	}
+	/** Whether segment/slot reuse is currently suppressed (TIM-1466). */
+	isReuseSuppressed() {
+		return this.reuseInvalidatedAt > this.reuseRestoredAt;
 	}
 	/**
 	* Serialize the mounted segment tree for the X-Timber-State-Tree header.
@@ -60,9 +93,12 @@ var SegmentCache = class {
 		const segments = [];
 		const slots = [];
 		const treePaths = [];
+		const suppressed = this.reuseInvalidatedAt > this.reuseRestoredAt;
 		if (this.root) {
-			collectSyncSegments(this.root, segments, mergeableFilter);
-			collectSyncSlots(this.root, slots);
+			if (!suppressed) {
+				collectSyncSegments(this.root, segments, mergeableFilter);
+				collectSyncSlots(this.root, slots);
+			}
 			collectTreePaths(this.root, treePaths);
 		}
 		const tree = { segments };
@@ -171,6 +207,22 @@ function prefetchMapKey(key) {
 	return `${key.from.length}:${key.from}:${key.scope.length}:${key.scope}:${key.url}`;
 }
 /**
+* Extract the destination URL from a length-prefixed map key.
+* Key format: `${from.length}:${from}:${scope.length}:${scope}:${url}`
+*/
+function extractUrlFromMapKey(mapKey) {
+	const firstColon = mapKey.indexOf(":");
+	if (firstColon === -1) return null;
+	const fromLen = parseInt(mapKey.slice(0, firstColon), 10);
+	if (Number.isNaN(fromLen)) return null;
+	const scopeStart = firstColon + 1 + fromLen + 1;
+	const secondColon = mapKey.indexOf(":", scopeStart);
+	if (secondColon === -1) return null;
+	const scopeLen = parseInt(mapKey.slice(scopeStart, secondColon), 10);
+	if (Number.isNaN(scopeLen)) return null;
+	return mapKey.slice(secondColon + 1 + scopeLen + 1);
+}
+/**
 * 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.
@@ -244,12 +296,16 @@ var PrefetchCache = class PrefetchCache {
 				if (!signal.aborted && this.evictionGen === genAtStart) this.set(key, result);
 				return {
 					kind: "ready",
-					result
+					result,
+					startGen: genAtStart
 				};
 			} catch (err) {
 				if (isNonRoute(err)) {
 					if (!signal.aborted && this.evictionGen === genAtStart) this.setNegative(key);
-					return { kind: "non-route" };
+					return {
+						kind: "non-route",
+						startGen: genAtStart
+					};
 				}
 				throw err;
 			}
@@ -281,12 +337,32 @@ var PrefetchCache = class PrefetchCache {
 		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.
+	* Invalidate entries whose destination URL matches (TIM-1454).
+	*
+	* When `url` has no search string, evicts all entries sharing that
+	* pathname — `/products` evicts `/products?page=1` too, because
+	* `revalidatePath('/products')` invalidates the route regardless of
+	* query (TIM-1465).
+	*
+	* When `url` has a search string, only the exact URL is evicted.
+	*
+	* Also bumps the eviction generation so in-flight singleflight
+	* flights for the invalidated URL(s) discard their results on
+	* completion (TIM-1464).
 	*/
 	invalidateUrl(url) {
-		for (const [mapKey] of this.entries) if (mapKey.endsWith(":" + url)) this.entries.delete(mapKey);
+		const hasSearch = url.includes("?");
+		const pathname = hasSearch ? null : url;
+		for (const [mapKey] of this.entries) if (hasSearch) {
+			if (mapKey.endsWith(":" + url)) this.entries.delete(mapKey);
+		} else {
+			const entryUrl = extractUrlFromMapKey(mapKey);
+			if (entryUrl !== null) {
+				const qIndex = entryUrl.indexOf("?");
+				if ((qIndex === -1 ? entryUrl : entryUrl.slice(0, qIndex)) === pathname) this.entries.delete(mapKey);
+			}
+		}
+		this.evictionGen++;
 	}
 	/**
 	* Evict all ready entries and fence in-flight singleflights (TIM-1476).
@@ -311,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.
@@ -348,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) {
@@ -361,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
@@ -376,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.
@@ -386,12 +493,13 @@ 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(),
 		/**
 		* The X-Timber-State-Tree to send with the next RSC request.
 		*
@@ -424,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
@@ -451,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
 					});
 				}
 			};
@@ -491,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-DwQBrLBz.js.map
+//# sourceMappingURL=status-page-marker-gaihi0KZ.js.map