@timber-js/app 0.2.0-alpha.71 → 0.2.0-alpha.72

package/dist/client/index.js

@@ -1,11 +1,13 @@
 "use client";
 import { n as __exportAll } from "../_chunks/chunk-DYhsFzuS.js";
 import { t as classifyUrlSegment } from "../_chunks/segment-classify-BDNn6EzD.js";
-import { n as useQueryStates, t as bindUseQueryStates } from "../_chunks/use-query-states-DAhgj8Gx.js";
-import { n as useSegmentContext, r as mergePreservedSearchParams, t as SegmentProvider } from "../_chunks/segment-context-hzuJ048X.js";
-import { a as _setCachedSearch, c as cachedSearch, d as globalRouter, i as setSsrData, l as cachedSearchParams, n as clearSsrData, o as _setCurrentParams, r as getSsrData, s as _setGlobalRouter, t as TimberErrorBoundary, u as currentParams } from "../_chunks/error-boundary-D9hzsveV.js";
-import { t as _registerUseCookieModule } from "../_chunks/define-cookie-B5mewxwM.js";
-import React, { cloneElement, createContext, createElement, isValidElement, useActionState as useActionState$1, useContext, useEffect, useRef, useState, useSyncExternalStore, useTransition } from "react";
+import { n as useQueryStates } from "../_chunks/use-query-states-Lo_s_pw2.js";
+import { t as mergePreservedSearchParams } from "../_chunks/merge-search-params-Cm_KIWDX.js";
+import { c as cachedSearchParams, i as _setCachedSearch, n as getSsrData, s as cachedSearch } from "../_chunks/ssr-data-DzuI0bIV.js";
+import { n as useSegmentContext } from "../_chunks/segment-context-fHFLF1PE.js";
+import { c as usePendingNavigationUrl, d as setLinkForCurrentNavigation, f as unmountLinkForCurrentNavigation, l as IDLE_LINK_STATUS, m as getRouterOrNull, n as useSegmentParams, s as useNavigationContext, u as PENDING_LINK_STATUS } from "../_chunks/use-params-B1AuhI1p.js";
+import { t as _registerUseCookieModule } from "../_chunks/define-cookie-C2IkoFGN.js";
+import { createContext, useActionState as useActionState$1, useContext, useEffect, useRef, useState, useSyncExternalStore, useTransition } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/client/use-link-status.ts
 /**
@@ -17,7 +19,7 @@ var LinkStatusContext = createContext({ pending: false });
 * Returns `{ pending: true }` while the nearest parent `<Link>` component's
 * navigation is in flight. Must be used inside a `<Link>` component's children.
 *
-* Unlike `useNavigationPending()` which is global, this hook is scoped to
+* Unlike `usePendingNavigation()` which is global, this hook is scoped to
 * the nearest parent `<Link>` — only the link the user clicked shows pending.
 *
 * ```tsx
@@ -41,72 +43,6 @@ var LinkStatusContext = createContext({ pending: false });
 function useLinkStatus() {
 	return useContext(LinkStatusContext);
 }
-//#endregion
-//#region src/client/router-ref.ts
-/**
-* Set the global router instance. Called once during bootstrap.
-*/
-function setGlobalRouter(router) {
-	_setGlobalRouter(router);
-}
-/**
-* Get the global router instance. Throws if called before bootstrap.
-* Used by client-side hooks (useNavigationPending, etc.)
-*/
-function getRouter() {
-	if (!globalRouter) throw new Error("[timber] Router not initialized. getRouter() was called before bootstrap().");
-	return globalRouter;
-}
-/**
-* Get the global router instance or null if not yet initialized.
-* Used by useRouter() methods to avoid silent failures — callers
-* can log a meaningful warning instead of silently no-oping.
-*/
-function getRouterOrNull() {
-	return globalRouter;
-}
-//#endregion
-//#region src/client/link-pending-store.ts
-var LINK_PENDING_KEY = Symbol.for("__timber_link_pending");
-/** Status object indicating link is pending — shared reference */
-var PENDING_LINK_STATUS = { pending: true };
-/** Status object indicating link is idle — shared reference */
-var IDLE_LINK_STATUS = { pending: false };
-function getStore() {
-	const g = globalThis;
-	if (!g[LINK_PENDING_KEY]) g[LINK_PENDING_KEY] = {
-		current: null,
-		navId: 0
-	};
-	return g[LINK_PENDING_KEY];
-}
-/**
-* Register the link instance that initiated the current navigation.
-*
-* Called from <Link>'s click handler before router.navigate().
-* - Resets the previous pending link to IDLE (urgent update, immediate)
-* - Does NOT set the new link to PENDING here — the Link's click handler
-*   calls setLinkStatus(PENDING) directly for the eager show
-* - Increments the navId counter for stale-clear protection
-*
-* Pass `null` to clear (e.g., for programmatic navigations).
-*/
-function setLinkForCurrentNavigation(link) {
-	const store = getStore();
-	const prev = store.current;
-	if (prev && prev !== link) prev.setLinkStatus(IDLE_LINK_STATUS);
-	store.current = link;
-	store.navId++;
-}
-/**
-* Unmount a link instance from navigation tracking. Called when a Link
-* component unmounts while it is the current navigation link. Prevents
-* calling setState on an unmounted component.
-*/
-function unmountLinkForCurrentNavigation(link) {
-	const store = getStore();
-	if (store.current === link) store.current = null;
-}
 /**
 * Store metadata from Link's onClick for the next navigate event.
 * Called synchronously in the click handler — the navigate event
@@ -114,211 +50,6 @@ function unmountLinkForCurrentNavigation(link) {
 */
 function setNavLinkMetadata(metadata) {}
 //#endregion
-//#region src/client/navigation-context.ts
-/**
-* NavigationContext — React context for navigation state.
-*
-* Holds the current route params and pathname, updated atomically
-* with the RSC tree on each navigation. This replaces the previous
-* useSyncExternalStore approach for useSegmentParams() and usePathname(),
-* which suffered from a timing gap: the new tree could commit before
-* the external store re-renders fired, causing a frame where both
-* old and new active states were visible simultaneously.
-*
-* By wrapping the RSC payload element in NavigationProvider inside
-* renderRoot(), the context value and the element tree are passed to
-* reactRoot.render() in the same call — atomic by construction.
-* All consumers (useParams, usePathname) see the new values in the
-* same render pass as the new tree.
-*
-* During SSR, no NavigationProvider is mounted. Hooks fall back to
-* the ALS-backed getSsrData() for per-request isolation.
-*
-* IMPORTANT: createContext and useContext are NOT available in the RSC
-* environment (React Server Components use a stripped-down React).
-* The context is lazily initialized on first access, and all functions
-* that depend on these APIs are safe to call from any environment —
-* they return null or no-op when the APIs aren't available.
-*
-* SINGLETON GUARANTEE: All shared mutable state uses globalThis via
-* Symbol.for keys. The RSC client bundler can duplicate this module
-* across chunks (browser-entry graph + client-reference graph). With
-* ESM output, each chunk gets its own module scope — module-level
-* variables would create separate singleton instances per chunk.
-* globalThis guarantees a single instance regardless of duplication.
-*
-* This workaround will be removed when Rolldown ships `format: 'app'`
-* (module registry format that deduplicates like webpack/Turbopack).
-* See design/27-chunking-strategy.md.
-*
-* See design/19-client-navigation.md §"NavigationContext"
-*/
-/**
-* The context is created lazily to avoid calling createContext at module
-* level. In the RSC environment, React.createContext doesn't exist —
-* calling it at import time would crash the server.
-*
-* Context instances are stored on globalThis (NOT in module-level
-* variables) because the ESM bundler can duplicate this module across
-* chunks. Module-level variables would create separate instances per
-* chunk — the provider in NavigationRoot (index chunk) would use
-* context A while the consumer in useNavigationPending (shared chunk)
-* reads from context B. globalThis guarantees a single instance.
-*
-* See design/27-chunking-strategy.md §"Singleton Safety"
-*/
-var NAV_CTX_KEY = Symbol.for("__timber_nav_ctx");
-var PENDING_CTX_KEY = Symbol.for("__timber_pending_nav_ctx");
-function getOrCreateContext() {
-	const existing = globalThis[NAV_CTX_KEY];
-	if (existing !== void 0) return existing;
-	if (typeof React.createContext === "function") {
-		const ctx = React.createContext(null);
-		globalThis[NAV_CTX_KEY] = ctx;
-		return ctx;
-	}
-}
-/**
-* Read the navigation context. Returns null during SSR (no provider)
-* or in the RSC environment (no context available).
-* Internal — used by useSegmentParams() and usePathname().
-*/
-function useNavigationContext() {
-	const ctx = getOrCreateContext();
-	if (!ctx) return null;
-	if (typeof React.useContext !== "function") return null;
-	return React.useContext(ctx);
-}
-/**
-* Wraps children with NavigationContext.Provider.
-*
-* Used in browser-entry.ts renderRoot to wrap the RSC payload element
-* so that navigation state updates atomically with the tree render.
-*/
-function NavigationProvider({ value, children }) {
-	const ctx = getOrCreateContext();
-	if (!ctx) return children;
-	return createElement(ctx.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: {
-		params: {},
-		pathname: "/"
-	} };
-	return g[NAV_STATE_KEY];
-}
-function setNavigationState(state) {
-	_getNavStateStore().current = state;
-}
-function getNavigationState() {
-	return _getNavStateStore().current;
-}
-/**
-* Separate context for the in-flight navigation URL. Provided by
-* NavigationRoot (urgent useState), consumed by useNavigationPending
-* and TopLoader. Per-link pending state uses useOptimistic instead
-* (see link-pending-store.ts).
-*
-* Uses globalThis via Symbol.for for the same reason as NavigationContext
-* above — the bundler may duplicate this module across chunks, and module-
-* level variables would create separate context instances.
-*/
-function getOrCreatePendingContext() {
-	const existing = globalThis[PENDING_CTX_KEY];
-	if (existing !== void 0) return existing;
-	if (typeof React.createContext === "function") {
-		const ctx = React.createContext(null);
-		globalThis[PENDING_CTX_KEY] = ctx;
-		return ctx;
-	}
-}
-/**
-* Read the pending navigation URL from context.
-* Returns null during SSR (no provider) or in the RSC environment.
-*/
-function usePendingNavigationUrl() {
-	const ctx = getOrCreatePendingContext();
-	if (!ctx) return null;
-	if (typeof React.useContext !== "function") return null;
-	return React.useContext(ctx);
-}
-//#endregion
-//#region src/client/top-loader.tsx
-/**
-* TopLoader — Built-in progress bar for client navigations.
-*
-* Shows an animated progress bar at the top of the viewport while an RSC
-* navigation is in flight. Injected automatically by the framework into
-* NavigationRoot — users never render this component directly.
-*
-* Configuration is via timber.config.ts `topLoader` key. Enabled by default.
-* Users who want a fully custom progress indicator disable the built-in one
-* (`topLoader: { enabled: false }`) and use `useNavigationPending()` directly.
-*
-* Animation approach: pure CSS @keyframes. The bar crawls from 0% to ~90%
-* width over ~30s using ease-out timing. When navigation completes, the bar
-* snaps to 100% and fades out over 200ms. No JS animation loops (RAF, setInterval).
-*
-* Phase transitions are derived synchronously during render (React's
-* getDerivedStateFromProps pattern) — no useEffect needed for state tracking.
-* The finishing → hidden cleanup uses onTransitionEnd from the CSS transition.
-*
-* When delay > 0, CSS animation-delay + a visibility keyframe ensure the bar
-* stays invisible during the delay period. If navigation finishes before the
-* delay, the bar was never visible so the finish transition is also invisible.
-*
-* See design/19-client-navigation.md §"useNavigationPending()"
-* See LOCAL-336 for design decisions.
-*/
-//#endregion
-//#region src/client/navigation-root.tsx
-/**
-* Module-level flag indicating a hard (MPA) navigation is in progress.
-*
-* When true:
-* - NavigationRoot throws an unresolved thenable to suspend forever,
-*   preventing React from rendering children during page teardown
-*   (avoids "Rendered more hooks" crashes).
-* - The Navigation API handler skips interception, letting the browser
-*   perform a full page load (prevents infinite loops where
-*   window.location.href → navigate event → router.navigate → 500 →
-*   window.location.href → ...).
-*
-* Uses globalThis for singleton guarantee across chunks (same pattern
-* as NavigationContext). See design/19-client-navigation.md §"Singleton
-* Guarantee via globalThis".
-*/
-var HARD_NAV_KEY = Symbol.for("__timber_hard_navigating");
-function getHardNavStore() {
-	const g = globalThis;
-	if (!g[HARD_NAV_KEY]) g[HARD_NAV_KEY] = { value: false };
-	return g[HARD_NAV_KEY];
-}
-/**
-* Set the hard-navigating flag. Call this BEFORE setting
-* window.location.href or window.location.reload() to prevent:
-* 1. React from rendering children during page teardown
-* 2. Navigation API from intercepting the hard navigation
-*/
-function setHardNavigating(value) {
-	getHardNavStore().value = value;
-}
-//#endregion
 //#region src/client/navigation-api.ts
 /**
 * Returns true if the Navigation API is available in the current environment.
@@ -545,915 +276,7 @@ var Link = function LinkImpl(props) {
 	});
 };
 //#endregion
-//#region src/client/segment-cache.ts
-/**
-* Maintains the client-side segment tree representing currently mounted
-* layouts and pages. Used for navigation reconciliation — the router diffs
-* new routes against this tree to determine which segments to re-fetch.
-*/
-var SegmentCache = class {
-	root;
-	get(segment) {
-		if (segment === "/" || segment === this.root?.segment) return this.root;
-	}
-	set(segment, node) {
-		if (segment === "/" || !this.root) this.root = node;
-	}
-	clear() {
-		this.root = void 0;
-	}
-	/**
-	* Serialize the mounted segment tree for the X-Timber-State-Tree header.
-	* Only includes sync segments — async segments are excluded because the
-	* server must always re-render them (they may depend on request context).
-	*
-	* When mergeableFilter is provided, only segments whose paths are in the
-	* set are included. This ensures the server only skips segments that the
-	* client can actually merge (i.e., segments whose cached element tree
-	* contains an inner SegmentProvider the merger can splice into).
-	*
-	* This is a performance optimization only, NOT a security boundary.
-	* The server always runs all access.ts files regardless of the state tree.
-	*/
-	serializeStateTree(mergeableFilter) {
-		const segments = [];
-		if (this.root) collectSyncSegments(this.root, segments, mergeableFilter);
-		return { segments };
-	}
-};
-/** Recursively collect sync segment paths from the tree */
-function collectSyncSegments(node, out, mergeableFilter) {
-	if (!node.isAsync && (!mergeableFilter || mergeableFilter.has(node.segment))) out.push(node.segment);
-	for (const child of node.children.values()) collectSyncSegments(child, out, mergeableFilter);
-}
-/**
-* Build a SegmentNode tree from flat segment metadata.
-*
-* Takes an ordered list of segment descriptors (root → leaf) from the
-* server's X-Timber-Segments header and constructs the hierarchical
-* tree structure that SegmentCache expects.
-*
-* Each segment is nested as a child of the previous one, forming a
-* linear chain from root to leaf. The leaf segment (page) is excluded
-* from the tree — pages are never cached across navigations.
-*/
-function buildSegmentTree(segments) {
-	if (segments.length === 0) return void 0;
-	const layouts = segments.length > 1 ? segments.slice(0, -1) : segments;
-	let root;
-	let parent;
-	for (const info of layouts) {
-		const node = {
-			segment: info.path,
-			payload: null,
-			isAsync: info.isAsync,
-			children: /* @__PURE__ */ new Map()
-		};
-		if (!root) root = node;
-		if (parent) parent.children.set(info.path, node);
-		parent = node;
-	}
-	return root;
-}
-/**
-* Short-lived cache for hover-triggered prefetches. Entries expire after
-* 30 seconds. When a link is clicked, the prefetched payload is consumed
-* (moved to the history stack) and removed from this cache.
-*
-* timber.js does NOT prefetch on viewport intersection — only explicit
-* hover on <Link prefetch> triggers a prefetch.
-*/
-var PrefetchCache = class PrefetchCache {
-	static TTL_MS = 3e4;
-	entries = /* @__PURE__ */ new Map();
-	set(url, result) {
-		this.entries.set(url, {
-			result,
-			expiresAt: Date.now() + PrefetchCache.TTL_MS
-		});
-	}
-	get(url) {
-		const entry = this.entries.get(url);
-		if (!entry) return void 0;
-		if (Date.now() >= entry.expiresAt) {
-			this.entries.delete(url);
-			return;
-		}
-		return entry.result;
-	}
-	/** Get and remove the entry (used when navigation consumes a prefetch) */
-	consume(url) {
-		const result = this.get(url);
-		if (result !== void 0) this.entries.delete(url);
-		return result;
-	}
-};
-//#endregion
-//#region src/client/history.ts
-/**
-* Session-lived history stack keyed by URL. Enables instant back/forward
-* navigation without a server roundtrip.
-*
-* On forward navigation, the new page's payload is pushed onto the stack.
-* On popstate, the cached payload is replayed instantly.
-*
-* Supports two keying modes:
-* - **URL-keyed** (default): entries keyed by pathname + search.
-*   Used with the History API fallback.
-* - **Entry-key + URL**: when the Navigation API is available,
-*   entries can also be stored by Navigation entry key for
-*   disambiguation of duplicate URLs in the history stack.
-*   Falls back to URL lookup when entry key is not found.
-*
-* Scroll positions are stored in history.state or Navigation API entry
-* state, not in this stack — see design/19-client-navigation.md §Scroll Restoration.
-*
-* Entries persist for the session duration (no expiry) and are cleared
-* when the tab is closed — matching browser back-button behavior.
-*/
-var HistoryStack = class {
-	entries = /* @__PURE__ */ new Map();
-	/** Entries keyed by Navigation API entry key for duplicate URL disambiguation. */
-	entryKeyMap = /* @__PURE__ */ new Map();
-	push(url, entry, entryKey) {
-		this.entries.set(url, entry);
-		if (entryKey) this.entryKeyMap.set(entryKey, entry);
-	}
-	/**
-	* Get an entry. When an entry key is provided (Navigation API),
-	* tries the entry-key map first for accurate disambiguation of
-	* duplicate URLs, then falls back to URL lookup.
-	*/
-	get(url, entryKey) {
-		if (entryKey) {
-			const byKey = this.entryKeyMap.get(entryKey);
-			if (byKey) return byKey;
-		}
-		return this.entries.get(url);
-	}
-	has(url) {
-		return this.entries.has(url);
-	}
-};
-//#endregion
-//#region src/client/use-params.ts
-/**
-* Set the current route params in the module-level store.
-*
-* Called by the router on each navigation. This updates the fallback
-* snapshot used by tests and by the hook when called outside a React
-* component (no NavigationContext available).
-*
-* On the client, the primary reactivity path is NavigationContext —
-* the router calls setNavigationState() then renderRoot() which wraps
-* the element in NavigationProvider. setCurrentParams is still called
-* for the module-level fallback.
-*
-* During SSR, params are also available via getSsrData().params
-* (ALS-backed).
-*/
-function setCurrentParams(params) {
-	_setCurrentParams(params);
-}
-function useSegmentParams(_route) {
-	try {
-		const navContext = useNavigationContext();
-		if (navContext !== null) return navContext.params;
-	} catch {}
-	return getSsrData()?.params ?? currentParams;
-}
-//#endregion
-//#region src/client/segment-merger.ts
-/**
-* Segment Merger — client-side tree merging for partial RSC payloads.
-*
-* When the server skips rendering sync layouts (because the client already
-* has them cached), the RSC payload is missing outer segment wrappers.
-* This module reconstructs the full element tree by splicing the partial
-* payload into cached segment subtrees.
-*
-* The approach:
-* 1. After each full RSC payload render, walk the decoded element tree
-*    and cache each segment's subtree (identified by SegmentProvider boundaries)
-* 2. When a partial payload arrives, wrap it with cached segment elements
-*    using React.cloneElement to preserve component identity
-*
-* React.cloneElement preserves the element's `type` — React sees the same
-* component at the same tree position and reconciles (preserving state)
-* rather than remounting. This is how layout state survives navigations.
-*
-* Design docs: 19-client-navigation.md §"Navigation Reconciliation"
-* Security: access.ts runs on the server regardless of skipping — this
-*           is a performance optimization only. See 13-security.md.
-*/
-/**
-* Cache of React element subtrees per segment path.
-* Updated after each navigation with the full decoded RSC element tree.
-*/
-var SegmentElementCache = class {
-	entries = /* @__PURE__ */ new Map();
-	get(segmentPath) {
-		return this.entries.get(segmentPath);
-	}
-	set(segmentPath, entry) {
-		this.entries.set(segmentPath, entry);
-	}
-	has(segmentPath) {
-		return this.entries.has(segmentPath);
-	}
-	clear() {
-		this.entries.clear();
-	}
-	get size() {
-		return this.entries.size;
-	}
-	/**
-	* Get the set of segment paths that are safe for the server to skip.
-	* Only segments with an inner SegmentProvider (hasMergeableChild) are
-	* included — the merger can only replace inner SegmentProviders, not
-	* pages embedded in layout output. Used to filter the state tree.
-	*
-	* Returns an empty set if the element cache is empty (no elements
-	* cached yet). This is the safe default — an empty set means no
-	* segments pass the filter, so the state tree is empty and the server
-	* does a full render. The element cache is populated lazily after the
-	* first SPA navigation (RSC-decoded elements from hydration are
-	* thenables that can't be walked until React resolves them).
-	*/
-	getMergeablePaths() {
-		const paths = /* @__PURE__ */ new Set();
-		for (const [, entry] of this.entries) if (entry.hasMergeableChild) paths.add(entry.segmentPath);
-		return paths;
-	}
-};
-/**
-* Check if a React element is a SegmentProvider by looking for the
-* `segments` prop (an array of path segments). This is the only
-* component that receives this prop shape.
-*/
-function isSegmentProvider(element) {
-	if (!isValidElement(element)) return false;
-	const props = element.props;
-	return Array.isArray(props.segments);
-}
-/**
-* Extract the segment path from a SegmentProvider element.
-*
-* Uses the `segmentId` prop if available (set by the server for route groups
-* to distinguish siblings that share the same urlPath). Falls back to
-* reconstructing from the `segments` array prop.
-*/
-function getSegmentPath(element) {
-	const props = element.props;
-	if (props.segmentId) return props.segmentId;
-	const filtered = props.segments.filter(Boolean);
-	return filtered.length === 0 ? "/" : "/" + filtered.join("/");
-}
-/**
-* Walk a React element tree and extract all SegmentProvider boundaries.
-* Returns an ordered list of segment entries from outermost to innermost.
-*
-* This only finds SegmentProviders along the main children path — it does
-* not descend into parallel routes/slots (those are separate subtrees).
-*/
-function extractSegments(element) {
-	const segments = [];
-	walkForSegments(element, segments);
-	for (let i = 0; i < segments.length; i++) segments[i].hasMergeableChild = i < segments.length - 1;
-	return segments;
-}
-function walkForSegments(node, out) {
-	if (!isValidElement(node)) return;
-	const el = node;
-	const props = el.props;
-	if (isSegmentProvider(node)) {
-		out.push({
-			segmentPath: getSegmentPath(el),
-			element: el,
-			hasMergeableChild: false
-		});
-		walkChildren(props.children, out);
-		return;
-	}
-	walkChildren(props.children, out);
-}
-function walkChildren(children, out) {
-	if (children == null) return;
-	if (Array.isArray(children)) for (const child of children) walkForSegments(child, out);
-	else walkForSegments(children, out);
-}
-/**
-* Cache all segment subtrees from a fully-rendered RSC element tree.
-* Call this after every full RSC payload render (navigate, refresh, hydration).
-*/
-function cacheSegmentElements(element, cache) {
-	const segments = extractSegments(element);
-	for (const entry of segments) cache.set(entry.segmentPath, entry);
-}
-function findSegmentProviderPath(node, targetPath) {
-	const children = node.props.children;
-	if (children == null) return null;
-	if (Array.isArray(children)) for (let i = 0; i < children.length; i++) {
-		const child = children[i];
-		if (!isValidElement(child)) continue;
-		if (isSegmentProvider(child)) {
-			if (!targetPath || getSegmentPath(child) === targetPath) return [{
-				element: node,
-				childIndex: i
-			}];
-		}
-		const deeper = findSegmentProviderPath(child, targetPath);
-		if (deeper) return [{
-			element: node,
-			childIndex: i
-		}, ...deeper];
-	}
-	else if (isValidElement(children)) {
-		if (isSegmentProvider(children)) {
-			if (!targetPath || getSegmentPath(children) === targetPath) return [{
-				element: node,
-				childIndex: -1
-			}];
-		}
-		const deeper = findSegmentProviderPath(children, targetPath);
-		if (deeper) return [{
-			element: node,
-			childIndex: -1
-		}, ...deeper];
-	}
-	return null;
-}
-/**
-* Replace a nested SegmentProvider within a cached element tree with
-* new content. Uses cloneElement along the path to produce a new tree
-* with preserved component identity at every level except the replaced node.
-*
-* @param cachedElement The cached SegmentProvider element for this segment
-* @param newInnerContent The new React element to splice in at the inner segment position
-* @param innerSegmentPath The path of the inner segment to replace (optional — replaces first found)
-* @returns New element tree with the inner segment replaced
-*/
-function replaceInnerSegment(cachedElement, newInnerContent, innerSegmentPath) {
-	const path = findSegmentProviderPath(cachedElement, innerSegmentPath);
-	if (!path || path.length === 0) return cachedElement;
-	let replacement = newInnerContent;
-	for (let i = path.length - 1; i >= 0; i--) {
-		const { element, childIndex } = path[i];
-		if (childIndex === -1) replacement = cloneElement(element, {}, replacement);
-		else {
-			const newChildren = [...element.props.children];
-			newChildren[childIndex] = replacement;
-			replacement = cloneElement(element, {}, ...newChildren);
-		}
-	}
-	return replacement;
-}
-/**
-* Merge a partial RSC payload with cached segment elements.
-*
-* When the server skips segments, the partial payload starts from the
-* first non-skipped segment. This function wraps it with cached elements
-* for the skipped segments, producing a full tree that React can
-* reconcile with the mounted tree (preserving layout state).
-*
-* @param partialPayload The RSC payload element (may be partial)
-* @param skippedSegments Ordered list of segment paths that were skipped (outermost first)
-* @param cache The segment element cache
-* @returns The merged full element tree, or the partial payload if merging isn't possible
-*/
-function mergeSegmentTree(partialPayload, skippedSegments, cache) {
-	if (!isValidElement(partialPayload)) return partialPayload;
-	if (skippedSegments.length === 0) return partialPayload;
-	let result = partialPayload;
-	for (let i = skippedSegments.length - 1; i >= 0; i--) {
-		const segmentPath = skippedSegments[i];
-		const cached = cache.get(segmentPath);
-		if (!cached) return partialPayload;
-		result = replaceInnerSegment(cached.element, result);
-	}
-	return result;
-}
-//#endregion
-//#region src/client/rsc-fetch.ts
-var RSC_CONTENT_TYPE = "text/x-component";
-/**
-* Generate a short random cache-busting ID (5 chars, a-z0-9).
-* Matches the format Next.js uses for _rsc params.
-*/
-function generateCacheBustId() {
-	const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-	let id = "";
-	for (let i = 0; i < 5; i++) id += chars[Math.random() * 36 | 0];
-	return id;
-}
-/**
-* Append a `_rsc=<id>` query parameter to the URL.
-* Follows Next.js's pattern — prevents CDN/browser from serving cached HTML
-* for RSC navigation requests and signals that this is an RSC fetch.
-*/
-function appendRscParam(url) {
-	return `${url}${url.includes("?") ? "&" : "?"}_rsc=${generateCacheBustId()}`;
-}
-/**
-* The client's deployment ID, set at bootstrap from the runtime config.
-* Sent with every RSC/action request for version skew detection.
-* Null in dev mode. See TIM-446.
-*/
-var clientDeploymentId = null;
-/** Header name used by the server to signal a version skew reload. */
-var RELOAD_HEADER = "X-Timber-Reload";
-/** Header name for the client's deployment ID. */
-var DEPLOYMENT_ID_HEADER = "X-Timber-Deployment-Id";
-/**
-* Check if a response signals a version skew reload.
-* Triggers a full page reload if the server indicates the client is stale.
-*/
-function checkReloadSignal(response) {
-	return response.headers.get(RELOAD_HEADER) === "1";
-}
-function buildRscHeaders(stateTree, currentUrl) {
-	const headers = { Accept: RSC_CONTENT_TYPE };
-	if (stateTree) headers["X-Timber-State-Tree"] = JSON.stringify(stateTree);
-	if (currentUrl) headers["X-Timber-URL"] = currentUrl;
-	if (clientDeploymentId) headers[DEPLOYMENT_ID_HEADER] = clientDeploymentId;
-	return headers;
-}
-/**
-* Extract head elements from the X-Timber-Head response header.
-* Returns null if the header is missing or malformed.
-*/
-function extractHeadElements(response) {
-	const header = response.headers.get("X-Timber-Head");
-	if (!header) return null;
-	try {
-		return JSON.parse(decodeURIComponent(header));
-	} catch {
-		return null;
-	}
-}
-/**
-* Extract segment metadata from the X-Timber-Segments response header.
-* Returns null if the header is missing or malformed.
-*
-* Format: JSON array of {path, isAsync} objects describing the rendered
-* segment chain from root to leaf. Used to populate the client-side
-* segment cache for state tree diffing on subsequent navigations.
-*/
-function extractSegmentInfo(response) {
-	const header = response.headers.get("X-Timber-Segments");
-	if (!header) return null;
-	try {
-		return JSON.parse(header);
-	} catch {
-		return null;
-	}
-}
-/**
-* Extract skipped segment paths from the X-Timber-Skipped-Segments header.
-* Returns null if the header is missing or malformed.
-*
-* When the server skips sync layouts the client already has cached,
-* it sends this header listing the skipped segment paths (outermost first).
-* The client uses this to merge the partial payload with cached segments.
-*/
-function extractSkippedSegments(response) {
-	const header = response.headers.get("X-Timber-Skipped-Segments");
-	if (!header) return null;
-	try {
-		const parsed = JSON.parse(header);
-		return Array.isArray(parsed) ? parsed : null;
-	} catch {
-		return null;
-	}
-}
-/**
-* Extract route params from the X-Timber-Params response header.
-* Returns null if the header is missing or malformed.
-*
-* Used to populate useSegmentParams() after client-side navigation.
-*/
-function extractParams(response) {
-	const header = response.headers.get("X-Timber-Params");
-	if (!header) return null;
-	try {
-		return JSON.parse(header);
-	} catch {
-		return null;
-	}
-}
-/**
-* Thrown when an RSC payload response contains X-Timber-Redirect header.
-* Caught in navigate() to trigger a soft router navigation to the redirect target.
-*/
-var RedirectError = class extends Error {
-	redirectUrl;
-	constructor(url) {
-		super(`Server redirect to ${url}`);
-		this.redirectUrl = url;
-	}
-};
-/**
-* Thrown when the server signals a version skew (X-Timber-Reload header).
-* Caught in navigate() to trigger a full page reload via triggerStaleReload().
-* See TIM-446.
-*/
-var VersionSkewError = class extends Error {
-	constructor() {
-		super("Version skew detected — server has been redeployed");
-	}
-};
-/**
-* Thrown when the server returns an error for an RSC payload request.
-* The server sends X-Timber-Error header and a JSON body instead of a
-* broken RSC stream for any RenderError (4xx or 5xx). Caught in
-* navigate() to trigger a hard navigation so the server can render
-* the error page as HTML.
-*
-* See design/10-error-handling.md §"Error Page Rendering for Client Navigation"
-*/
-var ServerErrorResponse = class extends Error {
-	status;
-	url;
-	constructor(status, url) {
-		super(`Server error ${status} during navigation to ${url}`);
-		this.status = status;
-		this.url = url;
-	}
-};
-/**
-* Fetch an RSC payload from the server. If a decodeRsc function is provided,
-* the response is decoded into a React element tree via createFromFetch.
-* Otherwise, the raw response text is returned (test mode).
-*
-* Also extracts head elements from the X-Timber-Head response header
-* so the client can update document.title and <meta> tags after navigation.
-*/
-async function fetchRscPayload(url, deps, stateTree, currentUrl, signal) {
-	const rscUrl = appendRscParam(url);
-	const headers = buildRscHeaders(stateTree, currentUrl);
-	if (deps.decodeRsc) {
-		const fetchPromise = deps.fetch(rscUrl, {
-			headers,
-			redirect: "manual",
-			signal
-		});
-		let headElements = null;
-		let segmentInfo = null;
-		let params = null;
-		let skippedSegments = null;
-		const wrappedPromise = fetchPromise.then((response) => {
-			if (checkReloadSignal(response)) throw new VersionSkewError();
-			const redirectLocation = response.headers.get("X-Timber-Redirect") || (response.status >= 300 && response.status < 400 ? response.headers.get("Location") : null);
-			if (redirectLocation) throw new RedirectError(redirectLocation);
-			if (response.headers.get("X-Timber-Error") === "1") throw new ServerErrorResponse(response.status, url);
-			headElements = extractHeadElements(response);
-			segmentInfo = extractSegmentInfo(response);
-			params = extractParams(response);
-			skippedSegments = extractSkippedSegments(response);
-			return response;
-		});
-		await wrappedPromise;
-		return {
-			payload: await deps.decodeRsc(wrappedPromise),
-			headElements,
-			segmentInfo,
-			params,
-			skippedSegments
-		};
-	}
-	const response = await deps.fetch(rscUrl, {
-		headers,
-		redirect: "manual",
-		signal
-	});
-	if (response.status >= 300 && response.status < 400) {
-		const location = response.headers.get("Location");
-		if (location) throw new RedirectError(location);
-	}
-	return {
-		payload: await response.text(),
-		headElements: extractHeadElements(response),
-		segmentInfo: extractSegmentInfo(response),
-		params: extractParams(response),
-		skippedSegments: extractSkippedSegments(response)
-	};
-}
-//#endregion
-//#region src/client/router.ts
-/**
-* Check if an error is an abort error (connection closed / fetch aborted).
-* Browsers throw DOMException with name 'AbortError' when a fetch is aborted.
-*/
-function isAbortError(error) {
-	if (error instanceof DOMException && error.name === "AbortError") return true;
-	if (error instanceof Error && error.name === "AbortError") return true;
-	return false;
-}
-function createRouter(deps) {
-	const segmentCache = new SegmentCache();
-	const prefetchCache = new PrefetchCache();
-	const historyStack = new HistoryStack();
-	const segmentElementCache = new SegmentElementCache();
-	let routerPhase = { phase: "idle" };
-	const pendingListeners = /* @__PURE__ */ new Set();
-	let currentNavAbort = null;
-	/**
-	* Create a new AbortController for a navigation, aborting any
-	* previous in-flight navigation. Optionally links to an external
-	* signal (e.g., from the Navigation API's NavigateEvent.signal).
-	*/
-	function createNavAbort(externalSignal) {
-		currentNavAbort?.abort();
-		const controller = new AbortController();
-		currentNavAbort = controller;
-		if (externalSignal) if (externalSignal.aborted) controller.abort();
-		else externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
-		return controller;
-	}
-	function setPending(value, url) {
-		const next = value && url ? {
-			phase: "navigating",
-			targetUrl: url
-		} : { phase: "idle" };
-		if (routerPhase.phase === next.phase && (routerPhase.phase === "idle" || routerPhase.phase === "navigating" && next.phase === "navigating" && routerPhase.targetUrl === next.targetUrl)) return;
-		routerPhase = next;
-		for (const listener of pendingListeners) listener(value);
-	}
-	/** Update the segment cache from server-provided segment metadata. */
-	function updateSegmentCache(segmentInfo) {
-		if (!segmentInfo || segmentInfo.length === 0) return;
-		const tree = buildSegmentTree(segmentInfo);
-		if (tree) segmentCache.set("/", tree);
-	}
-	/** Render a decoded RSC payload into the DOM if a renderer is available. */
-	function renderPayload(payload, navState) {
-		if (deps.renderRoot) deps.renderRoot(payload, navState);
-	}
-	/**
-	* Merge a partial RSC payload with cached segment elements if segments
-	* were skipped, then cache segments from the (merged) payload.
-	* Returns the merged payload ready for rendering.
-	*/
-	function mergeAndCachePayload(payload, skippedSegments) {
-		let merged = payload;
-		if (skippedSegments && skippedSegments.length > 0) merged = mergeSegmentTree(payload, skippedSegments, segmentElementCache);
-		cacheSegmentElements(merged, segmentElementCache);
-		return merged;
-	}
-	/**
-	* Update navigation state (params + pathname) for the next render.
-	*
-	* Sets the module-level fallback (for tests and SSR) and the
-	* globalThis bridge, then returns the NavigationState so callers
-	* can pass it explicitly to renderRoot/wrapPayload — eliminating
-	* temporal coupling with getNavigationState().
-	*/
-	function updateNavigationState(params, url) {
-		const resolvedParams = params ?? {};
-		setCurrentParams(resolvedParams);
-		const navState = {
-			params: resolvedParams,
-			pathname: url.startsWith("http") ? new URL(url).pathname : url.split("?")[0] || "/"
-		};
-		setNavigationState(navState);
-		return navState;
-	}
-	/**
-	* Render a payload via navigateTransition (production) or renderRoot (tests).
-	* The perform callback should fetch data, update state, and return the
-	* FetchResult plus the NavigationState (so it can be passed explicitly
-	* to wrapPayload/renderRoot without temporal coupling).
-	*/
-	async function renderViaTransition(url, perform) {
-		if (deps.navigateTransition) {
-			let headElements = null;
-			await deps.navigateTransition(url, async (wrapPayload) => {
-				const result = await perform();
-				headElements = result.headElements;
-				const merged = mergeAndCachePayload(result.payload, result.skippedSegments);
-				historyStack.push(url, {
-					payload: merged,
-					headElements: result.headElements,
-					params: result.params
-				});
-				return wrapPayload(merged, result.navState);
-			});
-			return headElements;
-		}
-		const result = await perform();
-		const merged = mergeAndCachePayload(result.payload, result.skippedSegments);
-		historyStack.push(url, {
-			payload: merged,
-			headElements: result.headElements,
-			params: result.params
-		});
-		renderPayload(merged, result.navState);
-		return result.headElements;
-	}
-	/** Apply head elements (title, meta tags) to the DOM if available. */
-	function applyHead(elements) {
-		if (elements && deps.applyHead) deps.applyHead(elements);
-	}
-	/** Run a callback after the next paint (after React commit). */
-	function afterPaint(callback) {
-		if (deps.afterPaint) deps.afterPaint(callback);
-		else callback();
-	}
-	/**
-	* Schedule scroll restoration after the next paint and fire the
-	* scroll-restored event. Used by navigate, popstate, and refresh.
-	*/
-	function restoreScrollAfterPaint(scrollY) {
-		afterPaint(() => {
-			deps.scrollTo(0, scrollY);
-			window.dispatchEvent(new Event("timber:scroll-restored"));
-		});
-	}
-	/**
-	* Core navigation logic shared between the transition and fallback paths.
-	* Fetches the RSC payload, updates all state, and returns the result.
-	*/
-	async function performNavigationFetch(url, options) {
-		const prefetched = prefetchCache.consume(url);
-		let result = prefetched ? {
-			payload: prefetched.payload,
-			headElements: prefetched.headElements,
-			segmentInfo: prefetched.segmentInfo ?? null,
-			params: prefetched.params ?? null,
-			skippedSegments: prefetched.skippedSegments ?? null
-		} : void 0;
-		if (result === void 0) {
-			const stateTree = segmentCache.serializeStateTree(segmentElementCache.getMergeablePaths());
-			const rawCurrentUrl = deps.getCurrentUrl();
-			result = await fetchRscPayload(url, deps, stateTree, rawCurrentUrl.startsWith("http") ? new URL(rawCurrentUrl).pathname : new URL(rawCurrentUrl, "http://localhost").pathname, options.signal);
-		}
-		if (!options.skipHistory) {
-			deps.setRouterNavigating?.(true);
-			if (options.replace) deps.replaceState({
-				timber: true,
-				scrollY: 0
-			}, "", url);
-			else deps.pushState({
-				timber: true,
-				scrollY: 0
-			}, "", url);
-			deps.setRouterNavigating?.(false);
-		}
-		updateSegmentCache(result.segmentInfo);
-		const navState = updateNavigationState(result.params, url);
-		return {
-			...result,
-			navState
-		};
-	}
-	async function navigate(url, options = {}) {
-		const scroll = options.scroll !== false;
-		const replace = options.replace === true;
-		const externalSignal = options._signal;
-		const skipHistory = options._skipHistory === true;
-		const navAbort = createNavAbort(externalSignal);
-		const currentScrollY = deps.getScrollY();
-		if (deps.saveNavigationEntryScroll) deps.saveNavigationEntryScroll(currentScrollY);
-		else deps.replaceState({
-			timber: true,
-			scrollY: currentScrollY
-		}, "", deps.getCurrentUrl());
-		let effectiveSkipHistory = skipHistory;
-		if (!skipHistory && deps.navigationNavigate) {
-			deps.setRouterNavigating?.(true);
-			deps.navigationNavigate(url, replace);
-			deps.setRouterNavigating?.(false);
-			effectiveSkipHistory = true;
-		}
-		setPending(true, url);
-		try {
-			applyHead(await renderViaTransition(url, () => performNavigationFetch(url, {
-				replace,
-				signal: navAbort.signal,
-				skipHistory: effectiveSkipHistory
-			})));
-			window.dispatchEvent(new Event("timber:navigation-end"));
-			restoreScrollAfterPaint(scroll ? 0 : currentScrollY);
-		} catch (error) {
-			if (error instanceof VersionSkewError) {
-				setHardNavigating(true);
-				const { triggerStaleReload } = await import("../_chunks/stale-reload-BLUC_Pl_.js");
-				triggerStaleReload();
-				return new Promise(() => {});
-			}
-			if (error instanceof RedirectError) {
-				setPending(false);
-				deps.completeRouterNavigation?.();
-				await navigate(error.redirectUrl, { replace: true });
-				return;
-			}
-			if (error instanceof ServerErrorResponse) {
-				setHardNavigating(true);
-				window.location.href = error.url;
-				return new Promise(() => {});
-			}
-			if (isAbortError(error)) return;
-			throw error;
-		} finally {
-			if (currentNavAbort === navAbort) currentNavAbort = null;
-			setPending(false);
-			deps.completeRouterNavigation?.();
-		}
-	}
-	async function refresh() {
-		const currentUrl = deps.getCurrentUrl();
-		const navAbort = createNavAbort();
-		setPending(true, currentUrl);
-		try {
-			applyHead(await renderViaTransition(currentUrl, async () => {
-				const result = await fetchRscPayload(currentUrl, deps, void 0, void 0, navAbort.signal);
-				updateSegmentCache(result.segmentInfo);
-				const navState = updateNavigationState(result.params, currentUrl);
-				return {
-					...result,
-					navState
-				};
-			}));
-		} catch (error) {
-			if (isAbortError(error)) return;
-			throw error;
-		} finally {
-			if (currentNavAbort === navAbort) currentNavAbort = null;
-			setPending(false);
-			deps.completeRouterNavigation?.();
-		}
-	}
-	async function handlePopState(url, scrollY = 0, externalSignal) {
-		const entry = historyStack.get(url);
-		if (entry && entry.payload !== null) {
-			const navState = updateNavigationState(entry.params, url);
-			renderPayload(entry.payload, navState);
-			applyHead(entry.headElements);
-			restoreScrollAfterPaint(scrollY);
-		} else {
-			const navAbort = createNavAbort(externalSignal);
-			setPending(true, url);
-			try {
-				applyHead(await renderViaTransition(url, async () => {
-					const result = await fetchRscPayload(url, deps, segmentCache.serializeStateTree(segmentElementCache.getMergeablePaths()), void 0, navAbort.signal);
-					updateSegmentCache(result.segmentInfo);
-					const navState = updateNavigationState(result.params, url);
-					return {
-						...result,
-						navState
-					};
-				}));
-				restoreScrollAfterPaint(scrollY);
-			} catch (error) {
-				if (isAbortError(error)) return;
-				throw error;
-			} finally {
-				if (currentNavAbort === navAbort) currentNavAbort = null;
-				setPending(false);
-			}
-		}
-	}
-	/**
-	* Prefetch an RSC payload for a URL and store it in the prefetch cache.
-	* Called on hover of <Link prefetch> elements.
-	*/
-	function prefetch(url) {
-		if (prefetchCache.get(url) !== void 0) return;
-		if (historyStack.has(url)) return;
-		fetchRscPayload(url, deps, segmentCache.serializeStateTree(segmentElementCache.getMergeablePaths())).then((result) => {
-			prefetchCache.set(url, result);
-		}, () => {});
-	}
-	return {
-		navigate,
-		refresh,
-		handlePopState,
-		isPending: () => routerPhase.phase === "navigating",
-		getPendingUrl: () => routerPhase.phase === "navigating" ? routerPhase.targetUrl : null,
-		onPendingChange(listener) {
-			pendingListeners.add(listener);
-			return () => pendingListeners.delete(listener);
-		},
-		prefetch,
-		applyRevalidation(element, headElements) {
-			const currentUrl = deps.getCurrentUrl();
-			const merged = mergeAndCachePayload(element, null);
-			historyStack.push(currentUrl, {
-				payload: merged,
-				headElements
-			});
-			renderPayload(merged, getNavigationState());
-			applyHead(headElements);
-		},
-		initSegmentCache: (segments) => updateSegmentCache(segments),
-		cacheElementTree: (element) => cacheSegmentElements(element, segmentElementCache),
-		segmentCache,
-		prefetchCache,
-		historyStack
-	};
-}
-//#endregion
-//#region src/client/use-navigation-pending.ts
+//#region src/client/use-pending-navigation.ts
 /**
 * Returns true while an RSC navigation is in flight.
 *
@@ -1466,10 +289,10 @@ function createRouter(deps) {
 *
 * ```tsx
 * 'use client'
-* import { useNavigationPending } from '@timber-js/app/client'
+* import { usePendingNavigation } from '@timber-js/app/client'
 *
 * export function NavBar() {
-*   const isPending = useNavigationPending()
+*   const isPending = usePendingNavigation()
 *   return (
 *     <nav className={isPending ? 'opacity-50' : ''}>
 *       <Link href="/dashboard">Dashboard</Link>
@@ -1478,7 +301,7 @@ function createRouter(deps) {
 * }
 * ```
 */
-function useNavigationPending() {
+function usePendingNavigation() {
 	return usePendingNavigationUrl() !== null;
 }
 //#endregion
@@ -1505,7 +328,7 @@ function useNavigationPending() {
 *
 * For loading UI during navigation, use:
 * - useLinkStatus()          — per-link pending indicator (inside <Link>)
-* - useNavigationPending()   — global navigation pending state
+* - usePendingNavigation()   — global navigation pending state
 */
 /**
 * Get a router instance for programmatic navigation.
@@ -1960,6 +783,6 @@ function useCookie(name, defaultOptions) {
 //#region src/client/index.ts
 _registerUseCookieModule(use_cookie_exports);
 //#endregion
-export { HistoryStack, Link, LinkStatusContext, NavigationProvider, PrefetchCache, SegmentCache, SegmentProvider, TimberErrorBoundary, bindUseQueryStates, buildLinkProps, clearSsrData, createRouter, getNavigationState, getRouter, getRouterOrNull, getSsrData, interpolateParams, mergePreservedSearchParams, resolveHref, setCurrentParams, setGlobalRouter, setNavigationState, setSsrData, useActionState, useCookie, useFormAction, useFormErrors, useLinkStatus, useNavigationPending, usePathname, useQueryStates, useRouter, useSearchParams, useSegmentContext, useSegmentParams, useSelectedLayoutSegment, useSelectedLayoutSegments, validateLinkHref };
+export { Link, LinkStatusContext, buildLinkProps, interpolateParams, mergePreservedSearchParams, resolveHref, useActionState, useCookie, useFormAction, useFormErrors, useLinkStatus, usePathname, usePendingNavigation, useQueryStates, useRouter, useSearchParams, useSegmentParams, useSelectedLayoutSegment, useSelectedLayoutSegments, validateLinkHref };
 
 //# sourceMappingURL=index.js.map