polyrouter 1.0.13 → 1.0.15

package/app/node_modules/next/dist/client/components/segment-cache/navigation-testing-lock.js

@@ -23,16 +23,14 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     beginLockedNavigation: null,
     beginNavigationLockPrefetch: null,
-    finishNavigationLockPrefetchSpawning: null,
     getCurrentNavigationGate: null,
-    getCurrentNavigationLock: null,
+    getNavigationLockSegmentCacheMap: null,
     getPreLockFetch: null,
     isNavigationLocked: null,
-    recordNavigationLockOwnedEntry: null,
     resetNavigationLockToPending: null,
+    resolveNavigationLockPrefetch: null,
     shouldRestrictNavigationToShell: null,
     startListeningForInstantNavigationCookie: null,
-    trackNavigationLockPrefetchEntry: null,
     updateCapturedSPAToTree: null
 });
 function _export(target, all) {
@@ -48,14 +46,11 @@ _export(exports, {
     beginNavigationLockPrefetch: function() {
         return beginNavigationLockPrefetch;
     },
-    finishNavigationLockPrefetchSpawning: function() {
-        return finishNavigationLockPrefetchSpawning;
-    },
     getCurrentNavigationGate: function() {
         return getCurrentNavigationGate;
     },
-    getCurrentNavigationLock: function() {
-        return getCurrentNavigationLock;
+    getNavigationLockSegmentCacheMap: function() {
+        return getNavigationLockSegmentCacheMap;
     },
     getPreLockFetch: function() {
         return getPreLockFetch;
@@ -63,21 +58,18 @@ _export(exports, {
     isNavigationLocked: function() {
         return isNavigationLocked;
     },
-    recordNavigationLockOwnedEntry: function() {
-        return recordNavigationLockOwnedEntry;
-    },
     resetNavigationLockToPending: function() {
         return resetNavigationLockToPending;
     },
+    resolveNavigationLockPrefetch: function() {
+        return resolveNavigationLockPrefetch;
+    },
     shouldRestrictNavigationToShell: function() {
         return shouldRestrictNavigationToShell;
     },
     startListeningForInstantNavigationCookie: function() {
         return startListeningForInstantNavigationCookie;
     },
-    trackNavigationLockPrefetchEntry: function() {
-        return trackNavigationLockPrefetchEntry;
-    },
     updateCapturedSPAToTree: function() {
         return updateCapturedSPAToTree;
     }
@@ -86,7 +78,7 @@ const _approutertypes = require("../../../shared/lib/app-router-types");
 const _approuterheaders = require("../app-router-headers");
 const _useactionqueue = require("../use-action-queue");
 const _scheduler = require("./scheduler");
-const _cache = require("./cache");
+const _cachemap = require("./cache-map");
 function parseCookieValue(raw) {
     if (raw === '') {
         return 'empty';
@@ -154,48 +146,21 @@ function beginNavigationLockPrefetch() {
         });
         const prefetch = {
             promise,
-            resolve: resolve,
-            pendingCount: 1,
-            trackedEntries: new Set()
+            resolve: resolve
         };
         lockState.activePrefetches.add(prefetch);
         return prefetch;
     }
     return null;
 }
-function recordNavigationLockOwnedEntry(entry) {
-    if (lockState !== null) {
-        lockState.ownedEntries.add(entry);
-    }
+function getNavigationLockSegmentCacheMap() {
+    return lockState !== null ? lockState.segmentCacheMap : null;
 }
-function trackNavigationLockPrefetchEntry(prefetch, entry) {
-    if (prefetch.trackedEntries.has(entry)) {
-        return;
-    }
-    prefetch.trackedEntries.add(entry);
-    prefetch.pendingCount++;
-    const onSettled = ()=>{
-        prefetch.pendingCount--;
-        settleNavigationLockPrefetchIfDrained(prefetch);
-    };
-    // Decrement whether the entry fulfills or its request rejects, so a failed
-    // segment can't leave the navigation waiting forever.
-    (0, _cache.waitForSegmentCacheEntry)(entry).then(onSettled, onSettled);
-}
-function finishNavigationLockPrefetchSpawning(prefetch) {
-    prefetch.pendingCount--;
-    settleNavigationLockPrefetchIfDrained(prefetch);
-}
-function settleNavigationLockPrefetchIfDrained(prefetch) {
-    if (prefetch.pendingCount === 0) {
-        // Unregister from the lock (if still held) and resolve. Resolving is
-        // idempotent, so it's safe even if the lock already force-resolved this on
-        // release.
-        if (lockState !== null) {
-            lockState.activePrefetches.delete(prefetch);
-        }
-        prefetch.resolve();
+function resolveNavigationLockPrefetch(prefetch) {
+    if (lockState !== null) {
+        lockState.activePrefetches.delete(prefetch);
     }
+    prefetch.resolve();
 }
 function acquireLock() {
     if (lockState !== null) {
@@ -214,7 +179,7 @@ function acquireLock() {
         resolveReleased: resolveReleased,
         fetch: window.fetch,
         activePrefetches: new Set(),
-        ownedEntries: new Set(),
+        segmentCacheMap: (0, _cachemap.createCacheMap)(),
         currentNavigation,
         resolveCurrentNavigation: resolveCurrentNavigation
     };
@@ -434,9 +399,6 @@ function isNavigationLocked() {
     }
     return false;
 }
-function getCurrentNavigationLock() {
-    return lockState;
-}
 function getCurrentNavigationGate() {
     return lockState !== null ? lockState.currentNavigation : null;
 }

package/app/node_modules/next/dist/client/components/segment-cache/navigation.js

@@ -52,6 +52,8 @@ const _computechangedpath = require("../router-reducer/compute-changed-path");
 const _javascripturl = require("../../lib/javascript-url");
 const _bfcache = require("./bfcache");
 const _instantmessages = require("../../../shared/lib/instant-messages");
+const _matchsegments = require("../match-segments");
+const _segment = require("../../../shared/lib/segment");
 function navigate(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType) {
     let navigationLock = null;
     // Instant Navigation Testing API: when the lock is active, ensure a
@@ -71,16 +73,19 @@ function navigate(state, url, currentUrl, currentRenderedSearch, currentCacheNod
             return ensurePrefetchThenNavigate(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType, navigationLock);
         }
     }
-    return navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType, navigationLock);
+    return navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType, navigationLock, // An unlocked navigation is bound to the shared map.
+    _cache.segmentCacheMap);
 }
-function navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType, navigationLock) {
+function navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType, navigationLock, // The segment cache map this navigation is bound to: a locked navigation's
+// driving-task map, or the shared map. See `segmentCacheMap` in cache.ts.
+map) {
     const now = Date.now();
     const href = url.href;
     const cacheKey = (0, _cachekey.createCacheKey)(href, nextUrl);
     const route = (0, _cache.readRouteCacheEntry)(now, cacheKey);
     if (route !== null && route.status === _cache.EntryStatus.Fulfilled) {
         // We have a matching prefetch.
-        return navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, route, navigationLock);
+        return navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, route, navigationLock, map);
     }
     // There was no matching route tree in the cache. Let's see if we can
     // construct an "optimistic" route tree using the deprecated search-params
@@ -98,7 +103,7 @@ function navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCach
             const optimisticRoute = (0, _cache.deprecated_requestOptimisticRouteCacheEntry)(now, url, nextUrl);
             if (optimisticRoute !== null) {
                 // We have an optimistic route tree. Proceed with the normal flow.
-                return navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, optimisticRoute, navigationLock);
+                return navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, optimisticRoute, navigationLock, map);
             }
         }
     }
@@ -107,12 +112,14 @@ function navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCach
     //
     // TODO: If this is a gesture navigation, instead of performing a
     // dynamic request, we should do a runtime prefetch.
-    return navigateToUnknownRoute(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, navigationLock).catch(()=>{
+    return navigateToUnknownRoute(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, navigationLock, map).catch(()=>{
         // If the navigation fails, return the current state
         return state;
     });
 }
-function navigateToKnownRoute(now, state, url, canonicalUrl, navigationSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, navigationLock, debugInfo, // The route cache entry used for this navigation, if it came from route
+function navigateToKnownRoute(now, state, url, canonicalUrl, navigationSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, navigationLock, // The segment cache map this navigation is bound to: a locked navigation's
+// driving-task map, or the shared map. See `segmentCacheMap` in cache.ts.
+map, debugInfo, // The route cache entry used for this navigation, if it came from route
 // prediction. Passed through so it can be marked as having a dynamic rewrite
 // if the server returns a different pathname (indicating dynamic rewrite
 // behavior).
@@ -189,17 +196,17 @@ routeCacheEntry, signal) {
     // data. If the page segment is fully static and prefetched, the request is
     // skipped. (This is also how refresh() works.)
     const isSamePageNavigation = url.href === currentUrl.href;
-    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, navigationSeed.routeTree, navigationSeed.metadataVaryPath, freshnessPolicy, navigationSeed.data, navigationSeed.head, navigationSeed.dynamicStaleAt, isSamePageNavigation, accumulation, restrictToShell);
+    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, navigationSeed.routeTree, navigationSeed.metadataVaryPath, freshnessPolicy, navigationSeed.data, navigationSeed.head, navigationSeed.dynamicStaleAt, isSamePageNavigation, accumulation, map, restrictToShell);
     if (task !== null) {
         if (freshnessPolicy !== _pprnavigations.FreshnessPolicy.Gesture) {
-            (0, _pprnavigations.spawnDynamicRequests)(task, url, nextUrl, freshnessPolicy, accumulation, routeCacheEntry, navigateType, navigationLock, signal);
+            (0, _pprnavigations.spawnDynamicRequests)(task, url, nextUrl, freshnessPolicy, accumulation, routeCacheEntry, navigateType, navigationLock, map, signal);
         }
         return completeSoftNavigation(state, url, nextUrl, task.route, task.node, navigationSeed.renderedSearch, canonicalUrl, navigateType, scrollBehavior, accumulation.scrollRef, debugInfo);
     }
     // Could not perform a SPA navigation. Revert to a full-page (MPA) navigation.
     return completeHardNavigation(state, url, navigateType);
 }
-function navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, route, navigationLock) {
+function navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, route, navigationLock, map) {
     const routeTree = route.tree;
     const canonicalUrl = route.canonicalUrl + url.hash;
     const renderedSearch = route.renderedSearch;
@@ -209,9 +216,11 @@ function navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRe
         metadataVaryPath: route.metadata.varyPath,
         data: null,
         head: null,
-        dynamicStaleAt: (0, _bfcache.computeDynamicStaleAt)(now, _bfcache.UnknownDynamicStaleTime)
+        dynamicStaleAt: (0, _bfcache.computeDynamicStaleAt)(now, _bfcache.UnknownDynamicStaleTime),
+        // Not derived from a server response; no base to diverge from.
+        treeDivergedFromBase: false
     };
-    return navigateToKnownRoute(now, state, url, canonicalUrl, prefetchSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, navigationLock, null, route, // Not an HMR refresh, so there's no request generation to cancel.
+    return navigateToKnownRoute(now, state, url, canonicalUrl, prefetchSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, navigationLock, map, null, route, // Not an HMR refresh, so there's no request generation to cancel.
     undefined);
 }
 // Used to request all the dynamic data for a route, rather than just a subset,
@@ -225,7 +234,7 @@ const DynamicRequestTreeForEntireRoute = [
     null,
     'refetch'
 ];
-async function navigateToUnknownRoute(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, navigationLock) {
+async function navigateToUnknownRoute(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, navigationLock, map) {
     // Runs when a navigation happens but there's no cached prefetch we can use.
     // Don't bother to wait for a prefetch response; go straight to a full
     // navigation that contains both static and dynamic data in a single stream.
@@ -290,7 +299,7 @@ async function navigateToUnknownRoute(now, state, url, currentUrl, currentRender
                 // Intentionally holding off on doing this until we decide how the
                 // Cached Navigations behavior should work in combination with App
                 // Shells.
-                (0, _cache.writePrerenderResponseIntoCache)(now, _types.FetchStrategy.PPR, staticStageResponse.f, buildId, staticStageResponse.h, staticStageResponse.r ?? null, staleAt, currentFlightRouterState, renderedSearch, isResponsePartial);
+                (0, _cache.writePrerenderResponseIntoCache)(now, _types.FetchStrategy.PPR, staticStageResponse.f, buildId, staticStageResponse.h, staticStageResponse.r ?? null, staleAt, currentFlightRouterState, renderedSearch, isResponsePartial, map);
             }).catch(()=>{
             // The static stage processing failed. Not fatal — the navigation
             // completed normally, we just won't write into the cache.
@@ -299,7 +308,7 @@ async function navigateToUnknownRoute(now, state, url, currentUrl, currentRender
         if (runtimePrefetchStream !== null) {
             (0, _cache.processRuntimePrefetchStream)(now, runtimePrefetchStream, currentFlightRouterState, renderedSearch).then((processed)=>{
                 if (processed !== null) {
-                    (0, _cache.writeDynamicRenderResponseIntoCache)(now, _types.FetchStrategy.PPRRuntime, processed.flightDatas, processed.buildId, processed.isResponsePartial, processed.headVaryParams, processed.rootVaryParamsIterable, processed.staleAt, processed.navigationSeed, null);
+                    (0, _cache.writeDynamicRenderResponseIntoCache)(now, _types.FetchStrategy.PPRRuntime, processed.flightDatas, processed.buildId, processed.isResponsePartial, processed.headVaryParams, processed.rootVaryParamsIterable, processed.staleAt, processed.navigationSeed, null, map);
                 }
             }).catch(()=>{
             // The runtime prefetch cache write failed. Not fatal — the
@@ -321,7 +330,7 @@ async function navigateToUnknownRoute(now, state, url, currentUrl, currentRender
     if (result.revealAfter !== null) {
         await result.revealAfter;
     }
-    return navigateToKnownRoute(now, state, url, (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl), navigationSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, navigationLock, debugInfo, // Unknown route navigations don't use route prediction - the route tree
+    return navigateToKnownRoute(now, state, url, (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl), navigationSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, navigationLock, map, debugInfo, // Unknown route navigations don't use route prediction - the route tree
     // came directly from the server. If a mismatch occurs during dynamic data
     // fetch, the retry handler will traverse the known route tree to mark the
     // entry as having a dynamic rewrite.
@@ -513,8 +522,16 @@ function convertServerPatchToFullTree(now, currentTree, flightData, renderedSear
     let baseTree = currentTree;
     let baseData = null;
     let head = null;
+    // Whether any patch rendered a segment whose identity differs from the base
+    // (request) tree at the same position. See NavigationSeed.treeDivergedFromBase.
+    // Compared against the original `currentTree`, not the progressively-merged
+    // `baseTree`, so each patch is checked against what was actually requested.
+    let treeDivergedFromBase = false;
     if (flightData !== null) {
         for (const { segmentPath, tree: treePatch, seedData: dataPatch, head: headPatch } of flightData){
+            if (!treeDivergedFromBase) {
+                treeDivergedFromBase = didServerPatchDivergeFromBase(currentTree, segmentPath, treePatch);
+            }
             const result = convertServerPatchToFullTreeImpl(baseTree, baseData, treePatch, dataPatch, segmentPath, renderedSearch, 0);
             baseTree = result.tree;
             baseData = result.data;
@@ -530,7 +547,8 @@ function convertServerPatchToFullTree(now, currentTree, flightData, renderedSear
     // only. The RouteTree type will become the main type used for dealing with
     // routes on the client, and we'll store it in the state directly.
     const acc = {
-        metadataVaryPath: null
+        metadataVaryPath: null,
+        treeDivergedFromBase: false
     };
     const routeTree = (0, _cache.convertRootFlightRouterStateToRouteTree)(finalFlightRouterState, renderedSearch, acc);
     return {
@@ -539,9 +557,80 @@ function convertServerPatchToFullTree(now, currentTree, flightData, renderedSear
         data: baseData,
         renderedSearch,
         head,
-        dynamicStaleAt: (0, _bfcache.computeDynamicStaleAt)(now, dynamicStaleTimeSeconds)
+        dynamicStaleAt: (0, _bfcache.computeDynamicStaleAt)(now, dynamicStaleTimeSeconds),
+        treeDivergedFromBase
     };
 }
+// Whether a server patch's rendered tree diverges in segment identity from the
+// base (request) tree it was applied to. Mirrors the comparison performed while
+// decoding a server response in newer versions of the client (see
+// NavigationSeed.treeDivergedFromBase). Divergence means the server rendered a
+// different route than the one we requested — e.g. a URL rewrite that behaves
+// dynamically — so a prefetch built from the base tree can never be fulfilled.
+//
+// The base-tree descent mirrors convertServerPatchToFullTreeImpl: segmentPath
+// is a repeating [parallelRouteKey, segment, ...] pattern; segmentPath[i] keys
+// into the children, segmentPath[i + 1] is the server's segment at that
+// position.
+function didServerPatchDivergeFromBase(currentTree, segmentPath, treePatch) {
+    let baseNode = currentTree;
+    for(let i = 0; i + 1 < segmentPath.length; i += 2){
+        const parallelRouteKey = segmentPath[i];
+        const serverSegment = segmentPath[i + 1];
+        const childBase = baseNode[1][parallelRouteKey];
+        if (childBase === undefined) {
+            // The base tree doesn't have this branch. Unless the server merely
+            // filled it with a default, the trees have different structures.
+            return serverSegment !== _segment.DEFAULT_SEGMENT_KEY;
+        }
+        if (segmentIdentityDivergesFromBase(serverSegment, childBase[0])) {
+            return true;
+        }
+        baseNode = childBase;
+    }
+    return detectTreeDivergenceFromBase(treePatch, baseNode);
+}
+// Recursively compares a server-rendered subtree against the base subtree at
+// the same position. Inactive parallel route branches — which carry a refresh
+// state in the base — are expected to differ and are skipped.
+function detectTreeDivergenceFromBase(serverNode, baseNode) {
+    if (segmentIdentityDivergesFromBase(serverNode[0], baseNode[0])) {
+        return true;
+    }
+    const serverChildren = serverNode[1];
+    const baseChildren = baseNode[1];
+    for(const parallelRouteKey in serverChildren){
+        const childServer = serverChildren[parallelRouteKey];
+        const childBase = baseChildren[parallelRouteKey];
+        if (childBase === undefined) {
+            // A slot the base tree doesn't have. Unless the server merely filled it
+            // with a default, the trees have different structures.
+            if (childServer[0] !== _segment.DEFAULT_SEGMENT_KEY) {
+                return true;
+            }
+        } else if ((childBase[2] ?? null) !== null) {
+        // The base branch carries a refresh state: an inactive parallel route
+        // reused from a different route (e.g. a "default" slot). The server's
+        // answer is expected to differ, so skip the branch.
+        } else if (detectTreeDivergenceFromBase(childServer, childBase)) {
+            return true;
+        }
+    }
+    return false;
+}
+// Whether two segments at the same position claim different identities. Page
+// segments match modulo embedded search params (validated separately, see
+// getRenderedSearch), and a default filled in by the server is not a claim
+// about the position's identity.
+function segmentIdentityDivergesFromBase(serverSegment, baseSegment) {
+    if (typeof serverSegment === 'string' && typeof baseSegment === 'string' && serverSegment.startsWith(_segment.PAGE_SEGMENT_KEY) && baseSegment.startsWith(_segment.PAGE_SEGMENT_KEY)) {
+        return false;
+    }
+    if (serverSegment === _segment.DEFAULT_SEGMENT_KEY) {
+        return false;
+    }
+    return !(0, _matchsegments.matchSegment)(baseSegment, serverSegment);
+}
 function convertServerPatchToFullTreeImpl(baseRouterState, baseData, treePatch, dataPatch, segmentPath, renderedSearch, index) {
     if (index === segmentPath.length) {
         // We reached the part of the tree that we need to patch.
@@ -650,18 +739,21 @@ function convertServerPatchToFullTreeImpl(baseRouterState, baseData, treePatch,
     const cacheKey = (0, _cachekey.createCacheKey)(url.href, nextUrl);
     // Create this navigation's "wait for prefetch to fulfill" state and schedule
     // the prefetch as a locked-navigation prefetch. The prefetch's promise
-    // resolves once it has spawned every request and all of them have fulfilled,
-    // so the navigation below reads present data rather than a still-in-flight
-    // entry.
+    // resolves when the task completes — after every segment response the task
+    // cares about has settled — so the navigation below reads present data
+    // rather than a still-in-flight entry.
     const { beginNavigationLockPrefetch } = require('./navigation-testing-lock');
     const navigationLockPrefetch = beginNavigationLockPrefetch();
-    (0, _scheduler.schedulePrefetchTask)(cacheKey, currentFlightRouterState, fetchStrategy, _types.PrefetchPriority.Default, null, navigationLockPrefetch);
+    const prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, currentFlightRouterState, fetchStrategy, _types.PrefetchPriority.Default, null, navigationLockPrefetch);
     if (navigationLockPrefetch !== null) {
         await navigationLockPrefetch.promise;
     }
     // Prefetch is complete. Proceed with the normal navigation flow, which
-    // will now find the route in the cache.
-    const result = await navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType, navigationLock);
+    // will now find the route in the cache. The navigation inherits the map of
+    // the prefetch task that drives it: the task was scheduled inside the lock
+    // scope, so this is the scope's private map, and the navigation reads only
+    // data fetched under the lock.
+    const result = await navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType, navigationLock, prefetchTask.segmentCacheMap);
     // Only transition to captured-SPA once the navigation is known to be an SPA.
     // If the result is an MPA navigation, leave the cookie pending and let the new
     // document load transition it to captured-MPA.

package/app/node_modules/next/dist/client/components/segment-cache/optimistic-routes.js

@@ -98,7 +98,8 @@ function createEmptyPart() {
         dynamicChild: null,
         dynamicChildParamName: null,
         dynamicChildParamType: null,
-        pattern: null
+        pattern: null,
+        hasConflictingDynamicChildren: false
     };
 }
 // The root of the known route tree.
@@ -134,9 +135,11 @@ function discoverKnownRoute(now, pathname, search, nextUrl, pendingEntry, routeT
     return (0, _cache.writeRouteIntoCache)(now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
 }
 /**
- * Gets or creates the dynamic child node for a KnownRoutePart.
- * A node can have at most one dynamic child (you can't have both [slug] and
- * [id] at the same route level), so we either return existing or create new.
+ * Gets or creates the dynamic child node for a KnownRoutePart. A node can
+ * have at most one dynamic child. Sibling filesystem routes can't declare two
+ * different params at the same level, but parallel route branches can (e.g.
+ * @modal/[...catchAll] alongside [username]) — the caller detects that case
+ * and marks the level as conflicted instead of calling this.
  */ function discoverDynamicChild(part, paramName, paramType) {
     if (part.dynamicChild !== null) {
         return part.dynamicChild;
@@ -195,6 +198,7 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
     } else {
         // Dynamic segment tuple: [paramName, paramCacheKey, paramType, staticSiblings]
         const paramName = segment[0];
+        const paramCacheKey = segment[1];
         const paramType = segment[2];
         const staticSiblings = segment[3];
         if (paramType !== 'oc' && urlPart === null) {
@@ -209,6 +213,55 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
             // is a known static sibling. This is a mismatch.
             return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
         }
+        // The param's cache key holds the value parsed from the *rendered*
+        // pathname. If the URL part(s) this segment would consume don't equal
+        // that value, the response was rewrite-affected in a way that shifts
+        // which URL part maps to which segment (e.g. a proxy injected a leading
+        // locale segment). A static segment catches this above by failing to
+        // match its URL part; a dynamic segment consumes whatever part is in
+        // front of it, so compare against the rendered value instead. Bail out.
+        switch(paramType){
+            case 'd':
+                {
+                    // Canonicalize the URL part to the same encoded form the server used
+                    // for the cache key.
+                    if (urlPart !== null && (0, _routeparams.canonicalizeURLPart)(urlPart) !== paramCacheKey) {
+                        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+                    }
+                    break;
+                }
+            case 'c':
+            case 'oc':
+                {
+                    // Catch-alls consume every remaining URL part; their cache keys are
+                    // the rendered parts joined with '/' (empty string for an empty
+                    // optional catch-all). Comparing the joined remainder also catches a
+                    // rewrite that appended segments the URL doesn't have.
+                    const joinedRemainingParts = pathnameParts.slice(partIndex).map(_routeparams.canonicalizeURLPart).join('/');
+                    if (joinedRemainingParts !== paramCacheKey) {
+                        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+                    }
+                    break;
+                }
+            case 'ci(..)(..)':
+            case 'ci(.)':
+            case 'ci(..)':
+            case 'ci(...)':
+            case 'di(..)(..)':
+            case 'di(.)':
+            case 'di(..)':
+            case 'di(...)':
+                break;
+            default:
+                paramType;
+        }
+        if (parentKnownRoutePart.hasConflictingDynamicChildren || parentKnownRoutePart.dynamicChild !== null && (parentKnownRoutePart.dynamicChildParamName !== paramName || parentKnownRoutePart.dynamicChildParamType !== paramType)) {
+            // A different parallel route branch already claimed the dynamic child
+            // at this level with a different param. Mark the level as conflicted
+            // so matching bails out, and don't store a pattern via this branch.
+            parentKnownRoutePart.hasConflictingDynamicChildren = true;
+            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+        }
         // URL matches route structure. Build the known route tree.
         knownRoutePart = discoverDynamicChild(parentKnownRoutePart, paramName, paramType);
         // Record static siblings as placeholder parts.
@@ -417,8 +470,10 @@ function matchKnownRoute(now, pathname, search) {
             return null;
         }
     }
-    // Try dynamic child
-    if (part.dynamicChild !== null) {
+    // Try dynamic child. Skip it entirely if parallel route branches disagree
+    // about the dynamic segment at this level — any pattern stored beneath it
+    // was learned under a conflicting model.
+    if (part.dynamicChild !== null && !part.hasConflictingDynamicChildren) {
         const dynamicPart = part.dynamicChild;
         const paramName = part.dynamicChildParamName;
         const paramType = part.dynamicChildParamType;