@rangojs/router 0.26.6 → 0.28.0

package/src/browser/prefetch/fetch.ts

@@ -38,6 +38,7 @@ import { SEGMENT_FRAGMENT_CAPABILITY_HEADER } from "../../segment-fragments.js";
 import { PREFETCH_HEADER } from "../../prefetch-markers.js";
 import type { RscPayload } from "../types.js";
 import { getRegisteredStore } from "../navigation-store-handle.js";
+import { writePartialParams } from "../wire-protocol.js";
 
 /**
  * Decoder injected at app startup (see setPrefetchDecoder). This is
@@ -153,24 +154,15 @@ function buildPrefetchUrl(
   if (targetUrl.origin !== window.location.origin) {
     return null;
   }
-  targetUrl.searchParams.set("_rsc_partial", "true");
-  if (segmentIds.length > 0) {
-    targetUrl.searchParams.set("_rsc_segments", segmentIds.join(","));
-  }
-  if (version) {
-    targetUrl.searchParams.set("_rsc_v", version);
-  }
-  if (routerId) {
-    targetUrl.searchParams.set("_rsc_rid", routerId);
-  }
   // The page's rewrite target, so the server diffs against the route that
   // rendered it, as for the navigation.
-  const rewriteTarget =
-    getRegisteredStore()?.getHistoryEntryMemory()?.rewriteTarget;
-  if (rewriteTarget) {
-    targetUrl.searchParams.set("_rsc_rt", rewriteTarget);
-  }
-  return targetUrl;
+  return writePartialParams(targetUrl, {
+    segmentIds,
+    emptySegments: "omit",
+    version,
+    routerId,
+    rewriteTarget: getRegisteredStore()?.getHistoryEntryMemory()?.rewriteTarget,
+  });
 }
 
 /**

package/src/browser/prefetch/queue.ts

@@ -15,6 +15,7 @@
  */
 
 import { wait, waitForIdle, waitForViewportImages } from "./resource-ready.js";
+import { WIRE_PREFIX } from "../../wire-params.js";
 
 // Max prefetches executing at once. Mirrors DEFAULT_PREFETCH_CONCURRENCY
 // (router/prefetch-limits.ts); kept as a local literal so the client bundle
@@ -128,16 +129,15 @@ export function enqueuePrefetch(
 
 /**
  * Normalize a URL-like string for keep-alive matching: parse against a
- * placeholder origin and strip internal `_rsc_*` query params. Returns
+ * placeholder origin and strip every `WIRE_PREFIX` query param. Returns
  * `pathname + search` so comparisons ignore hash and the internal params
- * that prefetch appends to targets (`_rsc_partial`, `_rsc_segments`,
- * `_rsc_v`, `_rsc_rid`, `_rsc_stale`).
+ * that prefetch appends to targets.
  */
 function normalizeForMatch(urlish: string): string {
   try {
     const u = new URL(urlish, "http://placeholder");
     for (const k of [...u.searchParams.keys()]) {
-      if (k.startsWith("_rsc_")) u.searchParams.delete(k);
+      if (k.startsWith(WIRE_PREFIX)) u.searchParams.delete(k);
     }
     return u.pathname + u.search;
   } catch {

package/src/browser/react/NavigationProvider.tsx

@@ -78,7 +78,8 @@ async function processHandles(
 
   // This nav's instance token, captured before any await — processHandles runs
   // right after its own commit, so this is that commit's token. generateHistoryKey
-  // is URL-only, so an A->B->A revisit reuses the key; the token lets a late
+  // is the URL (plus the source page for an intercept), so an A->B->A revisit
+  // reuses the key; the token lets a late
   // resolution tell its own visit apart from a newer same-URL visit, so a stale
   // nav can never clobber a fresher one's live state or cache (P1).
   const myInstance = store.getNavInstance();

package/src/browser/react/filter-segment-order.ts

@@ -33,8 +33,8 @@ export function loaderParentId(id: string): string {
  * 2. Place each parallel slot id (contains ".@") immediately after its
  *    parent layout/route id. Raw segment-resolution emission order does NOT
  *    guarantee this: route-mounted parallels are resolved/pushed BEFORE the
- *    route handler's segment is appended (see fresh.ts:resolveSegment for
- *    routes, and revalidation.ts ~915-919), so matched can read
+ *    route handler's segment is appended (see resolveSegment in
+ *    segment-resolution/revalidation.ts), so matched can read
  *    `[..., R0.@panel, R0]`. collectHandleData consumes segmentOrder verbatim
  *    with later-wins semantics, so without normalization the route handler's
  *    Meta would override the slot's more-specific Meta — backwards.

package/src/browser/rsc-router.tsx

@@ -42,6 +42,7 @@ import { setAppVersion } from "./app-version.js";
 import {
   isInterceptSegment,
   splitInterceptSegments,
+  wholeInterceptMatched,
 } from "./intercept-utils.js";
 import { createAppShellRef } from "./app-shell.js";
 import { bootLog, IS_BROWSER_DEBUG } from "./logging.js";
@@ -75,7 +76,7 @@ export interface InitBrowserAppOptions {
   storeOptions?: {
     /**
      * Maximum number of history entries to cache
-     * @default 10
+     * @default 20
      */
     cacheSize?: number;
   };
@@ -531,6 +532,9 @@ export async function initBrowserApp(
         const streamingToken = handle.startStreaming();
 
         const interceptSourceUrl = store.getInterceptSourceUrl();
+        // Read before a version change below clears the history cache.
+        const onScreen =
+          store.getCachedSegments(store.getHistoryKey())?.segments ?? [];
 
         try {
           const { payload, streamComplete } = await client.fetchPartial({
@@ -582,7 +586,17 @@ export async function initBrowserApp(
           // a paramless document GET would run the SSR path and surface the
           // not-found page during that same transient.
           if (payload.metadata?.isPartial) {
-            const segments = payload.metadata.segments || [];
+            // Held nothing: an intercept answer keeps the page under the slot
+            // from the entry on screen; the layouts and the slot are fresh.
+            let segments = payload.metadata.segments || [];
+            const kept = wholeInterceptMatched(onScreen, payload.metadata);
+            if (kept) {
+              payload.metadata.matched = kept;
+              const byId = new Map(
+                [...onScreen, ...segments].map((s) => [s.id, s]),
+              );
+              segments = kept.flatMap((id) => byId.get(id) ?? []);
+            }
             const matched = payload.metadata.matched || [];
 
             // Derive intercept state from the returned payload, not the
@@ -600,6 +614,7 @@ export async function initBrowserApp(
 
             const historyKey = generateHistoryKey(window.location.href, {
               intercept: responseIsIntercept,
+              interceptSource: interceptSourceUrl ?? undefined,
             });
             store.setHistoryKey(historyKey);
             const currentHandleData = liveHandleDataForCache(

package/src/browser/segment-reconciler.ts

@@ -46,6 +46,60 @@ export interface ReconcileResult {
   interceptSegments: ResolvedSegment[];
 }
 
+/**
+ * A segment the server sent over its cached copy, keeping the cached
+ * structural properties so the React tree keeps its shape. Changing them
+ * between renders alters the element nesting (with/without
+ * RouteContentWrapper, MountContextProvider, etc.), which remounts components
+ * and destroys useActionState.
+ */
+function mergeCached(
+  fromServer: ResolvedSegment,
+  fromCache: ResolvedSegment,
+  actor: ReconcileActor,
+): ResolvedSegment {
+  let merged = fromServer;
+
+  // When server returns component: null for a layout segment, it means
+  // "this segment doesn't need re-rendering" - preserve the cached component
+  // to maintain the outlet chain and prevent React tree changes
+  if (
+    fromServer.component === null &&
+    fromServer.type === "layout" &&
+    fromCache.component != null
+  ) {
+    merged = { ...merged, component: fromCache.component };
+  }
+
+  // Loading preservation is actor-aware:
+  // - action/stale-revalidation: always preserve cached value to prevent
+  //   tree remount (even when cached is undefined, to avoid adding a
+  //   Suspense boundary that wasn't there before)
+  // - navigation: only when cached is defined (building a new tree)
+  if (
+    fromServer.loading !== fromCache.loading &&
+    (actor !== "navigation" || fromCache.loading !== undefined)
+  ) {
+    merged = { ...merged, loading: fromCache.loading };
+  }
+
+  // mountPath: SSR segments may lack mountPath while revalidated segments
+  // include it. The conditional MountContextProvider wrapper changes tree depth.
+  if (fromServer.mountPath !== fromCache.mountPath) {
+    merged = { ...merged, mountPath: fromCache.mountPath };
+  }
+
+  // Dev-mode assertion: warn if the merged result still differs from cache
+  // in tree-structural properties. This catches bugs where the merge code
+  // above fails to preserve a value it should have.
+  assertSegmentStructure(
+    fromCache,
+    merged,
+    actor === "action" ? "action-bridge" : "partial-update",
+  );
+  return merged;
+}
+
 /**
  * Single source of truth for merging server segments with cached segments.
  *
@@ -70,7 +124,6 @@ export interface ReconcileResult {
  */
 export function reconcileSegments(input: ReconcileInput): ReconcileResult {
   const { actor, matched, diff, insertMissingDiff } = input;
-  const context = actor === "action" ? "action-bridge" : "partial-update";
 
   // Build lookup maps from arrays
   const serverSegments = new Map<string, ResolvedSegment>();
@@ -111,59 +164,13 @@ export function reconcileSegments(input: ReconcileInput): ReconcileResult {
 
       if (fromServer) {
         const inDiff = diffSet.has(segId);
-        // Preserve cached structural properties to maintain consistent React tree.
-        // Changing these between renders alters the element nesting
-        // (with/without RouteContentWrapper, MountContextProvider, etc.),
-        // causing React to remount components and destroy useActionState.
         if (fromCache) {
-          let merged = fromServer;
-
-          // When server returns component: null for a layout segment, it means
-          // "this segment doesn't need re-rendering" - preserve the cached component
-          // to maintain the outlet chain and prevent React tree changes
-          if (
-            fromServer.component === null &&
-            fromServer.type === "layout" &&
-            fromCache.component != null
-          ) {
-            merged = { ...merged, component: fromCache.component };
-          }
-
-          // Loading preservation is actor-aware:
-          // - action/stale-revalidation: always preserve cached value to prevent
-          //   tree remount (even when cached is undefined, to avoid adding a
-          //   Suspense boundary that wasn't there before)
-          // - navigation: only when cached is defined (building a new tree)
-          if (actor !== "navigation") {
-            if (fromServer.loading !== fromCache.loading) {
-              merged = { ...merged, loading: fromCache.loading };
-            }
-          } else {
-            if (
-              fromCache.loading !== undefined &&
-              fromServer.loading !== fromCache.loading
-            ) {
-              merged = { ...merged, loading: fromCache.loading };
-            }
-          }
-
-          // mountPath: SSR segments may lack mountPath while revalidated segments
-          // include it. The conditional MountContextProvider wrapper changes tree depth.
-          if (fromServer.mountPath !== fromCache.mountPath) {
-            merged = { ...merged, mountPath: fromCache.mountPath };
-          }
-
-          // Dev-mode assertion: warn if the merged result still differs from cache
-          // in tree-structural properties. This catches bugs where the merge code
-          // above fails to preserve a value it should have.
-          assertSegmentStructure(fromCache, merged, context);
-
           if (IS_BROWSER_DEBUG) {
             debugLog(
               `[reconcile] ${segId}: SERVER+CACHE merge (${inDiff ? "in diff" : "not in diff"}, type=${fromServer.type}, component=${fromServer.component === null ? "null→cached" : "server"})`,
             );
           }
-          return merged;
+          return mergeCached(fromServer, fromCache, actor);
         }
         if (IS_BROWSER_DEBUG) {
           debugLog(
@@ -221,11 +228,13 @@ export function reconcileSegments(input: ReconcileInput): ReconcileResult {
 }
 
 /**
- * Reconcile error segments with cached segments.
+ * Reconcile an error-boundary response with cached segments.
  *
- * For error responses, the server returns the error boundary segment.
- * This function overlays error segments onto the full cached tree,
- * preserving sibling layouts that aren't in the error parent chain.
+ * The server returns the error boundary segment and, above it, what the
+ * action's revalidation re-ran (rsc/server-action.ts). This function overlays
+ * them onto the full cached tree, preserving sibling layouts that aren't in
+ * the error parent chain. The error segment replaces its cached copy; every
+ * other segment merges as an action's does (mergeCached).
  */
 export function reconcileErrorSegments(
   cachedSegments: ResolvedSegment[],
@@ -236,7 +245,11 @@ export function reconcileErrorSegments(
 
   const segments = cachedSegments.map((cached) => {
     const fromServer = errorMap.get(cached.id);
-    return fromServer || cached;
+    return !fromServer
+      ? cached
+      : fromServer.type === "error"
+        ? fromServer
+        : mergeCached(fromServer, cached, "action");
   });
 
   const { main, intercept } = splitInterceptSegments(segments);