@rangojs/router 0.27.0 → 0.29.0

package/src/browser/event-controller.ts

@@ -92,6 +92,11 @@ export interface ActionEntry {
   startedAt: number;
   /** Whether action processing is complete (may still be streaming) */
   completed?: boolean;
+  /**
+   * Set when a later call started (see startAction): "id" hides this call
+   * from every reader, "name" from readers that match by export name.
+   */
+  supersededBy?: "id" | "name";
 }
 
 /**
@@ -104,7 +109,7 @@ export interface DerivedNavigationState {
   isStreaming: boolean;
   /** Whether a navigation is active (fetching or streaming, before commit) */
   isNavigating: boolean;
-  /** Current committed location */
+  /** The location of the last page flushed to React (useNavigation keeps the page on screen) */
   location: NavigationLocation;
   /** URL being navigated to (null if idle) */
   pendingUrl: string | null;
@@ -258,7 +263,8 @@ export interface EventController {
     /** Originating history entry key; scopes location-state arbitration. */
     cohort?: string,
   ): ActionHandle;
-  abortAllActions(): void;
+  /** Abort every action in flight except `except` (an ActionHandle id). */
+  abortAllActions(except?: string): void;
 
   // State access
   getState(): DerivedNavigationState;
@@ -711,15 +717,18 @@ export function createEventController(
     // idle snapshot (the same reference use-action falls back to).
     if (inflightActions.size === 0) return DEFAULT_ACTION_STATE;
 
-    const entry = [...inflightActions.values()]
-      .filter((a) => matchesActionId(actionId, a.actionId))
-      .reduce<ActionEntry | undefined>((best, a) => {
-        if (!best) return a;
-        const aActive = a.phase !== "settling";
-        const bActive = best.phase !== "settling";
-        if (aActive !== bActive) return aActive ? a : best;
-        return a.startedAt > best.startedAt ? a : best;
-      }, undefined);
+    // The latest call this reader matches, or none once a later call left the
+    // map: an earlier call still running is never reported again.
+    const byName = !actionId.includes("#");
+    let entry: ActionEntry | undefined;
+    for (const a of inflightActions.values()) {
+      if (
+        matchesActionId(actionId, a.actionId) &&
+        (byName ? !a.supersededBy : a.supersededBy !== "id")
+      ) {
+        entry = a;
+      }
+    }
 
     if (!entry) {
       return { ...DEFAULT_ACTION_STATE };
@@ -912,6 +921,20 @@ export function createEventController(
       hadAnyConcurrentActions = true;
     }
 
+    // useAction reports the latest call. Every earlier call that a reader of
+    // this one also matches is hidden from that reader for good, so it never
+    // shows again after this call settles and leaves the map: a call of the
+    // same action from every reader, a call of another action with the same
+    // export name from readers that match by name (matchesActionId).
+    const hash = actionId.lastIndexOf("#");
+    const name = hash === -1 ? null : actionId.slice(hash + 1);
+    for (const a of inflightActions.values()) {
+      if (a.actionId === actionId) a.supersededBy = "id";
+      else if (name !== null && matchesActionId(name, a.actionId)) {
+        a.supersededBy ??= "name";
+      }
+    }
+
     const entry: ActionEntry = {
       id,
       actionId,
@@ -1108,13 +1131,14 @@ export function createEventController(
     };
   }
 
-  function abortAllActions() {
+  /** Abort every action in flight except `except` (an ActionHandle id). */
+  function abortAllActions(except?: string) {
     for (const [id, entry] of inflightActions) {
       // Preserve settling entries — they have already been handled by
       // fail()/complete() and will self-cleanup via the settlement timeout.
       // Clearing them here would prevent debounced notifications from
       // delivering the error/result state to subscribers.
-      if (entry.phase === "settling") continue;
+      if (entry.phase === "settling" || id === except) continue;
       entry.abort.abort();
       inflightActions.delete(id);
     }

package/src/browser/history-state.ts

@@ -9,6 +9,7 @@ import {
   resolveLocationStateEntries,
   stampLocationState,
 } from "./react/location-state-shared.js";
+import { WIRE } from "../wire-params.js";
 
 /**
  * Check if state is from typed LocationStateEntry[] (has __rsc_ls_ keys)
@@ -137,16 +138,9 @@ export function pushHistoryWithIdx(
 }
 
 /**
- * The forced-MISS reload marker (`SHELL_MISS_PARAM` in rsc/shell-serve.ts,
- * which the browser bundle must not import): a degraded PPR shell HIT
- * reloads the page with it, and the server renders a marked request like a
- * cache miss.
- */
-export const SHELL_MISS_MARKER: string = "_rsc_shell";
-
-/**
- * Drop the forced-MISS marker from the address bar at boot, keeping the
- * history entry's state (initBrowserApp calls it before any location read).
+ * Drop the forced-MISS marker (`WIRE.shellMiss`, rsc/shell-serve.ts) from the
+ * address bar at boot, keeping the history entry's state (initBrowserApp
+ * calls it before any location read).
  * Left in place, a refresh or a shared link would stay off the shell and the
  * app's search params would carry it. The server strips the same marker from
  * the request before rendering (shell-serve.ts withoutShellMissMarker), so
@@ -154,8 +148,8 @@ export const SHELL_MISS_MARKER: string = "_rsc_shell";
  */
 export function stripShellMissMarker(): void {
   const url = new URL(window.location.href);
-  if (!url.searchParams.has(SHELL_MISS_MARKER)) return;
-  url.searchParams.delete(SHELL_MISS_MARKER);
+  if (!url.searchParams.has(WIRE.shellMiss)) return;
+  url.searchParams.delete(WIRE.shellMiss);
   window.history.replaceState(window.history.state, "", url.href);
 }
 

package/src/browser/navigation-bridge.ts

@@ -45,6 +45,7 @@ import {
 } from "./navigation-store.js";
 import type { EventController } from "./event-controller.js";
 import { isInterceptOnlyCache } from "./intercept-utils.js";
+import { actionBoundaryAt, idsAboveBoundary } from "./segment-reconciler.js";
 import {
   toNetworkError,
   emitNetworkError,
@@ -206,7 +207,10 @@ export function createNavigationBridge(
     error: ServerRedirect,
     url: string,
     hops: number,
-    options: { replace?: boolean; transition?: boolean },
+    options: Pick<
+      NavigateOptionsInternal,
+      "replace" | "transition" | "_redirectFrom"
+    >,
   ): Promise<void> {
     const redirectUrl = validateRedirectOrigin(
       error.url,
@@ -228,6 +232,7 @@ export function createNavigationBridge(
       ...options,
       _skipCache: true,
       _redirectHops: hops + 1,
+      _redirectFrom: options._redirectFrom ?? url,
     });
   }
 
@@ -273,15 +278,18 @@ export function createNavigationBridge(
         targetUrl.pathname === new URL(window.location.href).pathname
       ) {
         // Preserve intercept context from the current history entry so that
-        // popstate uses the correct cache key (:intercept suffix) and restores
-        // the right full-page vs modal semantics.
+        // popstate uses the same cache key and restores the right full-page
+        // vs intercept semantics.
         const currentHistoryState = window.history.state;
         const isIntercept = currentHistoryState?.intercept === true;
         const interceptSourceUrl = isIntercept
           ? currentHistoryState?.sourceUrl
           : undefined;
 
-        const historyKey = generateHistoryKey(url, { intercept: isIntercept });
+        const historyKey = generateHistoryKey(url, {
+          intercept: isIntercept,
+          interceptSource: interceptSourceUrl,
+        });
 
         // Copy current segments to the new history key so back/forward restores instantly.
         // The array itself, not a clone: getPageHistoryKeys reads a shared
@@ -405,25 +413,24 @@ export function createNavigationBridge(
         });
       }
 
-      // Also check if there's an intercept cache entry for this URL
-      // If so, this URL CAN be intercepted, and we shouldn't use the non-intercept cache
-      // because the navigation might result in an intercept (depending on source URL)
-      const interceptHistoryKey = generateHistoryKey(url, { intercept: true });
-      const hasInterceptCache = store.hasHistoryCache(interceptHistoryKey);
-
       // Skip cached SWR for:
       // 1. intercept caches - interception depends on source page context
       // 2. routes that CAN be intercepted - we don't know if this navigation will intercept
       // 3. when leaving intercept - we need fresh non-intercept segments from server
       // 4. redirect-with-state - force re-render so hooks read fresh state
       // 5. stale cache - server action invalidated it, need fresh data with loading state
+      // 6. an error boundary in the list - a link renders the page again; its
+      //    ids would tell the server the client holds what the error replaced
       const hasUsableCache =
         isRestorable(cachedSegments) &&
+        !cachedSegments.some((s) => s.type === "error") &&
         !isInterceptOnlyCache(cachedSegments) &&
-        !hasInterceptCache &&
         !isLeavingIntercept &&
         !cached?.stale &&
-        !options?._skipCache;
+        !options?._skipCache &&
+        // A cached intercept entry for this URL (from any source page) means
+        // the navigation might intercept, depending on the source URL.
+        !store.hasInterceptCache(historyKey);
 
       // Forward navigations always await fetchPartialUpdate before rendering,
       // so useNavigation should always report "loading". skipLoadingState is
@@ -539,7 +546,11 @@ export function createNavigationBridge(
             error,
             url,
             options?._redirectHops ?? 0,
-            { replace: options?.replace, transition: options?.transition },
+            {
+              replace: options?.replace,
+              transition: options?.transition,
+              _redirectFrom: options?._redirectFrom,
+            },
           );
         }
 
@@ -570,9 +581,19 @@ export function createNavigationBridge(
     },
 
     /**
-     * Refresh current route
+     * Refresh current route. A cross-tab refresh holds the action error
+     * boundary the page shows (actionBoundaryAt), as the follow-up does: it
+     * is this tab's own outcome, not a read another tab's write changed. A
+     * refresh the app asks for renders it again.
      */
-    async refresh(): Promise<void> {
+    async refresh(crossTab?: boolean): Promise<void> {
+      const shown =
+        (crossTab &&
+          !store.getInterceptSourceUrl() &&
+          store.getCachedSegments(store.getHistoryKey())?.segments) ||
+        [];
+      const at = actionBoundaryAt(shown);
+      if (at === 0) return;
       eventController.abortNavigation();
 
       const tx = createNavigationTransaction(
@@ -590,7 +611,7 @@ export function createNavigationBridge(
           false,
           tx.handle.signal,
           tx.with({ url: window.location.href, replace: true, scroll: false }),
-          { type: "navigate", refresh: true },
+          { type: "navigate", refresh: true, boundary: shown[at]?.id },
         );
       } catch (error) {
         // Aborted or superseded: bail without rendering a boundary (see navigate()).
@@ -664,8 +685,10 @@ export function createNavigationBridge(
       const isLeavingIntercept =
         !isIntercept && currentInterceptSource !== null;
 
-      // Compute history key from URL (with intercept suffix if applicable)
-      const historyKey = generateHistoryKey(url, { intercept: isIntercept });
+      const historyKey = generateHistoryKey(url, {
+        intercept: isIntercept,
+        interceptSource: interceptSourceUrl,
+      });
 
       debugLog(
         "[Browser] Popstate -",
@@ -716,9 +739,20 @@ export function createNavigationBridge(
             }),
           });
 
+        // An action error boundary the entry shows (actionBoundaryAt) is
+        // held: the page holds the ids above it, so a link renders it again,
+        // and the revalidation below renders above it. Never under an
+        // intercept, as the follow-up (server-action-bridge.ts).
+        const boundaryAt = isIntercept ? -1 : actionBoundaryAt(cachedSegments);
+        const boundary = cachedSegments[boundaryAt]?.id;
+        const heldIds = idsAboveBoundary(
+          cachedSegments.map((s) => s.id),
+          boundary,
+        );
+
         // Update store to point to this history entry
         store.setHistoryKey(historyKey);
-        store.setSegmentIds(cachedSegments.map((s) => s.id));
+        store.setSegmentIds(heldIds);
         store.setCurrentUrl(url);
         store.setPath(new URL(url).pathname);
 
@@ -797,8 +831,9 @@ export function createNavigationBridge(
                 onUpdate({ ...popstateUpdate, inTransition: true });
               });
             }
-            // SWR: If stale, trigger background revalidation
-            if (isStale) {
+            // SWR: If stale, trigger background revalidation. Nothing is
+            // above a boundary at the page's first segment.
+            if (isStale && boundaryAt !== 0) {
               debugLog("[Browser] Cache is stale, background revalidating...");
               // Background revalidation - don't await, just fire and forget.
               // When the entry's handles are incomplete (a deferred Meta was still
@@ -810,9 +845,7 @@ export function createNavigationBridge(
               // would stay the pre-resolution carry. handlesPending is set only for
               // the deferred-Meta-aborted case, so action/cross-tab SWR keeps the
               // cheap diff path.
-              const segmentIds = cached?.handlesPending
-                ? []
-                : cachedSegments.map((s) => s.id);
+              const segmentIds = cached?.handlesPending ? [] : heldIds;
 
               const tx = createNavigationTransaction(
                 store,
@@ -834,7 +867,7 @@ export function createNavigationBridge(
                   interceptSourceUrl,
                   cacheOnly: true,
                 }),
-                { type: "stale-revalidation", interceptSourceUrl },
+                { type: "stale-revalidation", interceptSourceUrl, boundary },
               )
                 .catch((error) => {
                   if (isBackgroundSuppressible(error)) return;
@@ -989,7 +1022,7 @@ export function createNavigationBridge(
 
       // Register cross-tab refresh callback with the store
       store.setCrossTabRefreshCallback(() => {
-        this.refresh();
+        this.refresh(true);
       });
 
       window.addEventListener("popstate", handlePopstate);

package/src/browser/navigation-client.ts

@@ -38,7 +38,7 @@ import {
   type DecodedPrefetch,
 } from "./prefetch/cache.js";
 import { cancelAllPrefetches } from "./prefetch/loader.js";
-import { FILL_PARAM, STALE_PARAM } from "../prefetch-markers.js";
+import { writePartialParams } from "./wire-protocol.js";
 
 /**
  * Create a navigation client for fetching RSC payloads
@@ -82,6 +82,7 @@ export function createNavigationClient(
         rewriteTarget,
         signal,
         staleRevalidation,
+        boundary,
         interceptSourceUrl,
         version,
         routerId,
@@ -103,30 +104,24 @@ export function createNavigationClient(
       }
 
       // Build fetch URL with partial rendering params (used for both
-      // cache key lookup and actual fetch if cache misses)
-      const fetchUrl = new URL(targetUrl, window.location.origin);
-      fetchUrl.searchParams.set("_rsc_partial", "true");
-      fetchUrl.searchParams.set("_rsc_segments", segmentIds.join(","));
-      if (staleRevalidation) {
-        fetchUrl.searchParams.set(STALE_PARAM, "true");
-      }
-      if (version) {
-        fetchUrl.searchParams.set("_rsc_v", version);
-      }
-      if (routerId) {
-        fetchUrl.searchParams.set("_rsc_rid", routerId);
-      }
-      // The page left's rewrite target (#1144), in both prefetch keys like
-      // the params above: buildPrefetchUrl sets it in the same place.
-      if (rewriteTarget) {
-        fetchUrl.searchParams.set("_rsc_rt", rewriteTarget);
-      }
-      // A param, not a header: the document cache decides from the raw URL
-      // (cache/document-cache.ts), and it keeps the fill out of every
-      // prefetch key below.
-      if (fill) {
-        fetchUrl.searchParams.set(FILL_PARAM, "1");
-      }
+      // cache key lookup and actual fetch if cache misses). The page left's
+      // rewrite target (#1144) is in both prefetch keys, like the params
+      // around it. The fill is a param, not a header: the document cache
+      // decides from the raw URL (cache/document-cache.ts), and it keeps the
+      // fill out of every prefetch key below.
+      const fetchUrl = writePartialParams(
+        new URL(targetUrl, window.location.origin),
+        {
+          segmentIds,
+          emptySegments: "send",
+          stale: staleRevalidation,
+          boundary,
+          version,
+          routerId,
+          rewriteTarget,
+          fill,
+        },
+      );
 
       // If the lazy prefetch runtime has not loaded yet, prevent a deferred
       // speculative request from starting after this navigation misses the

package/src/browser/navigation-store.ts

@@ -34,7 +34,7 @@ const HISTORY_ENTRY_MEMORY_SIZE = 200;
 // stale=true means the data may be outdated and should be revalidated on access.
 // navInstance is the monotonic nav-instance token (see navInstance below): it
 // identifies the per-commit visit that owns this entry. generateHistoryKey is
-// URL-only, so A->B->A reuses the same key; the token lets a late async
+// the URL (plus the source page for an intercept), so A->B->A reuses the key; the token lets a late async
 // resolution tell its own visit's entry apart from a newer same-URL visit's, so
 // a stale nav can never clobber a fresher one.
 // handlesPending=true means the entry's handle data is INCOMPLETE (a deferred
@@ -124,36 +124,35 @@ function getCacheInvalidationChannel(): BroadcastChannel | null {
  * Options for generating a history key
  */
 export interface HistoryKeyOptions {
-  /** If true, append :intercept suffix to differentiate intercept entries */
+  /** Key an intercept entry (apart from the plain entry for the URL). */
   intercept?: boolean;
+  /** The page the intercept was opened over (history.state.sourceUrl). */
+  interceptSource?: string;
+}
+
+function urlKey(url: string): string {
+  const parsed = new URL(url, "http://localhost");
+  return parsed.pathname + parsed.search;
 }
 
 /**
- * Generate a cache key from a URL.
- * Uses pathname + search (query params) directly as the key.
- * Hash fragments (#) are excluded since they don't affect server data.
+ * Generate a cache key from a URL: pathname + search. Hash fragments (#) are
+ * excluded since they don't affect server data.
  *
- * For intercept routes, append `:intercept` suffix to cache them separately
- * from non-intercept versions of the same URL.
+ * An intercept entry is keyed `<url>:intercept:<source>`: its cached tree
+ * includes the page under the intercept. hasInterceptCache relies on the
+ * `:intercept:` separator.
  */
 export function generateHistoryKey(
   url?: string,
   options?: HistoryKeyOptions,
 ): string {
-  if (!url) {
-    url = typeof window !== "undefined" ? window.location.href : "/";
-  }
-
-  // Parse URL and use only pathname + search (exclude hash fragment)
-  const parsed = new URL(url, "http://localhost");
-  let key = parsed.pathname + parsed.search;
-
-  // Append intercept suffix for separate caching
-  if (options?.intercept) {
-    key += ":intercept";
-  }
-
-  return key;
+  const key = urlKey(
+    url || (typeof window !== "undefined" ? window.location.href : "/"),
+  );
+  if (!options?.intercept) return key;
+  const source = options.interceptSource;
+  return `${key}:intercept:${source ? urlKey(source) : ""}`;
 }
 
 /**
@@ -258,7 +257,8 @@ export function createNavigationStore(
 
   // Monotonic nav-instance token. Bumped each time a cache entry is created or
   // replaced in cacheSegmentsForHistory (i.e. once per commit). Because
-  // generateHistoryKey is URL-only, two visits to the same URL share a key; this
+  // generateHistoryKey is the URL (plus the source page for an intercept), two
+  // visits to the same URL share a key; this
   // token gives each visit a distinct identity so a late async handle resolution
   // can tell whether it still owns the live page / the target cache entry, and
   // never overwrite a newer same-URL visit's state.
@@ -580,11 +580,9 @@ export function createNavigationStore(
       };
     },
 
-    /**
-     * Check if segments are cached for a history entry
-     */
-    hasHistoryCache(historyKey: string): boolean {
-      return historyCache.some(([key]) => key === historyKey);
+    hasInterceptCache(historyKey: string): boolean {
+      const prefix = `${historyKey}:intercept:`;
+      return historyCache.some(([key]) => key.startsWith(prefix));
     },
 
     /**

package/src/browser/navigation-transaction.ts

@@ -180,7 +180,10 @@ export function createNavigationTransaction(
 
     const parsedUrl = new URL(url, window.location.origin);
 
-    const historyKey = generateHistoryKey(url, { intercept });
+    const historyKey = generateHistoryKey(url, {
+      intercept,
+      interceptSource: interceptSourceUrl,
+    });
 
     if (cacheOnly) {
       const currentHandleData = eventController.getHandleState().data;

package/src/browser/network-error-handler.ts

@@ -28,6 +28,9 @@ export function toNetworkError(
  * Render an error into the segment tree via the onUpdate subscriber so the
  * nearest error boundary catches it. Wrapped in startTransition; RenderErrorThrower
  * throws during render (async rejections do not reach boundaries on their own).
+ * Flagged inTransition like every tree handed over in a transition, so route
+ * state that arrives after it (the failed navigation's idle) waits for its
+ * commit (NavigationProvider's "anchor").
  */
 function emitErrorToBoundary(
   onUpdate: UpdateSubscriber,
@@ -43,6 +46,7 @@ function emitErrorToBoundary(
         segments: [],
         isError: true,
       },
+      inTransition: true,
     });
   });
 }

package/src/browser/partial-update.ts

@@ -14,7 +14,7 @@ export const addTransitionType: ((type: string) => void) | undefined =
   "addTransitionType" in React ? (React as any).addTransitionType : undefined;
 
 import type { RenderSegmentsOptions } from "../segment-system.js";
-import { reconcileSegments } from "./segment-reconciler.js";
+import { idsAboveBoundary, reconcileSegments } from "./segment-reconciler.js";
 import type { ReconcileActor } from "./segment-reconciler.js";
 import { Defer } from "./defer.js";
 import {
@@ -236,15 +236,28 @@ export type UpdateMode =
        * transition({ when }) sees kind "revalidate", not "replace".
        */
       refresh?: boolean;
+      /** The cross-tab refresh's held boundary (see `action`). */
+      boundary?: string;
+    }
+  | { type: "leave-intercept"; interceptSourceUrl?: string; boundary?: never }
+  | {
+      type: "stale-revalidation";
+      interceptSourceUrl?: string;
+      /** Back/Forward's held boundary (see `action`). */
+      boundary?: string;
     }
-  | { type: "leave-intercept"; interceptSourceUrl?: string }
-  | { type: "stale-revalidation"; interceptSourceUrl?: string }
   | {
       type: "action";
       interceptSourceUrl?: string;
       actionId?: string;
       /** The action's FormData and result, for transition({ when }) `action`. */
       action?: TransitionWhenActionInput;
+      /**
+       * An action's error boundary the page shows (actionBoundaryAt): the
+       * server renders above it, its cached segment stays, and the page
+       * holds only the ids above it.
+       */
+      boundary?: string;
     };
 
 /**
@@ -569,6 +582,7 @@ export function createPartialUpdater(
     const historyKeyAtStart = store.getHistoryKey();
 
     const interceptSourceUrl = mode.interceptSourceUrl;
+    const boundary = mode.boundary;
 
     let segments: string[];
     if (mode.type === "leave-intercept") {
@@ -690,6 +704,7 @@ export function createPartialUpdater(
         : store.getHistoryEntryMemory()?.rewriteTarget,
       staleRevalidation:
         mode.type === "stale-revalidation" || segments.length === 0,
+      boundary,
       version: getVersion(),
       routerId: store.getRouterId?.(),
     });
@@ -874,14 +889,14 @@ export function createPartialUpdater(
       // in place of each missing value, and this navigation fills them from
       // one fill request once it has committed the tree.
       let defers: Holes["defers"] | undefined;
-      let heldIds = matchedIds;
+      let heldIds = idsAboveBoundary(matchedIds, boundary);
       const placeholders = serverSegments.filter(isPlaceholder);
       if (placeholders.length > 0) {
         defers = armHoles(placeholders);
         // A placeholder is not held: every later request from this page
         // leaves its id out, so the server renders it.
         const deferredIds = new Set(placeholders.map((s) => s.id));
-        heldIds = matchedIds.filter((id) => !deferredIds.has(id));
+        heldIds = heldIds.filter((id) => !deferredIds.has(id));
       }
 
       const reconcile = () =>
@@ -895,7 +910,10 @@ export function createPartialUpdater(
         });
       let reconciled = reconcile();
 
-      const missing = missingIds(matchedIds, reconciled.segments);
+      // Not the ids at or below a held boundary: its loaders may never have
+      // reached the client (the route failed on its GET), and nothing renders
+      // them under the error.
+      const missing = missingIds(heldIds, reconciled.segments);
 
       if (missing.length > 0) {
         const missingCount = missing.length;
@@ -1119,6 +1137,15 @@ export function createPartialUpdater(
         }),
         ...(serverLocationState && { serverState: serverLocationState }),
       };
+      // A refetch that held an action's boundary commits only while the page
+      // on screen still shows it: a later commit there (an action's success)
+      // replaced it, and this response would put the error back.
+      if (
+        boundary &&
+        !entryOnScreen()?.includes(cachedSegs.find((s) => s.id === boundary)!)
+      ) {
+        return;
+      }
       const cachedHandleData = readCachedHandleData?.();
       const { scroll: navScroll } = tx.commit(
         heldIds,

package/src/browser/prefetch/cache.ts

@@ -43,6 +43,7 @@ import { abortAllPrefetches } from "./loader.js";
 import { notifyPrefetchCacheInvalidated } from "./invalidation.js";
 import { invalidateRangoState } from "../rango-state.js";
 import type { RscPayload } from "../types.js";
+import { WIRE } from "../../wire-params.js";
 
 /**
  * A prefetch that has been fetched AND eagerly decoded. Storing the decoded
@@ -190,7 +191,7 @@ let generation = 0;
  */
 export function buildPrefetchKey(prefix: string, targetUrl: URL): string {
   const normalizedTarget = new URL(targetUrl);
-  normalizedTarget.searchParams.delete("_rsc_segments");
+  normalizedTarget.searchParams.delete(WIRE.segments);
   return prefix + "\0" + normalizedTarget.pathname + normalizedTarget.search;
 }