@rangojs/router 0.24.4 → 0.25.0

package/src/browser/segment-reconciler.ts

@@ -1,9 +1,5 @@
 import type { ResolvedSegment } from "./types.js";
-import {
-  mergeSegmentLoaders,
-  needsLoaderMerge,
-  insertMissingDiffSegments,
-} from "./merge-segment-loaders.js";
+import { insertMissingDiffSegments } from "./merge-segment-loaders.js";
 import { assertSegmentStructure } from "./segment-structure-assert.js";
 import { splitInterceptSegments } from "./intercept-utils.js";
 import { debugLog, IS_BROWSER_DEBUG } from "./logging.js";
@@ -11,15 +7,17 @@ import { debugLog, IS_BROWSER_DEBUG } from "./logging.js";
 /**
  * Determines the merging behavior for segment reconciliation.
  *
- * - 'action': From server-action-bridge's own merge. Always merges loaders,
- *   always preserves cached loading (even undefined), never clears cached
- *   segment loading.
- * - 'navigation': From partial-update during normal navigation. Does NOT merge
- *   loaders, preserves cached loading only when defined, clears truthy loading
- *   on cached segments not in server diff.
+ * - 'action': From server-action-bridge's own merge. Always preserves cached
+ *   loading (even undefined), never clears cached segment loading.
+ * - 'navigation': From partial-update during normal navigation. Preserves
+ *   cached loading only when defined, clears truthy loading on cached
+ *   segments not in server diff.
  * - 'stale-revalidation': From partial-update during stale revalidation or
- *   action-triggered refetch. Merges loaders, always preserves cached loading
- *   (same as action), clears truthy loading on cached segments not in server diff.
+ *   action-triggered refetch. Always preserves cached loading (same as
+ *   action), clears truthy loading on cached segments not in server diff.
+ *
+ * No actor merges loader data: a loader the server skipped, an intercept's
+ * included, is its own cached segment in `matched`.
  */
 export type ReconcileActor = "navigation" | "action" | "stale-revalidation";
 
@@ -64,11 +62,6 @@ export interface ReconcileResult {
  *   (not undefined). When cached is undefined, lets server value through
  *   because we're building a new tree.
  *
- * Loader merging:
- * - action/stale-revalidation: Merges partial loader data when server returns
- *   fewer loaders than cached (revalidation only updated some loaders).
- * - navigation: Does not merge (full navigation fetches complete data).
- *
  * Cached segment handling (segments in matched but not in server response):
  * - action: Returns cached segment as-is (preserve tree structure).
  * - navigation/stale-revalidation: Clears truthy loading to undefined
@@ -77,7 +70,6 @@ export interface ReconcileResult {
  */
 export function reconcileSegments(input: ReconcileInput): ReconcileResult {
   const { actor, matched, diff, insertMissingDiff } = input;
-  const shouldMergeLoaders = actor !== "navigation";
   const context = actor === "action" ? "action-bridge" : "partial-update";
 
   // Build lookup maps from arrays
@@ -119,16 +111,6 @@ export function reconcileSegments(input: ReconcileInput): ReconcileResult {
 
       if (fromServer) {
         const inDiff = diffSet.has(segId);
-        // Merge partial loader data when server returns fewer loaders than cached
-        if (shouldMergeLoaders && needsLoaderMerge(fromServer, fromCache)) {
-          if (IS_BROWSER_DEBUG) {
-            debugLog(
-              `[reconcile] ${segId}: MERGE loaders (server partial, ${inDiff ? "in diff" : "not in diff"})`,
-            );
-          }
-          return mergeSegmentLoaders(fromServer, fromCache);
-        }
-
         // Preserve cached structural properties to maintain consistent React tree.
         // Changing these between renders alters the element nesting
         // (with/without RouteContentWrapper, MountContextProvider, etc.),

package/src/browser/server-action-bridge.ts

@@ -3,8 +3,10 @@ import type {
   ServerActionBridgeConfig,
   RscPayload,
   ResolvedSegment,
+  NavigationUpdate,
+  UpdateSubscriber,
 } from "./types.js";
-import { createPartialUpdater } from "./partial-update.js";
+import { addTransitionType, createPartialUpdater } from "./partial-update.js";
 import { enterActionFence, exitActionFence } from "./action-fence.js";
 import { KEEP_CACHE_HEADER } from "./cookie-name.js";
 import { createNavigationTransaction } from "./navigation-transaction.js";
@@ -39,6 +41,7 @@ import {
 import { mergeLocationState } from "./history-state.js";
 import { stampLocationState } from "./react/location-state-shared.js";
 import { classifyActionOutcome } from "./action-coordinator.js";
+import { revalidationErrorOf } from "../decode-loader-results.js";
 import { getAppVersion } from "./app-version.js";
 import {
   decideCommitGatedOff,
@@ -99,6 +102,24 @@ function applyActionLocationState(
   }
 }
 
+/**
+ * An action's commit: urgent when transition({ when }) gated it off, like
+ * every gated-off commit, else a transition tagged `action` (#1165).
+ */
+function commitAction(
+  onUpdate: UpdateSubscriber,
+  update: NavigationUpdate,
+  gatedOff: boolean,
+): void {
+  if (gatedOff) onUpdate(update);
+  else
+    startTransition(() => {
+      addTransitionType?.("action");
+      update.inTransition = true;
+      onUpdate(update);
+    });
+}
+
 /**
  * Create a server action bridge for handling RSC server actions
  *
@@ -173,6 +194,7 @@ export function createServerActionBridge(
    * Refetch current route via a navigation transaction.
    * Encapsulates the repeated pattern of creating a navTx + fetchPartialUpdate
    * used by navigated-away, hmr-missing, and consolidation-needed scenarios.
+   * Resolves with the error of a loader that threw on the refetch.
    */
   async function refetchRoute(opts?: {
     segments?: string[];
@@ -180,7 +202,7 @@ export function createServerActionBridge(
     actionId?: string;
     /** transition({ when }) `action` fields for the refetch commit. */
     action?: TransitionWhenActionInput;
-  }): Promise<void> {
+  }): Promise<Error | undefined> {
     const src = opts?.interceptSourceUrl ?? null;
     const navTx = createNavigationTransaction(
       store,
@@ -189,7 +211,7 @@ export function createServerActionBridge(
       { replace: true, skipLoadingState: true },
     );
     try {
-      await fetchPartialUpdate(
+      return await fetchPartialUpdate(
         window.location.href,
         opts?.segments ?? [],
         false,
@@ -302,6 +324,11 @@ export function createServerActionBridge(
       if (rid) {
         url.searchParams.set("_rsc_rid", rid);
       }
+      // The page's rewrite target: the server diffs the re-render against it.
+      const rewriteTarget = store.getHistoryEntryMemory()?.rewriteTarget;
+      if (rewriteTarget) {
+        url.searchParams.set("_rsc_rt", rewriteTarget);
+      }
 
       // Encode arguments
       const encodedBody = await deps.encodeReply(args, { temporaryReferences });
@@ -618,12 +645,13 @@ export function createServerActionBridge(
         );
         store.rememberDisplayedEntry();
 
-        // Update UI with error boundary: urgent when transition({ when })
-        // gated it off, like every gated-off commit.
-        const errorUpdate = { root: errorTree, metadata: metadata! };
+        // Update UI with error boundary.
         if (process.env.NODE_ENV !== "production") auditTreeCause("action");
-        if (errorGatedOff) onUpdate(errorUpdate);
-        else startTransition(() => onUpdate(errorUpdate));
+        commitAction(
+          onUpdate,
+          { root: errorTree, metadata: metadata! },
+          errorGatedOff,
+        );
 
         // Throw the error so the action promise rejects
         if (returnValue && !returnValue.ok) {
@@ -677,6 +705,8 @@ export function createServerActionBridge(
       const fullSegments = reconciled.segments;
 
       const returnData = returnValue?.data;
+      // A loader that threw while it re-ran: reported, not thrown.
+      let revalidationError: Error | undefined;
 
       if (returnValue && !returnValue.ok) {
         handle.fail(returnValue.data);
@@ -754,7 +784,7 @@ export function createServerActionBridge(
           // route. Invalidation is deferred to finalizeAction(); here we only
           // trigger the revalidation refetch (suppressed on keep).
           if (!keepCache) {
-            await refetchRoute({
+            revalidationError = await refetchRoute({
               interceptSourceUrl: store.getInterceptSourceUrl(),
               actionId: id,
               action: whenAction,
@@ -771,7 +801,7 @@ export function createServerActionBridge(
           // resolving last must discharge a directive-free sibling's repair.
           // See the keep row in docs/design/rango-state-cookie.md (the all-keep
           // edge, and the benign re-mark-stale-after-refetch end-state delta).
-          await refetchRoute({
+          revalidationError = await refetchRoute({
             interceptSourceUrl,
             actionId: id,
             action: whenAction,
@@ -794,7 +824,7 @@ export function createServerActionBridge(
           handle.clearConsolidation();
 
           // Ungated on keepCache, same as hmr-missing above (see the keep row).
-          await refetchRoute({
+          revalidationError = await refetchRoute({
             segments: segmentsToSend,
             interceptSourceUrl,
             actionId: id,
@@ -824,6 +854,9 @@ export function createServerActionBridge(
               currentHandleData,
             );
           }
+          // Not rendered: the sibling's refetch reruns these loaders and
+          // reports its own. Resolve when the metadata lands, without waiting
+          // for this answer's loader chunks.
           break;
         }
 
@@ -854,6 +887,7 @@ export function createServerActionBridge(
                 ? reconciled.interceptSegments
                 : undefined,
           });
+          revalidationError = await revalidationErrorOf(segments);
 
           // Re-check if user navigated away (could happen during async renderSegments)
           if (window.location.pathname !== actionStartPathname) {
@@ -891,12 +925,14 @@ export function createServerActionBridge(
             fullSegments,
             currentHandleData,
           );
-          store.rememberDisplayedEntry(metadata?.routeName);
+          store.rememberDisplayedEntry(metadata);
 
-          const actionUpdate = { root: newTree, metadata: metadata! };
           if (process.env.NODE_ENV !== "production") auditTreeCause("action");
-          if (gatedOff) onUpdate(actionUpdate);
-          else startTransition(() => onUpdate(actionUpdate));
+          commitAction(
+            onUpdate,
+            { root: newTree, metadata: metadata! },
+            gatedOff,
+          );
           // Invalidation deferred to finalizeAction() (runs after this caches
           // the fresh segments), suppressed when the action called
           // keepClientCache().
@@ -904,7 +940,7 @@ export function createServerActionBridge(
         }
       }
 
-      handle.complete(returnData);
+      handle.complete(returnData, revalidationError);
       return returnData;
     } catch (error) {
       // What the call rejects with (a revalidation render that threw, a

package/src/browser/types.ts

@@ -36,6 +36,11 @@ export type HandleData = Record<string, Record<string, unknown[]>>;
  */
 export interface RscMetadata {
   pathname: string;
+  /**
+   * Path and search of the URL the route rendered, when middleware rewrote
+   * the request there. Kept per history entry and sent back as `_rsc_rt`.
+   */
+  rewriteTarget?: string;
   segments: ResolvedSegment[];
   /** Router instance ID — the current app's identity. A mismatch with the
    *  client's id (sent as _rsc_rid) is detected server-side and answered with
@@ -248,6 +253,13 @@ export interface TrackedActionState {
 
   /** Result data from the action (preserved after completion) */
   result: unknown | null;
+
+  /**
+   * The error of a loader that threw while it re-ran after this successful
+   * action (the first, when several did). The loader also throws at its
+   * useLoader read, where the nearest error boundary catches it.
+   */
+  revalidationError: unknown | null;
 }
 
 /**
@@ -292,13 +304,24 @@ export interface SegmentState {
   currentSegmentIds: string[];
 }
 
+/**
+ * What a committed payload says about the page it shows, remembered per
+ * history entry (NavigationStore.rememberDisplayedEntry).
+ *
+ * @internal This type is an implementation detail and may change without notice.
+ */
+export interface ShownEntry {
+  readonly routeName?: string;
+  readonly rewriteTarget?: string;
+}
+
 /**
  * What the router remembers about one history entry for transition({ when })
- * (NavigationStore.rememberDisplayedEntry).
+ * and the requests made from it (NavigationStore.rememberDisplayedEntry).
  *
  * @internal This type is an implementation detail and may change without notice.
  */
-export interface HistoryEntryMemory {
+export interface HistoryEntryMemory extends ShownEntry {
   readonly routeName: string | undefined;
   /** The entry's `history.state` as last recorded. */
   readonly state: unknown;
@@ -326,6 +349,12 @@ export interface NavigationUpdate {
     /** Function to check if streaming is in progress */
     isStreaming?: () => boolean;
   };
+  /**
+   * Handed to React inside startTransition (commitInTransition, an action's
+   * commit, a cached back/forward's): NavigationProvider joins the route
+   * state that arrives while React holds it to its commit.
+   */
+  inTransition?: true;
 }
 
 /**
@@ -587,12 +616,12 @@ export interface NavigationStore {
   /**
    * Per-history-entry memory for transition({ when }) sources: record the
    * entry on screen (keyed by its `history.state.key`) with its current
-   * `history.state` and, when given, its route name (kept from the last
-   * record otherwise; every push/replace creates a new key, so a stale name
-   * never carries to another entry). Called after every commit, restore and
-   * state merge.
+   * `history.state` and, when `shown` is given, its route name and rewrite
+   * target (both kept from the last record otherwise; every push/replace
+   * creates a new key, so a stale record never carries to another entry).
+   * Called after every commit, restore and state merge.
    */
-  rememberDisplayedEntry(routeName?: string): void;
+  rememberDisplayedEntry(shown?: ShownEntry): void;
   /**
    * The memory of the entry on screen, or of `entryKey`. At popstate
    * history.state already belongs to the destination, so back/forward reads
@@ -683,6 +712,8 @@ export interface FetchPartialOptions {
   targetUrl: string;
   segmentIds: string[];
   previousUrl: string;
+  /** The page's RscMetadata.rewriteTarget, sent as `_rsc_rt`. */
+  rewriteTarget?: string;
   signal?: AbortSignal;
   /** If true, this is a stale cache revalidation request - server should force revalidators */
   staleRevalidation?: boolean;
@@ -772,7 +803,8 @@ export interface ServerActionBridgeConfig {
 export interface NavigationBridge {
   navigate(url: string, options?: NavigateOptionsInternal): Promise<void>;
   refresh(): Promise<void>;
-  handlePopstate(): Promise<void>;
+  /** `event`: the popstate event; a traversal the browser animated itself (hasUAVisualTransition) is not animated again. */
+  handlePopstate(event?: PopStateEvent): Promise<void>;
   registerLinkInterception(): () => void;
   registerDelegatedPrefetch(): () => void;
   /** Current RSC version (live, reflects the latest updateVersion). */

package/src/build/generate-manifest.ts

@@ -16,7 +16,11 @@ import {
   RangoContext,
   runWithPrefixes,
 } from "../server/context.js";
-import type { EntryData, TrackedInclude } from "../server/context.js";
+import type {
+  EntryData,
+  IncludeScopePosition,
+  TrackedInclude,
+} from "../server/context.js";
 import type { TrailingSlashMode } from "../types.js";
 import { createRouteHelpers } from "../route-definition.js";
 import MapRootLayout from "../server/root-layout.js";
@@ -179,6 +183,7 @@ async function buildPrefixTreeNode(
   routeSearchSchemas?: Record<string, Record<string, string>>,
   routerId?: string,
   validateTransitionWhen?: boolean,
+  position?: IncludeScopePosition,
 ): Promise<PrefixTreeNode> {
   // Resolve an async include provider (`() => import("./routes")`) so its routes
   // are walked into the build-time manifest/types/href. Runtime matching still
@@ -222,6 +227,10 @@ async function buildPrefixTreeNode(
         mountIndex,
         ...(routerId ? { routerId } : {}),
         trackedIncludes, // Enable nested include tracking
+        // The same position runtime expansion runs this include at
+        // (lazy-includes.ts), so nested hidden names agree across realms.
+        scopePath: position?.scopePath,
+        hiddenScopePath: position?.hiddenScopePath,
       },
       () => {
         const helpers = createRouteHelpers();
@@ -304,6 +313,7 @@ async function buildPrefixTreeNode(
         routeSearchSchemas,
         routerId,
         validateTransitionWhen,
+        include,
       ),
     );
 
@@ -505,6 +515,7 @@ export async function generateManifestFull<TEnv>(
       routeSearchSchemas,
       options?.routerId,
       options?.validateTransitionWhen,
+      include,
     ),
   );
 

package/src/build/route-types/codegen.ts

@@ -48,7 +48,11 @@ export function generatePerModuleTypesSource(
     }
     deduped.set(name, { pattern, params, search });
   }
-  const sorted = [...deduped.entries()].sort(([a], [b]) => a.localeCompare(b));
+  // Locale pinned: the machine's default locale reorders names (Czech sorts
+  // "ch" after "h"), and generated files must be identical on every machine.
+  const sorted = [...deduped.entries()].sort(([a], [b]) =>
+    a.localeCompare(b, "en"),
+  );
   const body = sorted
     .map(([name, { pattern, params, search }]) => {
       const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
@@ -69,7 +73,7 @@ export function generateRouteTypesSource(
 ): string {
   const entries = Object.entries(routeManifest)
     .filter(([name]) => !isAutoGeneratedRouteName(name))
-    .sort(([a], [b]) => a.localeCompare(b));
+    .sort(([a], [b]) => a.localeCompare(b, "en"));
 
   const filteredSearchSchemas = searchSchemas
     ? Object.fromEntries(

package/src/build/route-types/per-module-writer.ts

@@ -62,70 +62,107 @@ export function findUrlsVariableNames(code: string): string[] {
   return names;
 }
 
+export interface PerModuleRouteTypesPlan {
+  genPath: string;
+  /** A urls()/clientUrls() variable resolved to zero routes; content is empty. */
+  isPlaceholder: boolean;
+  content: string;
+}
+
 /**
- * Generate per-module route types for a single url module file.
- * Follows include() calls recursively to produce the full route tree.
- * No-ops if the file doesn't contain `urls(`/`clientUrls(` or has no named
- * routes.
+ * Pure half of the per-module writer: reads sources, never writes. Returns
+ * null when the file has no `urls(`/`clientUrls(` or no named routes and no
+ * urls() variable. Throws on failure.
  */
-export function writePerModuleRouteTypesForFile(filePath: string): void {
-  try {
-    const source = readFileSync(filePath, "utf-8");
-    if (!source.includes("urls(") && !source.includes("clientUrls(")) return;
+export function planPerModuleRouteTypesForFile(
+  filePath: string,
+): PerModuleRouteTypesPlan | null {
+  const source = readFileSync(filePath, "utf-8");
+  if (!source.includes("urls(") && !source.includes("clientUrls(")) return null;
 
-    const varNames = findUrlsVariableNames(source);
+  const varNames = findUrlsVariableNames(source);
 
-    type Route = {
-      name: string;
-      pattern: string;
-      params?: Record<string, string>;
-      search?: Record<string, string>;
-    };
-    let routes: Route[];
+  type Route = {
+    name: string;
+    pattern: string;
+    params?: Record<string, string>;
+    search?: Record<string, string>;
+  };
+  let routes: Route[];
 
-    if (varNames.length > 0) {
-      // Follow includes recursively via the combined route map builder.
-      // The visited set in buildCombinedRouteMapWithSearch prevents infinite loops.
-      // Share one per-file scan memo across all urls() variables so a shared
-      // include target is read+parsed once for this file, not once per variable.
-      routes = [];
-      const memo = createScanMemo();
-      for (const varName of varNames) {
-        const { routes: routeMap, searchSchemas } =
-          buildCombinedRouteMapWithSearch(
-            filePath,
-            varName,
-            undefined,
-            undefined,
-            undefined,
-            memo,
-          );
-        for (const [name, pattern] of Object.entries(routeMap)) {
-          const params = extractParamsFromPattern(pattern);
-          routes.push({
-            name,
-            pattern,
-            ...(params ? { params } : {}),
-            ...(searchSchemas[name] ? { search: searchSchemas[name] } : {}),
-          });
-        }
+  if (varNames.length > 0) {
+    // Follow includes recursively via the combined route map builder.
+    // The visited set in buildCombinedRouteMapWithSearch prevents infinite loops.
+    // Share one per-file scan memo across all urls() variables so a shared
+    // include target is read+parsed once for this file, not once per variable.
+    routes = [];
+    const memo = createScanMemo();
+    for (const varName of varNames) {
+      const { routes: routeMap, searchSchemas } =
+        buildCombinedRouteMapWithSearch(
+          filePath,
+          varName,
+          undefined,
+          undefined,
+          undefined,
+          memo,
+        );
+      for (const [name, pattern] of Object.entries(routeMap)) {
+        const params = extractParamsFromPattern(pattern);
+        routes.push({
+          name,
+          pattern,
+          ...(params ? { params } : {}),
+          ...(searchSchemas[name] ? { search: searchSchemas[name] } : {}),
+        });
       }
-    } else {
-      // Fallback: no urls() variable found, extract path() calls directly
-      routes = extractRoutesFromSource(source);
     }
+  } else {
+    // Fallback: no urls() variable found, extract path() calls directly
+    routes = extractRoutesFromSource(source);
+  }
+
+  // Match .ts/.tsx/.js/.jsx (same as router-processing.ts / router-transform.ts).
+  // Without the jsx? branch a .jsx/.js source produced genPath === filePath,
+  // overwriting the source file instead of writing a sibling .gen.ts.
+  const genPath = filePath.replace(/\.(tsx?|jsx?)$/, ".gen.ts");
 
-    // Match .ts/.tsx/.js/.jsx (same as router-processing.ts / router-transform.ts).
-    // Without the jsx? branch a .jsx/.js source produced genPath === filePath,
-    // overwriting the source file instead of writing a sibling .gen.ts.
-    const genPath = filePath.replace(/\.(tsx?|jsx?)$/, ".gen.ts");
+  if (routes.length === 0) {
+    if (varNames.length === 0) return null;
+    return {
+      genPath,
+      isPlaceholder: true,
+      content: generatePerModuleTypesSource([]),
+    };
+  }
+  return {
+    genPath,
+    isPlaceholder: false,
+    content: generatePerModuleTypesSource(routes),
+  };
+}
+
+/**
+ * Generate per-module route types for a single url module file.
+ * Follows include() calls recursively to produce the full route tree.
+ * No-ops if the file doesn't contain `urls(`/`clientUrls(` or has no named
+ * routes.
+ */
+export function writePerModuleRouteTypesForFile(filePath: string): void {
+  try {
+    const plan = planPerModuleRouteTypesForFile(filePath);
+    if (!plan) return;
+    const { genPath, isPlaceholder, content } = plan;
+    const exists = existsSync(genPath);
 
-    // When a urls() variable was found but static resolution yields zero
-    // routes, write an empty placeholder so generated imports stay
-    // resolvable until runtime discovery fills them in.
-    if (routes.length === 0) {
-      if (varNames.length > 0 && !existsSync(genPath)) {
-        writeFileSync(genPath, generatePerModuleTypesSource([]));
+    // A urls() variable whose static resolution yields zero routes gets an
+    // empty placeholder so an import of the sibling .gen.ts resolves. Nothing
+    // fills it in later: runtime discovery writes only *.named-routes.gen.ts
+    // (runtime-discovery.ts), so it stays `routes = {}` until a static run can
+    // resolve the module's includes and overwrites it.
+    if (isPlaceholder) {
+      if (!exists) {
+        writeFileSync(genPath, content);
         console.log(
           `[rango] Generated route types (placeholder) -> ${genPath}`,
         );
@@ -133,12 +170,8 @@ export function writePerModuleRouteTypesForFile(filePath: string): void {
       return;
     }
 
-    const genSource = generatePerModuleTypesSource(routes);
-    const existing = existsSync(genPath)
-      ? readFileSync(genPath, "utf-8")
-      : null;
-    if (existing !== genSource) {
-      writeFileSync(genPath, genSource);
+    if (!exists || readFileSync(genPath, "utf-8") !== content) {
+      writeFileSync(genPath, content);
       console.log(`[rango] Generated route types -> ${genPath}`);
     }
   } catch (err) {

package/src/cache/cache-runtime.ts

@@ -508,6 +508,15 @@ export function registerCachedFunction<T extends (...args: any[]) => any>(
           if (ctx._routeName) {
             keyArgs.push(ctx._routeName);
           }
+          // A layout's / parallel's / their loader's ctx resolves dot names
+          // in its own module (withReverseScope), so one route's segments
+          // can reverse the same name differently.
+          const scope = ctx._reverseScope;
+          if (scope) {
+            keyArgs.push(
+              `reverse-scope:${scope.prefix ?? ""}:${scope.rootScoped}`,
+            );
+          }
           keyArgs.push(ctx.pathname, ctx.params);
           if (ctx._responseType) {
             keyArgs.push(ctx._responseType);

package/src/cache/cache-scope.ts

@@ -24,6 +24,7 @@ import {
   runInSegmentTagScope,
 } from "./cache-tag.js";
 import { reportCacheError } from "./cache-error.js";
+import { isInterceptSegment } from "../browser/intercept-utils.js";
 import {
   predatesInvalidation,
   type ExecutionStart,
@@ -373,7 +374,7 @@ export class CacheScope {
       const next = id.charCodeAt(boundary.length);
       return !(next >= 48 && next <= 57);
     }
-    return namespace?.startsWith("intercept:") === true;
+    return isInterceptSegment({ namespace });
   }
 
   /**

package/src/cache/cf/cf-cache-store.ts

@@ -422,6 +422,7 @@ function shellHeadToEntry(head: ShellFrameHead): ShellEntryHead {
     reactVersion: head.rv,
     buildVersion: head.bv,
     initialTheme: head.i,
+    pathname: head.lp,
     docKey: head.dk,
     prunedRecords: head.pr,
     navigationOnly: head.no,
@@ -2695,6 +2696,7 @@ export class CFCacheStore<TEnv = unknown> implements SegmentCacheStore<TEnv> {
           t: tags,
           ta: taggedAt,
           i: entry.initialTheme,
+          lp: entry.pathname,
           dk: entry.docKey,
           pr: entry.prunedRecords,
           no: entry.navigationOnly,