@rangojs/router 0.26.6 → 0.28.0

package/src/browser/event-controller.ts

@@ -52,6 +52,18 @@ export interface NavigationEntry {
   phase: NavigationPhase;
   startedAt: number;
   options?: NavigateOptionsInternal & { skipLoadingState?: boolean };
+  /**
+   * Resolves once the navigation has ended: its transaction ended and every
+   * stream it opened closed. True when it committed, false when it ended
+   * without a commit (a failure) or was left (aborted, which settles it at
+   * once). A `prefetch: false` fill holds the transaction open
+   * (partial-update.ts awaits fillHoles before it resolves) and its stream
+   * until the fill's answer streamed, so a waiter never cuts a fill or a
+   * stream short. Only the action bridge's follow-up awaits it
+   * (server-action-bridge.ts followUp); no hook reads it, and settling it
+   * notifies nothing.
+   */
+  settled: Promise<boolean>;
 }
 
 /**
@@ -246,7 +258,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;
@@ -351,6 +364,12 @@ export interface EventController {
 
   // Direct state access for advanced use
   getCurrentNavigation(): NavigationEntry | null;
+  /**
+   * The newest navigation until it settles (NavigationEntry.settled): before
+   * its commit, and after it while its transaction or a stream is still
+   * open. Null once it settled or was left.
+   */
+  getUnsettledNavigation(): NavigationEntry | null;
   getInflightActions(): Map<string, ActionEntry>;
   /** Whether any concurrent actions have occurred (shared across all handles) */
   hadAnyConcurrentActions(): boolean;
@@ -513,6 +532,9 @@ export function createEventController(
   // links a request to its signal only until then): the navigation stops
   // reading it, and it streams to its end.
   let streamingNavigation: AbortController | null = null;
+  // The newest navigation until it settles (getUnsettledNavigation). Not
+  // derived state: no hook reads it, and moving it notifies nothing.
+  let unsettledNavigation: NavigationEntry | null = null;
 
   const inflightActions = new Map<string, ActionEntry>();
 
@@ -743,19 +765,31 @@ export function createEventController(
     }
 
     const abort = new AbortController();
+    let resolveSettled!: (committed: boolean) => void;
     const entry: NavigationEntry = {
       url,
       abort,
       phase: "fetching",
       startedAt: Date.now(),
       options,
+      settled: new Promise((resolve) => (resolveSettled = resolve)),
+    };
+    const settle = (committed: boolean): void => {
+      if (unsettledNavigation === entry) unsettledNavigation = null;
+      resolveSettled(committed);
     };
+    abort.signal.addEventListener("abort", () => settle(false));
 
     currentNavigation = entry;
+    unsettledNavigation = entry;
     notify();
 
     let completed = false;
+    let disposed = false;
     let openStreams = 0;
+    const settleIfEnded = (): void => {
+      if (disposed && openStreams === 0) settle(completed);
+    };
 
     return {
       abort,
@@ -780,6 +814,7 @@ export function createEventController(
             if (--openStreams === 0 && streamingNavigation === abort) {
               streamingNavigation = null;
             }
+            settleIfEnded();
             notify();
           },
         };
@@ -797,6 +832,8 @@ export function createEventController(
 
       // Disposable: cleanup if not completed (e.g., error thrown)
       [Symbol.dispose]() {
+        disposed = true;
+        settleIfEnded();
         // If aborted by another navigation, don't touch state
         if (abort.signal.aborted) return;
 
@@ -1072,13 +1109,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);
     }
@@ -1287,6 +1325,7 @@ export function createEventController(
 
     // Direct access
     getCurrentNavigation: () => currentNavigation,
+    getUnsettledNavigation: () => unsettledNavigation,
     getInflightActions: () => inflightActions,
     hadAnyConcurrentActions: () => hadAnyConcurrentActions,
   };

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);
 }
 
@@ -169,13 +163,21 @@ export function stripShellMissMarker(): void {
  *
  * A slot is recognised by its key alone (the `~r` suffix): at start-up the
  * module that defines it may not be loaded.
+ *
+ * The same pass drops the entry's intercept marks (`intercept`,
+ * `sourceUrl`): a document request never renders an intercept, so the entry
+ * is a full page for later Back/Forward.
  */
 export function clearLocationStateOnDocumentLoad(): void {
   const state: unknown = window.history.state;
   if (state === null || typeof state !== "object") return;
   let next: Record<string, unknown> | undefined;
   for (const key in state) {
-    if (isLocationStateKey(key) && key.endsWith(CLEAR_ON_RELOAD_KEY_SUFFIX)) {
+    if (
+      (isLocationStateKey(key) && key.endsWith(CLEAR_ON_RELOAD_KEY_SUFFIX)) ||
+      key === "intercept" ||
+      key === "sourceUrl"
+    ) {
       next ??= { ...state };
       delete next[key];
     }

package/src/browser/intercept-utils.ts

@@ -1,5 +1,7 @@
 import type { ResolvedSegment } from "./types.js";
 import type { SlotState } from "../types.js";
+import { isPlaceholder } from "../types/segments.js";
+import { loaderParentId } from "./react/filter-segment-order.js";
 
 /**
  * Check if a segment is an intercept segment.
@@ -51,3 +53,52 @@ export function hasActiveIntercept(slots?: Record<string, SlotState>): boolean {
 export function isInterceptOnlyCache(segments: ResolvedSegment[]): boolean {
   return segments.some(isInterceptSegment);
 }
+
+/**
+ * An intercept's `matched`: the client's ids without any of the slot's (its
+ * id and every loader segment on it, another intercept's into the same slot
+ * included), then the slot's (interceptSegmentIds). One order for the
+ * prefetch, its fill, an action and a revisit: a fill whose `matched` differs
+ * from its tree's is rendered as a new tree (browser/partial-update.ts
+ * fillHoles). Shared by router/match-result.ts and wholeInterceptMatched.
+ */
+export function interceptMatched(
+  clientIds: readonly string[],
+  slotIds: readonly string[],
+): string[] {
+  // loaderParentId leaves a non-loader id as it is: the slot's own id goes too.
+  return [
+    ...clientIds.filter((id) => loaderParentId(id) !== slotIds[0]),
+    ...slotIds,
+  ];
+}
+
+/**
+ * The `matched` the browser keeps for an intercept answer to a request that
+ * held no segments (a followed redirect, a Back/Forward revalidation with
+ * handles pending, the dev HMR refetch), or undefined to keep the answer's.
+ * The server never renders the page under an intercept and lists it only
+ * from the ids a request held, so such an answer has an empty outlet under
+ * the slot. The page it lands over (`held`) stays, as the server lists it for
+ * a request that holds it.
+ */
+export function wholeInterceptMatched(
+  held: readonly ResolvedSegment[],
+  answer: {
+    matched?: string[];
+    segments?: ResolvedSegment[];
+    slots?: Record<string, SlotState>;
+  },
+): string[] | undefined {
+  if (!hasActiveIntercept(answer.slots)) return undefined;
+  const heldIds = held.filter((s) => !isPlaceholder(s)).map((s) => s.id);
+  if (heldIds.length === 0) return undefined;
+  const slot = answer.segments?.find(
+    (s) => isInterceptSegment(s) && s.type !== "loader",
+  );
+  if (!slot) return undefined;
+  const slotLoaderIds = (answer.matched ?? []).filter(
+    (id) => id !== slot.id && loaderParentId(id) === slot.id,
+  );
+  return interceptMatched(heldIds, [slot.id, ...slotLoaderIds]);
+}

package/src/browser/navigation-bridge.ts

@@ -273,15 +273,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,12 +408,6 @@ 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
@@ -420,10 +417,12 @@ export function createNavigationBridge(
       const hasUsableCache =
         isRestorable(cachedSegments) &&
         !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
@@ -643,16 +642,17 @@ export function createNavigationBridge(
       const isIntercept = historyState?.intercept === true;
       const interceptSourceUrl = historyState?.sourceUrl;
 
-      // Check if intercept context is changing (same URL, different intercept state)
-      // If so, abort in-flight actions - their results would be for wrong context
+      // Actions in flight keep running across an intercept change, as across
+      // any navigation (server-action-bridge.ts followUp).
       const currentInterceptSource = store.getInterceptSourceUrl();
-      const newInterceptSource = interceptSourceUrl ?? null;
-      if (currentInterceptSource !== newInterceptSource) {
-        debugLog(
-          `[Browser] Intercept context changing (${currentInterceptSource} -> ${newInterceptSource}), aborting in-flight actions`,
-        );
-        eventController.abortAllActions();
-      }
+      // An intercept is fetched only from its source page (the page under
+      // an open intercept counts as on screen). From any other page the
+      // entry loads as a document, which renders its URL's full page.
+      const loadsDocument =
+        isIntercept &&
+        generateHistoryKey(
+          currentInterceptSource ?? store.getSegmentState().currentUrl,
+        ) !== generateHistoryKey(interceptSourceUrl);
 
       // Popstate that exits an intercept to a non-intercept destination. The
       // fallback fetch path below needs `leave-intercept` mode so it filters
@@ -663,8 +663,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 -",
@@ -673,13 +675,6 @@ export function createNavigationBridge(
         historyKey,
       );
 
-      // If this is an intercept, restore the intercept context
-      if (isIntercept && interceptSourceUrl) {
-        store.setInterceptSourceUrl(interceptSourceUrl);
-      } else {
-        store.setInterceptSourceUrl(null);
-      }
-
       // Helper to check if streaming is in progress
       const isStreaming = () => eventController.getState().isStreaming;
 
@@ -701,6 +696,7 @@ export function createNavigationBridge(
       const isStale = (cached?.stale ?? false) || isActionFenceActive();
 
       if (isRestorable(cachedSegments)) {
+        store.setInterceptSourceUrl(interceptSourceUrl ?? null);
         // transition({ when }) decides the restore (kind "pop") against the
         // entry being left, so before the store moves to the restored entry.
         // The decision the entry was committed with is not reused: it was
@@ -872,7 +868,15 @@ export function createNavigationBridge(
         debugLog("[Browser] History cache miss for key:", historyKey);
       }
 
-      // Fetch if not cached
+      // Fetch if not cached. The document load starts at the top: pagehide
+      // saves the scroll on screen under this entry, and the browser
+      // restores it after the reload. Instant, so `scroll-behavior: smooth`
+      // cannot leave it part-way when pagehide saves it.
+      if (loadsDocument) {
+        window.scrollTo({ top: 0, behavior: "instant" });
+        return window.location.reload();
+      }
+      store.setInterceptSourceUrl(interceptSourceUrl ?? null);
       const tx = createNavigationTransaction(store, eventController, url, {
         replace: true,
       });

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 } from "../prefetch-markers.js";
+import { writePartialParams } from "./wire-protocol.js";
 
 /**
  * Create a navigation client for fetching RSC payloads
@@ -103,30 +103,23 @@ 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("_rsc_stale", "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,
+          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
@@ -144,15 +137,10 @@ export function createNavigationClient(
       // server-action invalidation) auto-invalidates both scopes.
       // Skip cache for stale revalidation (needs fresh data), HMR (needs
       // fresh modules), and intercept contexts (source-dependent responses).
-      // Suspend prefetch consumption while an action is in flight: a queued
-      // prefetch holds pre-mutation data and must not be served until the
-      // action's response decides whether anything changed.
+      // A prefetch served during an action's flight holds pre-write data:
+      // the action bridge's follow-up refetches the page it commits.
       const canUsePrefetch =
-        !staleRevalidation &&
-        !hmr &&
-        !fill &&
-        !interceptSourceUrl &&
-        !isActionFenceActive();
+        !staleRevalidation && !hmr && !fill && !interceptSourceUrl;
       const rangoState = getRangoState();
       const wildcardKey = buildPrefetchKey(rangoState, fetchUrl);
       const cacheKey = buildSourceKey(rangoState, previousUrl, fetchUrl);

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

@@ -156,7 +156,6 @@ export function createNavigationTransaction(
   url: string,
   options?: NavigateOptionsInternal & { skipLoadingState?: boolean },
 ): NavigationTransaction {
-  let committed = false;
   const currentUrl = window.location.href;
 
   const handle = eventController.startNavigation(url, options);
@@ -165,8 +164,6 @@ export function createNavigationTransaction(
    * Commit the navigation - updates store and URL atomically
    */
   function commit(opts: CommitOptions): CommitResult {
-    committed = true;
-
     const {
       url,
       segmentIds,
@@ -183,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;
@@ -304,14 +304,10 @@ export function createNavigationTransaction(
       };
     },
 
+    // Reaches the handle committed or not: its dispose settles the entry
+    // (NavigationEntry.settled), and resets no state once it completed.
     [Symbol.dispose]() {
-      if (handle.signal.aborted) {
-        return;
-      }
-
-      if (!committed) {
-        handle[Symbol.dispose]();
-      }
+      if (!handle.signal.aborted) handle[Symbol.dispose]();
     },
   };
 }

package/src/browser/partial-update.ts

@@ -24,6 +24,7 @@ import {
 import {
   hasActiveIntercept as hasActiveInterceptSlots,
   isInterceptSegment,
+  wholeInterceptMatched,
 } from "./intercept-utils.js";
 import type { BoundTransaction } from "./navigation-transaction.js";
 import { ServerRedirect } from "../errors.js";
@@ -741,6 +742,13 @@ export function createPartialUpdater(
     if (redirected(payload.metadata)) return;
 
     if (payload.metadata?.isPartial) {
+      // Held nothing, answered as an intercept: the page it lands over stays
+      // under the slot, in `matched` for every reader below (the commit's
+      // handle cleanup included).
+      const kept =
+        segments.length === 0 &&
+        wholeInterceptMatched(cachedSegs, payload.metadata);
+      if (kept) payload.metadata.matched = kept;
       const { segments: newSegments, matched, diff } = payload.metadata;
       let serverSegments = newSegments || [];
       let sent = diff || [];

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;
 }