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

package/src/client/location-search.ts

@@ -0,0 +1,15 @@
+import { stripRscCacheKey } from '../shared/rsc-cache-key.ts';
+
+/**
+ * The app-visible search string from the address bar.
+ *
+ * Mirrors what `appVisibleSearch()` does on the server: strips key-shaped
+ * `_rsc` values so the client and server agree on search state regardless
+ * of whether the document URL itself carries a payload cache key (a user
+ * pasting/sharing an RSC payload URL). Non-key-shaped `_rsc` values — an
+ * application legitimately owning that name — survive, using the same
+ * `isRscCacheKeyShape` predicate the server uses.
+ */
+export function locationSearch(): string {
+  return stripRscCacheKey(window.location.search);
+}

package/src/client/navigation-api.ts

@@ -0,0 +1,347 @@
+/**
+ * Navigation API integration — progressive enhancement for client navigation.
+ *
+ * When the Navigation API (`window.navigation`) is available, this module
+ * provides an intercept-based navigation model that replaces the separate
+ * popstate + click handler approach with a single navigate event listener.
+ *
+ * Key benefits:
+ * - Intercepts ALL navigations (link clicks, form submissions, back/forward)
+ * - Built-in AbortSignal per navigation (auto-aborts in-flight fetches)
+ * - Per-entry state via NavigationHistoryEntry.getState()
+ * - navigation.transition for progress tracking
+ *
+ * When unavailable, all functions are no-ops and the History API fallback
+ * in browser-entry.ts handles navigation.
+ *
+ * See design/19-client-navigation.md
+ */
+
+import { isHardNavigating } from './navigation-root.tsx';
+import { stripRscCacheKey } from '../shared/rsc-cache-key.ts';
+
+// ─── Feature Detection ───────────────────────────────────────────
+
+/**
+ * Returns true if the Navigation API is available in the current environment.
+ * Feature-detected at runtime — no polyfill.
+ */
+export function hasNavigationApi(): boolean {
+  return typeof window !== 'undefined' && 'navigation' in window && window.navigation != null;
+}
+
+/**
+ * Get the Navigation API instance. Returns null if unavailable.
+ */
+export function getNavigationApi(): Navigation | null {
+  if (!hasNavigationApi()) return null;
+  return window.navigation;
+}
+
+// ─── Navigation API Controller ───────────────────────────────────
+
+/**
+ * Callbacks for the Navigation API event handler.
+ *
+ * When the Navigation API intercepts a navigation, it delegates to these
+ * callbacks which run the RSC fetch + render pipeline.
+ */
+export interface NavigationApiCallbacks {
+  /**
+   * Handle a push/replace navigation intercepted by the Navigation API.
+   * This covers both Link <a> clicks (user-initiated) and external
+   * navigations (plain <a> tags, programmatic).
+   * The Navigation API handles the URL update via event.intercept().
+   */
+  onExternalNavigate: (
+    url: string,
+    options: { replace: boolean; signal: AbortSignal; scroll?: boolean; departingUrl?: string }
+  ) => Promise<void>;
+
+  /**
+   * Handle a traversal (back/forward button). The Navigation API intercepts
+   * the traversal and delegates to us for RSC replay/fetch.
+   */
+  onTraverse: (url: string, scrollY: number, signal: AbortSignal) => Promise<void>;
+
+  /**
+   * Called when a shallow URL update is intercepted (e.g., nuqs with
+   * shallow: true, or replaceUrl). The URL has already been committed —
+   * this callback syncs NavigationContext.search so useSearchParams()
+   * reflects the new value without a full router navigation.
+   */
+  onShallowNavigate?: (url: string) => void;
+}
+
+/**
+ * Controller returned by setupNavigationApi. Provides methods to
+ * coordinate between the router and the navigate event listener.
+ */
+export interface NavigationApiController {
+  /**
+   * Set the router-navigating flag. When `true`, the next navigate event
+   * (from pushState/replaceState) is recognized as router-initiated. The
+   * handler still intercepts it — but ties the browser's native loading
+   * state to a deferred promise instead of running the RSC pipeline again.
+   *
+   * This means `navigation.transition` is active for the full duration of
+   * every router-initiated navigation, giving the browser a native loading
+   * indicator (tab spinner, address bar) aligned with the TopLoader.
+   *
+   * Must be called synchronously around pushState/replaceState:
+   *   controller.setRouterNavigating(true);
+   *   history.pushState(...);        // navigate event fires, intercepted
+   *   controller.setRouterNavigating(false);  // flag off, deferred stays open
+   */
+  setRouterNavigating: (value: boolean) => void;
+
+  /**
+   * Resolve the deferred promise created by setRouterNavigating(true),
+   * clearing the browser's native loading state. Call this when the
+   * navigation fully completes — the same finally block in router.navigate
+   * that clears the router's pending store.
+   */
+  completeRouterNavigation: () => void;
+
+  /**
+   * Initiate a navigation via the Navigation API (`navigation.navigate()`).
+   * Unlike `history.pushState()`, this fires the navigate event BEFORE
+   * committing the URL — allowing Chrome to show its native loading
+   * indicator while the intercept handler runs.
+   *
+   * Must be called with setRouterNavigating(true) active so the handler
+   * recognizes it as router-initiated and uses the deferred promise.
+   */
+  navigate: (url: string, replace: boolean) => void;
+
+  /**
+   * Save scroll position into the current navigation entry's state.
+   * Uses navigation.updateCurrentEntry() for per-entry scroll storage.
+   */
+  saveScrollPosition: (scrollY: number) => void;
+
+  /**
+   * Check if the Navigation API has an active transition.
+   * Returns the transition object if available, null otherwise.
+   */
+  hasActiveTransition: () => boolean;
+
+  /** Remove the navigate event listener. */
+  cleanup: () => void;
+}
+
+/**
+ * Set up the Navigation API navigate event listener.
+ *
+ * Intercepts same-origin navigations and delegates to the provided callbacks.
+ * Router-initiated navigations (pushState from router.navigate) are detected
+ * via a synchronous flag and NOT intercepted — the router already handles them.
+ *
+ * Returns a controller for coordinating with the router.
+ */
+export function setupNavigationApi(callbacks: NavigationApiCallbacks): NavigationApiController {
+  const nav = getNavigationApi()!;
+
+  let routerNavigating = false;
+
+  // Deferred promise for router-initiated navigations. Created when
+  // setRouterNavigating(true) is called, resolved by completeRouterNavigation().
+  // The navigate event handler intercepts with this promise so the browser's
+  // native loading state (tab spinner) stays active until the navigation
+  // completes — the same lifecycle the TopLoader is driven by.
+  let routerNavDeferred: { promise: Promise<void>; resolve: () => void } | null = null;
+
+  function handleNavigate(event: NavigateEvent): void {
+    // Skip non-interceptable navigations (cross-origin, etc.)
+    if (!event.canIntercept) return;
+
+    // Hard navigation guard: when the router has triggered a full page
+    // load (500 error, version skew), skip interception entirely so the
+    // browser performs the MPA navigation. Without this guard, setting
+    // window.location.href fires a navigate event that we'd intercept,
+    // running the RSC pipeline again → 500 → window.location.href →
+    // navigate event → infinite loop.
+    // See design/19-client-navigation.md §"Hard Navigation Guard"
+    if (isHardNavigating()) return;
+
+    // Skip download requests
+    if (event.downloadRequest) return;
+
+    // Skip blob: URLs — these are almost always downloads or object-URL
+    // navigations initiated by the host page (e.g., generated files, PDFs).
+    // The RSC pipeline cannot handle them, and intercepting would break
+    // the download/open behavior the host page expects.
+    if (event.destination.url.startsWith('blob:')) return;
+
+    // Skip hash-only changes — let the browser handle scroll-to-anchor
+    if (event.hashChange) return;
+
+    // Shallow URL updates (e.g., nuqs search param changes). The navigation
+    // only changes the URL — no server round trip needed. Intercept with a
+    // no-op handler so the Navigation API commits the URL change without
+    // triggering a full page navigation (which is the default if we don't
+    // intercept). The info property is the Navigation API's built-in
+    // per-navigation metadata — no side-channel flags needed.
+    const info = event.info as { shallow?: boolean } | null | undefined;
+    if (info?.shallow) {
+      event.intercept({
+        handler: () => Promise.resolve(),
+        focusReset: 'manual',
+        scroll: 'manual',
+      });
+      callbacks.onShallowNavigate?.(event.destination.url);
+      return;
+    }
+
+    // Skip form submissions with a body (POST/PUT/etc.). These need the
+    // browser's native form handling to send the request body to the server.
+    // Intercepting would convert them into GET RSC navigations, dropping
+    // the form data. Server actions use fetch() directly (not form navigation),
+    // so they are unaffected by this check.
+    if (event.formData) return;
+
+    // Skip cross-origin (defense-in-depth — canIntercept covers this)
+    const destUrl = new URL(event.destination.url);
+    if (destUrl.origin !== location.origin) return;
+
+    // Router-initiated navigation (Link click → router.navigate → pushState).
+    // The router is already running the RSC pipeline — don't run it again.
+    // Instead, intercept with the deferred promise so the browser's native
+    // loading state tracks the navigation's full lifecycle. This aligns the
+    // tab spinner / address bar indicator with the TopLoader.
+    if (routerNavigating && routerNavDeferred) {
+      event.intercept({
+        scroll: 'manual',
+        focusReset: 'manual',
+        handler: () => routerNavDeferred!.promise,
+      });
+      return;
+    }
+
+    // Skip reload navigations — let the browser handle full page reload
+    if (event.navigationType === 'reload') return;
+
+    const url = destUrl.pathname + stripRscCacheKey(destUrl.search);
+
+    if (event.navigationType === 'traverse') {
+      // Back/forward button — intercept and delegate to router.
+      // Read scroll position from the destination entry's state.
+      const entryState = event.destination.getState() as
+        | { scrollY?: number; timber?: boolean }
+        | null
+        | undefined;
+      const scrollY = entryState && typeof entryState.scrollY === 'number' ? entryState.scrollY : 0;
+
+      event.intercept({
+        // Manual scroll — we handle scroll restoration ourselves
+        // via afterPaint (same as the History API path).
+        scroll: 'manual',
+        focusReset: 'manual',
+        async handler() {
+          await callbacks.onTraverse(url, scrollY, event.signal);
+        },
+      });
+    } else if (event.navigationType === 'push' || event.navigationType === 'replace') {
+      // Push/replace — a Link <a> click or an external navigation
+      // (plain <a> tag, programmatic).
+
+      // Save the departing page's scroll position BEFORE event.intercept()
+      // commits the URL change. Once intercept() is called, currentEntry
+      // switches to the new (destination) entry — any updateCurrentEntry()
+      // call after that would save to the wrong entry.
+      // See: router.navigate() also calls saveNavigationEntryScroll(), but
+      // for Navigation API <a> click navigations (where Link does NOT call
+      // router.navigate directly), the router's save runs inside the
+      // intercept handler — too late, currentEntry has already switched.
+      try {
+        const currentState = (nav.currentEntry?.getState() ?? {}) as Record<string, unknown>;
+        nav.updateCurrentEntry({
+          state: { ...currentState, timber: true, scrollY: window.scrollY },
+        });
+      } catch {
+        // Ignore — entry may be disposed
+      }
+
+      // Capture the departing URL BEFORE event.intercept() commits the
+      // destination. Once intercept() is called, currentEntry switches and
+      // getCurrentUrl() returns the destination (TIM-1232).
+      const departingUrl = nav.currentEntry?.url
+        ? new URL(nav.currentEntry.url).pathname +
+          stripRscCacheKey(new URL(nav.currentEntry.url).search)
+        : undefined;
+
+      event.intercept({
+        scroll: 'manual',
+        focusReset: 'manual',
+        async handler() {
+          await callbacks.onExternalNavigate(url + destUrl.hash, {
+            replace: event.navigationType === 'replace',
+            signal: event.signal,
+            scroll: undefined,
+            departingUrl,
+          });
+        },
+      });
+    }
+  }
+
+  nav.addEventListener('navigate', handleNavigate);
+
+  return {
+    setRouterNavigating(value: boolean): void {
+      routerNavigating = value;
+      if (value) {
+        // Create a new deferred promise. The navigate event handler will
+        // intercept and tie the browser's loading state to this promise.
+        let resolve!: () => void;
+        const promise = new Promise<void>((r) => {
+          resolve = r;
+        });
+        routerNavDeferred = { promise, resolve };
+      } else {
+        // Flag off — but DON'T resolve the deferred here. The navigation
+        // is still in flight (RSC fetch + render). completeRouterNavigation()
+        // resolves it when the navigation fully completes.
+        routerNavigating = false;
+      }
+    },
+
+    completeRouterNavigation(): void {
+      if (routerNavDeferred) {
+        routerNavDeferred.resolve();
+        routerNavDeferred = null;
+      }
+    },
+
+    navigate(url: string, replace: boolean): void {
+      // Use navigation.navigate() instead of history.pushState().
+      // This fires the navigate event BEFORE committing the URL,
+      // which lets Chrome show its native loading indicator while
+      // the intercept handler (deferred promise) is pending.
+      // history.pushState() commits the URL synchronously, so Chrome
+      // sees the navigation as already complete and skips the indicator.
+      nav.navigate(url, {
+        history: replace ? 'replace' : 'push',
+      });
+    },
+
+    saveScrollPosition(scrollY: number): void {
+      try {
+        const currentState = (nav.currentEntry?.getState() ?? {}) as Record<string, unknown>;
+        nav.updateCurrentEntry({
+          state: { ...currentState, timber: true, scrollY },
+        });
+      } catch {
+        // Ignore errors — updateCurrentEntry may throw if entry is disposed
+      }
+    },
+
+    hasActiveTransition(): boolean {
+      return nav.transition != null;
+    },
+
+    cleanup(): void {
+      nav.removeEventListener('navigate', handleNavigate);
+    },
+  };
+}

package/src/client/navigation-commit.ts

@@ -0,0 +1,295 @@
+/**
+ * What it means for a page to be "current" on the client.
+ *
+ * One module owns every write that makes a navigation's destination the
+ * current page, and the read that describes the current page back to the
+ * server. Keeping them together is the point: `X-Timber-State-Tree` is
+ * derived from the segment cache, so the thing that publishes and the thing
+ * that reports have to agree about when a page becomes current.
+ *
+ * See design/19-client-navigation.md §"State Update Invariants".
+ */
+
+import { buildSegmentTree, type SegmentCache } from './segment-cache.ts';
+import type { HistoryStack } from './history.ts';
+import type { SegmentInfo, StateTree } from '../shared/segment-info.ts';
+import type { ParamsSource } from '../shared/payload-root.ts';
+import { setNavigationState, type NavigationState } from './navigation-context.ts';
+import {
+  statusPageRendered,
+  _setStatusPageRendered,
+  onStatusPageRendered,
+  _setOnStatusPageRendered,
+} from './state.ts';
+
+// ─── What a status page teaches the cache ─────────────────────────────────
+//
+// A status page replaces a subtree: a deny page lands at the segment owning
+// the matched file and nothing below it mounts; an `error.tsx` fallback
+// discards everything under the boundary that rendered it. `X-Timber-Segments`
+// nonetheless describes the whole chain the payload was built against — it
+// must, because a partial navigation picks its merge point out of it — so the
+// cache has to be told not to learn from such a tree.
+//
+// The HTTP status used to say so, and could not be trusted to: an RSC payload
+// response commits one macrotask after its first chunk, and a nested
+// component that denies after I/O puts its row in the stream after the
+// status line has gone out (TIM-1489). The only thing that reliably knows a
+// status page rendered is the status page itself, and the only moment that
+// matters is the commit that puts it on screen — so every status page the
+// framework produces is wrapped in `StatusPageMarker`, whose layout effect
+// reports on each commit that renders it. Layout effects run child-before-
+// parent, so the report lands before `NavigationRoot`'s publish of that
+// same commit, and never for a render React discards. Without Suspense
+// around the row, the transition cannot commit until the row has arrived, so
+// this covers the delayed nested case too, which no status ever could.
+//
+// The report also clears the cache on the spot, because not every commit
+// has a navigation to consume it: a deny row arriving inside a Suspense
+// boundary after its navigation published, or a status document being
+// hydrated, would otherwise leave a tree in the cache that is no longer on
+// screen. Consuming the flag at commit is what keeps the same navigation from
+// re-seeding it a moment later. Both are over-approximations — a page-level
+// deny leaves every layout standing — at the cost of one full render on the
+// next navigation.
+//
+// Slot boundaries do not report: a slot degrading is the page staying, and
+// the chain it mounted is the chain the header describes. See TIM-1356,
+// TIM-1495, design/04-authorization.md §"Where a Deny Page Renders".
+
+/**
+ * Record that a status page for the main route is on screen. Called from
+ * `StatusPageMarker`'s layout effect; consumed by the commit of the
+ * navigation whose tree it belongs to, and acted on immediately for the
+ * commits that have none.
+ */
+export function reportStatusPageRendered(): void {
+  _setStatusPageRendered(true);
+  onStatusPageRendered?.();
+}
+
+/** Everything a commit needs to describe the page it makes current. */
+export interface NavigationCommitInput {
+  payload: unknown;
+  /** The params that payload published — replayed with it on popstate. */
+  params: ParamsSource;
+  /**
+   * The rendered chain's metadata, or null/undefined when this commit
+   * carries none at all — a revalidation payload, or a history entry
+   * stored before the channel existed.
+   *
+   * An empty *array* is a different statement from an absent one: the
+   * server rendered a route with no layout-bearing segments (a layoutless
+   * app — the missing-root-layout check is a warning, not an error), so
+   * the correct tree is the empty one. Collapsing the two left the
+   * departing route's tree in place, which `treePaths` then reported as
+   * mounted — enough to select an intercepting rewrite whose slot is not
+   * on screen (TIM-1282).
+   */
+  segmentInfo?: SegmentInfo[] | null;
+  /** When true, clear the segment cache if segmentInfo is absent
+   *  (popstate replay for entries without layout metadata). */
+  clearSegmentCacheOnEmpty?: boolean;
+  /**
+   * Layouts the server skipped on this response (`X-Timber-Skipped-Segments`),
+   * when it came from a fetch. Omitted by replays and revalidation.
+   *
+   * Together with `skipped` slot entries in `segmentInfo`, this decides
+   * whether the payload can be *replayed*. A partial payload only renders
+   * merged over the tree on screen, and a `skip=true` outlet resolves against
+   * the slot content cache at render time — so a stored copy of either,
+   * replayed later, shows whatever the client holds *then*, not what was on
+   * screen when the entry committed. Such entries store a null payload and
+   * traversals to them fetch instead. Decided here, not at the fetch call
+   * sites, because there are three of those (`performNavigationFetch`,
+   * `refresh()`, and uncached traversal) and a rule applied at one of them
+   * holds by accident: `performNavigationFetch` had the check and
+   * `fetchCommitAndRender` did not, so a back/forward fetch that was
+   * answered with skips stored the holes (TIM-1432).
+   */
+  skippedSegments?: string[] | null;
+}
+
+/** Whether a response skipped layouts — its payload merges over the tree on screen. */
+export function isPartialNavigation(skippedSegments: string[] | null | undefined): boolean {
+  return skippedSegments != null && skippedSegments.length > 0;
+}
+
+/**
+ * Whether a payload can stand on its own when replayed from the history
+ * stack. See `NavigationCommitInput.skippedSegments`.
+ */
+function isReplayable(opts: NavigationCommitInput): boolean {
+  return !isPartialNavigation(opts.skippedSegments) && !hasSkippedSlot(opts.segmentInfo);
+}
+
+function hasSkippedSlot(segmentInfo: SegmentInfo[] | null | undefined): boolean {
+  return segmentInfo?.some((s) => s.slot && s.skipped) ?? false;
+}
+
+/**
+ * The metadata a history entry keeps. `skipped` describes the *response*
+ * — "this slot's content was omitted" — and the entry stores no such
+ * payload (it stores null). Left on the entry, the flag outlives the
+ * response: `applyActionResult()` reuses the entry's metadata beside a full
+ * re-render and would have that judged non-replayable too.
+ */
+function storedSegmentInfo(segmentInfo: SegmentInfo[] | null | undefined) {
+  if (!hasSkippedSlot(segmentInfo)) return segmentInfo;
+  return segmentInfo!.map(({ skipped: _skipped, ...rest }) => rest);
+}
+
+/**
+ * A navigation's destination, split into what a render needs and what a
+ * commit publishes.
+ */
+export interface PreparedNavigation {
+  /** The state the incoming tree renders with. Pure — safe before winning. */
+  navState: NavigationState;
+  /** Publishes the destination. Call only once the render has won. */
+  commit: () => void;
+}
+
+export interface NavigationCommitter {
+  prepareNavigation(url: string, opts: NavigationCommitInput): PreparedNavigation;
+  currentStateTree(): StateTree | undefined;
+  updateSegmentCache(segmentInfo: SegmentInfo[] | null | undefined): void;
+}
+
+/**
+ * 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.
+ */
+export function deriveNavigationState(url: string): NavigationState {
+  // Params are not part of it. They travel with the payload and are published
+  // by the one client-owned `ParamsProvider` as the new tree renders, which is
+  // also what clears the previous route's — a route with no params of its own
+  // still publishes an empty record (TIM-1294/TIM-1297, and the clearing
+  // requirement from TIM-1285).
+  const parsed = new URL(url, 'http://localhost');
+  return { pathname: parsed.pathname || '/', search: parsed.search };
+}
+
+export function createNavigationCommitter(deps: {
+  segmentCache: SegmentCache;
+  historyStack: HistoryStack;
+  /** Read at call time — the router's `clientSegmentCache` opt-in. */
+  clientSegmentCache: () => boolean | undefined;
+}): NavigationCommitter {
+  const { segmentCache, historyStack } = deps;
+
+  // See `reportStatusPageRendered`: a status page that commits with no
+  // navigation to consume the report still empties the cache.
+  _setOnStatusPageRendered(() => segmentCache.clear());
+
+  /**
+   * Update the segment cache from server-provided segment metadata.
+   *
+   * Runs whether or not `clientSegmentCache` is enabled: the tree is also
+   * where the mounted tree paths come from, and those cross on every
+   * navigation. What the flag gates is which parts get serialized — see
+   * `currentStateTree`.
+   */
+  function updateSegmentCache(segmentInfo: SegmentInfo[] | null | undefined): void {
+    if (!segmentInfo || segmentInfo.length === 0) return;
+    const tree = buildSegmentTree(segmentInfo);
+    if (tree) {
+      segmentCache.set('/', tree);
+    }
+  }
+
+  return {
+    updateSegmentCache,
+
+    /**
+     * The X-Timber-State-Tree to send with the next RSC request.
+     *
+     * Two different things travel on one header. `segments`/`slots` are the
+     * caching opt-in and are omitted unless `clientSegmentCache` is on.
+     * `treePaths` is how the server learns which route is actually mounted,
+     * which stops being derivable from the address bar as soon as a modal is
+     * open — so it crosses regardless (TIM-1282). Undefined when there is
+     * nothing to say, so a no-op header never enters the `_rsc` cache key.
+     *
+     * Reads what the last *committed* navigation published, so a superseded
+     * navigation's destination can never end up describing the mounted tree
+     * (TIM-1301).
+     */
+    currentStateTree(): StateTree | undefined {
+      const tree = segmentCache.serializeStateTree();
+      if (deps.clientSegmentCache()) return tree;
+      return tree.treePaths ? { segments: [], treePaths: tree.treePaths } : undefined;
+    },
+
+    /**
+     * Prepare all navigation-owned state for a new page — without publishing
+     * any of it. Every code path that changes the "current page" must go
+     * through this function, which is what makes "forgot a field" impossible
+     * by construction.
+     *
+     * Returns the destination's `NavigationState`, which is a pure function of
+     * the URL and is what the incoming tree is *rendered* with, plus a
+     * `commit` thunk that performs the writes that make a page current:
+     * 1. Segment cache — update from server-provided segment metadata
+     * 2. Navigation state — pathname/search for usePathname/useSearchParams
+     * 3. History stack — store the payload for instant back/forward replay
+     *
+     * Nothing is written until `commit()` runs, and on a transitioned
+     * navigation it runs only once the transition is known to have won — see
+     * `renderViaTransition` and `NavigationRoot`. A navigation superseded
+     * while its payload was in flight never calls it, so the cache, the
+     * pathname the client reports and the history stack all keep describing
+     * the route still on screen (TIM-1301).
+     *
+     * Callers with state of their own to publish — the address bar, the
+     * client's record of the mounted tree — wrap this thunk rather than
+     * commit beside it, so there stays exactly one moment at which a page
+     * becomes current.
+     */
+    prepareNavigation(url: string, opts: NavigationCommitInput): PreparedNavigation {
+      const navState = deriveNavigationState(url);
+      const payload = isReplayable(opts) ? opts.payload : null;
+
+      // The tree this navigation renders has not rendered yet. Whatever a
+      // boundary reported before now belongs to a commit that had no
+      // navigation to consume it — a hydration, a row that arrived inside a
+      // Suspense boundary after its navigation had published — and must not
+      // be charged to this one.
+      _setStatusPageRendered(false);
+
+      return {
+        navState,
+        commit() {
+          // A tree in which a boundary rendered a status page is not one to
+          // cache — see the module note. Read at commit rather than at
+          // prepare because that is when the boundary has spoken: the row it
+          // renders may not have existed when the response headers were read.
+          // The history entry records the same thing, or a traversal back to
+          // this URL would replay the metadata this drops.
+          const cacheable = !statusPageRendered;
+          _setStatusPageRendered(false);
+          const segmentInfo = cacheable ? opts.segmentInfo : [];
+
+          if (segmentInfo && segmentInfo.length > 0) {
+            updateSegmentCache(segmentInfo);
+          } else if (segmentInfo?.length === 0 || opts.clearSegmentCacheOnEmpty) {
+            segmentCache.clear();
+          }
+
+          setNavigationState(navState);
+
+          historyStack.push(url, {
+            payload,
+            params: opts.params,
+            segmentInfo: storedSegmentInfo(segmentInfo),
+          });
+        },
+      };
+    },
+  };
+}