@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/client/components/router-reducer/ppr-navigations.js

@@ -4,8 +4,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     FreshnessPolicy: null,
+    beginLockedNavigation: null,
     createInitialCacheNodeForHydration: null,
+    getCurrentNavigationLock: null,
     isDeferredRsc: null,
+    resetNavigationLockToPending: null,
     spawnDynamicRequests: null,
     startPPRNavigation: null
 });
@@ -19,12 +22,21 @@ _export(exports, {
     FreshnessPolicy: function() {
         return FreshnessPolicy;
     },
+    beginLockedNavigation: function() {
+        return beginLockedNavigation;
+    },
     createInitialCacheNodeForHydration: function() {
         return createInitialCacheNodeForHydration;
     },
+    getCurrentNavigationLock: function() {
+        return getCurrentNavigationLock;
+    },
     isDeferredRsc: function() {
         return isDeferredRsc;
     },
+    resetNavigationLockToPending: function() {
+        return resetNavigationLockToPending;
+    },
     spawnDynamicRequests: function() {
         return spawnDynamicRequests;
     },
@@ -46,6 +58,7 @@ const _cache = require("../segment-cache/cache");
 const _types = require("../segment-cache/types");
 const _optimisticroutes = require("../segment-cache/optimistic-routes");
 const _constants = require("../../../lib/constants");
+const _routeparams = require("../../route-params");
 const _varypath = require("../segment-cache/vary-path");
 const _bfcache = require("../segment-cache/bfcache");
 var FreshnessPolicy = /*#__PURE__*/ function(FreshnessPolicy) {
@@ -65,48 +78,38 @@ function createInitialCacheNodeForHydration(navigatedAt, initialTree, seedData,
         separateRefreshUrls: null,
         scrollRef: null
     };
-    const task = createCacheNodeOnNavigation(navigatedAt, initialTree, null, 1, seedData, seedHead, seedDynamicStaleAt, false, accumulation);
+    const restrictToShell = false;
+    const task = createCacheNodeOnNavigation(navigatedAt, initialTree, null, 1, seedData, seedHead, seedDynamicStaleAt, false, accumulation, // Hydration is bound to the shared map.
+    _cache.segmentCacheMap, restrictToShell);
     return task;
 }
-function startPPRNavigation(navigatedAt, oldUrl, oldRenderedSearch, oldCacheNode, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, accumulation) {
-    const didFindRootLayout = false;
+function startPPRNavigation(navigatedAt, oldUrl, oldRenderedSearch, oldCacheNode, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, accumulation, // 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, // Instant Navigation Testing API only — restricts segment reads to shell
+// entries. Always false outside the testing API. See navigation-testing-lock.
+restrictToShell) {
     const parentNeedsDynamicRequest = false;
     const parentRefreshState = null;
     const oldRootRefreshState = {
         canonicalUrl: (0, _createhreffromurl.createHrefFromUrl)(oldUrl),
         renderedSearch: oldRenderedSearch
     };
-    return updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode !== null ? oldCacheNode : undefined, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, didFindRootLayout, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation);
+    return updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode !== null ? oldCacheNode : undefined, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation, map, restrictToShell);
 }
-function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, didFindRootLayout, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation) {
-    // Check if this segment matches the one in the previous route.
+function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation, map, // Instant Navigation Testing API only — restricts segment reads to shell
+// entries. Always false outside the testing API. See navigation-testing-lock.
+restrictToShell) {
+    // Check if this segment matches the one in the previous route. A
+    // search-param-only difference at a page segment falls through to the
+    // matched branch — the CacheNode is rebuilt (so data refetches), but the
+    // bfcacheId carries forward as if the segment had matched.
     const oldSegment = oldRouterState[0];
     const newSegment = createSegmentFromRouteTree(newRouteTree);
-    if (!(0, _matchsegments.matchSegment)(newSegment, oldSegment)) {
+    const segmentMatchKind = compareSegments(newSegment, oldSegment);
+    if (segmentMatchKind === 1) {
         // This segment does not match the previous route. We're now entering the
         // new part of the target route. Switch to the "create" path.
-        if (// Check if the route tree changed before we reached a layout. (The
-        // highest-level layout in a route tree is referred to as the "root"
-        // layout.) This could mean that we're navigating between two different
-        // root layouts. When this happens, we perform a full-page (MPA-style)
-        // navigation.
-        //
-        // However, the algorithm for deciding where to start rendering a route
-        // (i.e. the one performed in order to reach this function) is stricter
-        // than the one used to detect a change in the root layout. So just
-        // because we're re-rendering a segment outside of the root layout does
-        // not mean we should trigger a full-page navigation.
-        //
-        // Specifically, we handle dynamic parameters differently: two segments
-        // are considered the same even if their parameter values are different.
-        //
-        // Refer to isNavigatingToNewRootLayout for details.
-        //
-        // Note that we only have to perform this extra traversal if we didn't
-        // already discover a root layout in the part of the tree that is
-        // unchanged. We also only need to compare the subtree that is not
-        // shared. In the common case, this branch is skipped completely.
-        !didFindRootLayout && (0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(oldRouterState, newRouteTree) || // The global Not Found route (app/global-not-found.tsx) is a special
+        if ((newRouteTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0 && (0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(oldRouterState, newRouteTree) || // The global Not Found route (app/global-not-found.tsx) is a special
         // case, because it acts like a root layout, but in the router tree, it
         // is rendered in the same position as app/layout.tsx.
         //
@@ -119,15 +122,11 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
         newSegment === _segment.NOT_FOUND_SEGMENT_KEY) {
             return null;
         }
-        return createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation);
+        return createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, restrictToShell);
     }
     const newSlots = newRouteTree.slots;
     const oldRouterStateChildren = oldRouterState[1];
     const seedDataChildren = seedData !== null ? seedData[1] : null;
-    // We're currently traversing the part of the tree that was also part of
-    // the previous route. If we discover a root layout, then we don't need to
-    // trigger an MPA navigation.
-    const childDidFindRootLayout = didFindRootLayout || (newRouteTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayout) !== 0;
     let shouldRefreshDynamicData = false;
     switch(freshness){
         case 0:
@@ -157,7 +156,10 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
     let newCacheNode;
     let needsDynamicRequest;
     if (oldCacheNode !== undefined && !shouldRefreshDynamicData && // During a same-page navigation, we always refetch the page segments
-    !(isLeafSegment && isSamePageNavigation)) {
+    !(isLeafSegment && isSamePageNavigation) && // A search-param-only change is treated as a refresh of the page segment.
+    // The internal cache key of the data is different, but the identity of
+    // the node in the route tree is the same.
+    segmentMatchKind !== 2) {
         // Reuse the existing CacheNode
         const dropPrefetchRsc = false;
         newCacheNode = reuseSharedCacheNode(dropPrefetchRsc, oldCacheNode);
@@ -166,16 +168,26 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
         // If this is part of a refresh, ignore the existing CacheNode and create a
         // new one.
         const seedRsc = seedData !== null ? seedData[0] : null;
-        const result = createCacheNodeForSegment(navigatedAt, newRouteTree, seedRsc, newMetadataVaryPath, seedHead, freshness, seedDynamicStaleAt);
+        const result = createCacheNodeForSegment(navigatedAt, newRouteTree, seedRsc, newMetadataVaryPath, seedHead, freshness, seedDynamicStaleAt, // Carry forward the existing bfcacheId when there's a prior CacheNode:
+        // even though the data is being refreshed, the state identity of the
+        // route hasn't changed. Otherwise (no prior node) mint a fresh one.
+        oldCacheNode !== undefined ? oldCacheNode.bfcacheId : generateBFCacheId(freshness), map, restrictToShell);
         newCacheNode = result.cacheNode;
         needsDynamicRequest = result.needsDynamicRequest;
-        // Carry forward the old node's scrollRef. This preserves scroll
-        // intent when a prior navigation's cache node is replaced by a
-        // refresh before the scroll handler has had a chance to fire —
-        // e.g. when router.push() and router.refresh() are called in the
-        // same startTransition batch.
-        if (oldCacheNode !== undefined) {
-            newCacheNode.scrollRef = oldCacheNode.scrollRef;
+        // Scroll handling
+        if (isLeafSegment && segmentMatchKind === 2) {
+            // Special case: A search param change mostly acts the same as a
+            // refresh, except it does trigger a scroll.
+            accumulateScrollRef(freshness, newCacheNode, accumulation);
+        } else {
+            // Normal case: This is a refresh of an existing segment. Carry forward
+            // the old node's scrollRef. This preserves scroll intent when a prior
+            // navigation's CacheNode is replaced by a refresh before the scroll
+            // handler has had a chance to fire — e.g. when router.push() and
+            // router.refresh() are called in the same startTransition batch.
+            if (oldCacheNode !== undefined) {
+                newCacheNode.scrollRef = oldCacheNode.scrollRef;
+            }
         }
     }
     // During a refresh navigation, there's a special case that happens when
@@ -222,8 +234,7 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
         const oldCacheNodeSlots = oldCacheNode !== undefined ? oldCacheNode.slots : null;
         newCacheNode.slots = newCacheNodeSlots = {};
         taskChildren = new Map();
-        for(let parallelRouteKey in newSlots){
-            let newRouteTreeChild = newSlots[parallelRouteKey];
+        for (let [parallelRouteKey, newRouteTreeChild] of newSlots){
             const oldRouterStateChild = oldRouterStateChildren[parallelRouteKey];
             if (oldRouterStateChild === undefined) {
                 // This should never happen, but if it does, it suggests a malformed
@@ -248,7 +259,7 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
                 seedHeadChild = null;
             }
             const oldCacheNodeChild = oldCacheNodeSlots !== null ? oldCacheNodeSlots[parallelRouteKey] : undefined;
-            const taskChild = updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNodeChild, oldRouterStateChild, newRouteTreeChild, newMetadataVaryPath, freshness, childDidFindRootLayout, seedDataChild ?? null, seedHeadChild, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest || needsDynamicRequest, oldRootRefreshState, refreshState, accumulation);
+            const taskChild = updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNodeChild, oldRouterStateChild, newRouteTreeChild, newMetadataVaryPath, freshness, seedDataChild ?? null, seedHeadChild, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest || needsDynamicRequest, oldRootRefreshState, refreshState, accumulation, map, restrictToShell);
             if (taskChild === null) {
                 // One of the child tasks discovered a change to the root layout.
                 // Immediately unwind from this recursive traversal. This will trigger a
@@ -330,7 +341,9 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
             break;
     }
 }
-function createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation) {
+function createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, // Instant Navigation Testing API only — restricts segment reads to shell
+// entries. Always false outside the testing API. See navigation-testing-lock.
+restrictToShell) {
     // Same traversal as updateCacheNodeNavigation, but simpler. We switch to this
     // path once we reach the part of the tree that was not in the previous route.
     // We don't need to diff against the old tree, we just need to create a new
@@ -344,7 +357,9 @@ function createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryP
     const newSlots = newRouteTree.slots;
     const seedDataChildren = seedData !== null ? seedData[1] : null;
     const seedRsc = seedData !== null ? seedData[0] : null;
-    const result = createCacheNodeForSegment(navigatedAt, newRouteTree, seedRsc, newMetadataVaryPath, seedHead, freshness, seedDynamicStaleAt);
+    const result = createCacheNodeForSegment(navigatedAt, newRouteTree, seedRsc, newMetadataVaryPath, seedHead, freshness, seedDynamicStaleAt, // This segment was not part of the previous route, so mint a fresh
+    // bfcacheId.
+    generateBFCacheId(freshness), map, restrictToShell);
     const newCacheNode = result.cacheNode;
     const needsDynamicRequest = result.needsDynamicRequest;
     const isLeafSegment = newSlots === null;
@@ -359,10 +374,9 @@ function createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryP
     if (newSlots !== null) {
         newCacheNode.slots = newCacheNodeSlots = {};
         taskChildren = new Map();
-        for(let parallelRouteKey in newSlots){
-            const newRouteTreeChild = newSlots[parallelRouteKey];
+        for (const [parallelRouteKey, newRouteTreeChild] of newSlots){
             const seedDataChild = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] : null;
-            const taskChild = createCacheNodeOnNavigation(navigatedAt, newRouteTreeChild, newMetadataVaryPath, freshness, seedDataChild ?? null, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest || needsDynamicRequest, accumulation);
+            const taskChild = createCacheNodeOnNavigation(navigatedAt, newRouteTreeChild, newMetadataVaryPath, freshness, seedDataChild ?? null, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest || needsDynamicRequest, accumulation, map, restrictToShell);
             taskChildren.set(parallelRouteKey, taskChild);
             newCacheNodeSlots[parallelRouteKey] = taskChild.node;
             const taskChildRoute = taskChild.route;
@@ -413,7 +427,7 @@ function createSegmentFromRouteTree(newRouteTree) {
         }
         // This is based on equivalent logic in addSearchParamsIfPageSegment, used
         // on the server.
-        const stringifiedQuery = JSON.stringify(Object.fromEntries(new URLSearchParams(renderedSearch)));
+        const stringifiedQuery = JSON.stringify((0, _routeparams.urlSearchParamsToParsedUrlQuery)(new URLSearchParams(renderedSearch)));
         return stringifiedQuery !== '{}' ? _segment.PAGE_SEGMENT_KEY + '?' + stringifiedQuery : _segment.PAGE_SEGMENT_KEY;
     }
     return newRouteTree.segment;
@@ -503,7 +517,8 @@ function reuseActiveSegmentInDefaultSlot(parentRouteTree, parallelRouteKey, oldR
         reusedRenderedSearch = oldRootRefreshState.renderedSearch;
     }
     const acc = {
-        metadataVaryPath: null
+        metadataVaryPath: null,
+        treeDivergedFromBase: false
     };
     const reusedRouteTree = (0, _cache.convertReusedFlightRouterStateToRouteTree)(parentRouteTree, parallelRouteKey, oldRouterState, reusedRenderedSearch, acc);
     reusedRouteTree.refreshState = {
@@ -516,9 +531,13 @@ function reuseSharedCacheNode(dropPrefetchRsc, existingCacheNode) {
     // Clone the CacheNode that was already present in the previous tree.
     // Carry forward the scrollRef so scroll intent from a prior navigation
     // survives tree rebuilds (e.g. push + refresh in the same batch).
-    return createCacheNode(existingCacheNode.rsc, dropPrefetchRsc ? null : existingCacheNode.prefetchRsc, existingCacheNode.head, dropPrefetchRsc ? null : existingCacheNode.prefetchHead, existingCacheNode.scrollRef);
+    // Carry forward the bfcacheId so shared-layout segments retain stable
+    // identity across navigations.
+    return createCacheNode(existingCacheNode.rsc, dropPrefetchRsc ? null : existingCacheNode.prefetchRsc, existingCacheNode.head, dropPrefetchRsc ? null : existingCacheNode.prefetchHead, existingCacheNode.bfcacheId, existingCacheNode.scrollRef);
 }
-function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHead, freshness, dynamicStaleAt) {
+function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHead, freshness, dynamicStaleAt, bfcacheId, map, // Instant Navigation Testing API only — restricts segment reads to shell
+// entries. Always false outside the testing API. See navigation-testing-lock.
+restrictToShell) {
     // Construct a new CacheNode using data from the BFCache, the client's
     // Segment Cache, or seeded from a server response.
     //
@@ -545,8 +564,12 @@ function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHea
                 // unstable_dynamicStaleTime for per-page control.
                 const bfcacheEntry = (0, _bfcache.readFromBFCacheDuringRegularNavigation)(now, tree.varyPath);
                 if (bfcacheEntry !== null) {
+                    // A regular navigation that happens to read cached data is still a
+                    // fresh navigation, so we use the caller-supplied bfcacheId — the
+                    // BFCacheEntry's id is only restored on history-traversal
+                    // navigations.
                     return {
-                        cacheNode: createCacheNode(bfcacheEntry.rsc, bfcacheEntry.prefetchRsc, bfcacheEntry.head, bfcacheEntry.prefetchHead),
+                        cacheNode: createCacheNode(bfcacheEntry.rsc, bfcacheEntry.prefetchRsc, bfcacheEntry.head, bfcacheEntry.prefetchHead, bfcacheId),
                         needsDynamicRequest: false
                     };
                 }
@@ -574,12 +597,12 @@ function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHea
                 const prefetchRsc = null;
                 const head = isPage ? seedHead : null;
                 const prefetchHead = null;
-                (0, _bfcache.writeToBFCache)(now, tree.varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt);
+                (0, _bfcache.writeToBFCache)(now, tree.varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt, bfcacheId);
                 if (isPage && metadataVaryPath !== null) {
-                    (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt);
+                    (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt, bfcacheId);
                 }
                 return {
-                    cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead),
+                    cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId),
                     needsDynamicRequest: false
                 };
             }
@@ -599,8 +622,11 @@ function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHea
                 const oldRsc = bfcacheEntry.rsc;
                 const oldRscDidResolve = !isDeferredRsc(oldRsc) || oldRsc.status !== 'pending';
                 const dropPrefetchRsc = oldRscDidResolve;
+                // Restore the bfcacheId from the cached entry so that back/forward
+                // navigations preserve the original id, regardless of whether
+                // `cacheComponents` Activity preservation is enabled.
                 return {
-                    cacheNode: createCacheNode(bfcacheEntry.rsc, dropPrefetchRsc ? null : bfcacheEntry.prefetchRsc, bfcacheEntry.head, dropPrefetchRsc ? null : bfcacheEntry.prefetchHead),
+                    cacheNode: createCacheNode(bfcacheEntry.rsc, dropPrefetchRsc ? null : bfcacheEntry.prefetchRsc, bfcacheEntry.head, dropPrefetchRsc ? null : bfcacheEntry.prefetchHead, bfcacheEntry.bfcacheId),
                     needsDynamicRequest: false
                 };
             }
@@ -615,7 +641,7 @@ function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHea
     }
     let cachedRsc = null;
     let isCachedRscPartial = true;
-    const segmentEntry = (0, _cache.readSegmentCacheEntry)(now, tree.varyPath);
+    const segmentEntry = (0, _cache.readSegmentCacheEntryForNavigation)(now, map, tree.varyPath, restrictToShell);
     if (segmentEntry !== null) {
         switch(segmentEntry.status){
             case _cache.EntryStatus.Fulfilled:
@@ -714,7 +740,7 @@ function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHea
         let cachedHead = null;
         let isCachedHeadPartial = true;
         if (metadataVaryPath !== null) {
-            const metadataEntry = (0, _cache.readSegmentCacheEntry)(now, metadataVaryPath);
+            const metadataEntry = (0, _cache.readSegmentCacheEntryForNavigation)(now, map, metadataVaryPath, restrictToShell);
             if (metadataEntry !== null) {
                 switch(metadataEntry.status){
                     case _cache.EntryStatus.Fulfilled:
@@ -787,29 +813,51 @@ function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHea
     // Skip BFCache writes for optimistic navigations since they are transient
     // and will be replaced by the canonical navigation.
     if (freshness !== 5) {
-        (0, _bfcache.writeToBFCache)(now, tree.varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt);
+        (0, _bfcache.writeToBFCache)(now, tree.varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt, bfcacheId);
         if (isPage && metadataVaryPath !== null) {
-            (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt);
+            (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt, bfcacheId);
         }
     }
     return {
-        cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead),
+        cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId),
         // TODO: We should store this field on the CacheNode itself. I think we can
         // probably unify NavigationTask, CacheNode, and DeferredRsc into a
         // single type. Or at least CacheNode and DeferredRsc.
         needsDynamicRequest: doesSegmentNeedDynamicRequest || doesHeadNeedDynamicRequest
     };
 }
-function createCacheNode(rsc, prefetchRsc, head, prefetchHead, scrollRef = null) {
+function createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId, scrollRef = null) {
     return {
         rsc,
         prefetchRsc,
         head,
         prefetchHead,
         slots: null,
-        scrollRef
+        scrollRef,
+        bfcacheId
     };
 }
+// Globally-unique counter for fresh bfcacheIds. Incremented every time a new
+// CacheNode is created on the client. The id surfaces to user code as a
+// string via `useRouter().bfcacheId`.
+let nextBFCacheId = 0;
+function generateBFCacheId(freshness) {
+    // Server-side rendering and the initial client-side hydration tree both
+    // use a fixed sentinel so they reconcile cleanly across hydration. The
+    // counter only advances on real client-side navigations after hydration.
+    if (typeof window === 'undefined') return 0;
+    if (freshness === 1) return 0;
+    return ++nextBFCacheId;
+}
+function compareSegments(newSegment, oldSegment) {
+    if ((0, _matchsegments.matchSegment)(newSegment, oldSegment)) {
+        return 0;
+    }
+    if (typeof newSegment === 'string' && typeof oldSegment === 'string' && newSegment.startsWith(_segment.PAGE_SEGMENT_KEY) && oldSegment.startsWith(_segment.PAGE_SEGMENT_KEY)) {
+        return 2;
+    }
+    return 1;
+}
 // Represents whether the previuos navigation resulted in a route tree mismatch.
 // A mismatch results in a refresh of the page. If there are two successive
 // mismatches, we will fall back to an MPA navigation, to prevent a retry loop.
@@ -821,7 +869,9 @@ function spawnDynamicRequests(task, primaryUrl, nextUrl, freshnessPolicy, accumu
 routeCacheEntry, // The original navigation's push/replace intent. Threaded through to the
 // server-patch retry logic so it can inherit the intent if the original
 // transition hasn't committed yet.
-navigateType) {
+navigateType, navigationLock, // The segment cache map this navigation is bound to. See `segmentCacheMap`
+// in cache.ts.
+map, signal) {
     const dynamicRequestTree = task.dynamicRequestTree;
     if (dynamicRequestTree === null) {
         // This navigation was fully cached. There are no dynamic requests to spawn.
@@ -837,7 +887,7 @@ navigateType) {
     // block the navigation, and collect the promises. The next function,
     // `finishNavigationTask`, can await the promises in any order without
     // accidentally introducing a network waterfall.
-    const primaryRequestPromise = fetchMissingDynamicData(task, dynamicRequestTree, primaryUrl, nextUrl, freshnessPolicy, routeCacheEntry);
+    const primaryRequestPromise = fetchMissingDynamicData(task, dynamicRequestTree, primaryUrl, nextUrl, freshnessPolicy, routeCacheEntry, navigationLock, map, signal);
     const separateRefreshUrls = accumulation.separateRefreshUrls;
     let refreshRequestPromises = null;
     if (separateRefreshUrls !== null) {
@@ -872,7 +922,7 @@ navigateType) {
                 // start tracking this alongside the refresh URL. In the meantime,
                 // if a refresh fails due to a mismatch, it will trigger a
                 // hard refresh.
-                nextUrl, freshnessPolicy, routeCacheEntry));
+                nextUrl, freshnessPolicy, routeCacheEntry, navigationLock, map, signal));
             }
         }
     }
@@ -896,6 +946,15 @@ async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refres
         exitStatus = abortRemainingPendingTasks(task, null, null);
     }
     switch(exitStatus){
+        case -1:
+            {
+                // This navigation was superseded and its request aborted. Its cache nodes
+                // may already be reused by the newer navigation, so leave them untouched
+                // for the newer request to fulfill. If the tree was abandoned entirely,
+                // it can be garbage collected along with its unresolved promises. We do
+                // not retry or hard-navigate.
+                return;
+            }
         case 0:
             {
                 // The task has completely finished. There's no missing data. Exit.
@@ -904,13 +963,25 @@ async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refres
             }
         case 1:
             {
-                // Some data failed to finish loading. Trigger a soft retry.
+                // Some data failed to finish loading. Trigger a soft retry that re-fetches
+                // the tree's dynamic data.
                 // TODO: As an extra precaution against soft retry loops, consider
                 // tracking whether a navigation was itself triggered by a retry. If two
                 // happen in a row, fall back to a hard retry.
                 const isHardRetry = false;
                 const primaryRequestResult = await primaryRequestPromise;
-                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType);
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType, 3);
+                return;
+            }
+        case 3:
+            {
+                // The route matched, but the request was redirected, so we committed the
+                // wrong canonical URL. Re-resolve the route to invalidate the now-stale
+                // route cache and correct the URL — but reuse the data we already received
+                // (HistoryTraversal) instead of re-fetching it. See issue #95195.
+                const isHardRetry = false;
+                const primaryRequestResult = await primaryRequestPromise;
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType, 2);
                 return;
             }
         case 2:
@@ -925,7 +996,7 @@ async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refres
                 // doesn't exist yet.
                 const isHardRetry = true;
                 const primaryRequestResult = await primaryRequestPromise;
-                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType);
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType, 3);
                 return;
             }
         default:
@@ -978,7 +1049,11 @@ function dispatchRetryDueToTreeMismatch(isHardRetry, retryUrl, retryNextUrl, see
 // prediction. If the navigation results in a mismatch, we mark it as having
 // a dynamic rewrite so future predictions bail out.
 routeCacheEntry, // The original navigation's push/replace intent.
-originalNavigateType) {
+originalNavigateType, // Freshness policy for the retry navigation. `RefreshAll` re-fetches the
+// tree's dynamic data (used for genuine tree mismatches). `HistoryTraversal`
+// reuses the data already in the tree (used when only the URL needs
+// correcting after a redirect).
+retryFreshnessPolicy) {
     // If the navigation used a route prediction, mark it as having a dynamic
     // rewrite since it resulted in a mismatch.
     if (routeCacheEntry !== null) {
@@ -991,7 +1066,7 @@ originalNavigateType) {
         const metadataVaryPath = seed.metadataVaryPath;
         if (metadataVaryPath !== null) {
             const now = Date.now();
-            (0, _optimisticroutes.discoverKnownRoute)(now, retryUrl.pathname, retryNextUrl, null, seed.routeTree, metadataVaryPath, false, (0, _createhreffromurl.createHrefFromUrl)(retryUrl), false, true // hasDynamicRewrite
+            (0, _optimisticroutes.discoverKnownRoute)(now, retryUrl.pathname, retryUrl.search, retryNextUrl, null, seed.routeTree, metadataVaryPath, false, (0, _createhreffromurl.createHrefFromUrl)(retryUrl), false, true // hasDynamicRewrite
             );
         }
     }
@@ -1026,16 +1101,18 @@ originalNavigateType) {
         nextUrl: retryNextUrl,
         seed,
         mpa: isHardRetry,
-        navigateType: retryNavigateType
+        navigateType: retryNavigateType,
+        freshnessPolicy: retryFreshnessPolicy
     };
     (0, _useactionqueue.dispatchAppRouterAction)(retryAction);
 }
-async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, freshnessPolicy, routeCacheEntry) {
+async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, freshnessPolicy, routeCacheEntry, navigationLock, map, signal) {
     try {
         const result = await (0, _fetchserverresponse.fetchServerResponse)(url, {
             flightRouterState: dynamicRequestTree,
             nextUrl,
-            isHmrRefresh: freshnessPolicy === 4
+            isHmrRefresh: freshnessPolicy === 4,
+            signal
         });
         if (typeof result === 'string') {
             // fetchServerResponse will return an href to indicate that the SPA
@@ -1053,14 +1130,17 @@ async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, f
         // If the navigation lock is active, wait for it to be released before
         // writing the dynamic data. This allows tests to assert on the prefetched
         // UI state.
-        if (process.env.__NEXT_EXPOSE_TESTING_API) {
-            await waitForNavigationLock();
+        if (process.env.__NEXT_EXPOSE_TESTING_API && navigationLock !== null) {
+            await navigationLock;
         }
+        // TODO: Implement Shell extraction as part of Cached Navigations.
+        // Intentionally holding off on doing this until we decide how the Cached
+        // Navigations behavior should work in combination with App Shells.
         if (routeCacheEntry !== null && result.staticStageData !== null) {
             const { response: staticStageResponse, isResponsePartial } = result.staticStageData;
-            (0, _cache.getStaleAt)(now, staticStageResponse.s).then((staleAt)=>{
+            (0, _cache.resolveStaleAt)(now, staticStageResponse.s).then((staleAt)=>{
                 const buildId = result.responseHeaders.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? staticStageResponse.b;
-                (0, _cache.writeStaticStageResponseIntoCache)(now, staticStageResponse.f, buildId, staticStageResponse.h, staleAt, dynamicRequestTree, result.renderedSearch, isResponsePartial);
+                (0, _cache.writePrerenderResponseIntoCache)(now, _types.FetchStrategy.PPR, staticStageResponse.f, buildId, staticStageResponse.h, staticStageResponse.r ?? null, staleAt, dynamicRequestTree, result.renderedSearch, isResponsePartial, map);
             }).catch(()=>{
             // The static stage processing failed. Not fatal — the navigation
             // completed normally, we just won't write into the cache.
@@ -1069,7 +1149,7 @@ async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, f
         if (routeCacheEntry !== null && result.runtimePrefetchStream !== null) {
             (0, _cache.processRuntimePrefetchStream)(now, result.runtimePrefetchStream, dynamicRequestTree, result.renderedSearch).then((processed)=>{
                 if (processed !== null) {
-                    (0, _cache.writeDynamicRenderResponseIntoCache)(now, _types.FetchStrategy.PPRRuntime, processed.flightDatas, processed.buildId, processed.isResponsePartial, processed.headVaryParams, 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
@@ -1079,13 +1159,45 @@ async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, f
         // result.dynamicStaleTime is in seconds (from the server's `d` field).
         // Convert to an absolute timestamp using the centralized helper.
         const dynamicStaleAt = (0, _bfcache.computeDynamicStaleAt)(now, result.dynamicStaleTime);
-        const didReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(task, seed.routeTree, seed.data, seed.head, dynamicStaleAt, result.debugInfo);
+        const didReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(task, seed.routeTree, seed.data, seed.head, dynamicStaleAt, result.debugInfo, result.revealAfter);
+        const resolvedUrl = new URL(result.canonicalUrl, location.origin);
+        // Decide whether the navigation needs to be retried.
+        //
+        // - A tree mismatch (unknown parallel route) means the data is incomplete,
+        //   so we soft-retry and re-fetch the whole tree.
+        // - Otherwise, the navigation committed the canonical URL from the route
+        //   cache entry it used (a prediction or prefetch). If the request resolved
+        //   to a *different* canonical URL — e.g. a middleware/proxy redirect the
+        //   prediction didn't account for — then the committed URL is wrong and the
+        //   route cache it came from is no longer reliable (the redirect implies a
+        //   server change the prediction couldn't know about, like logging in or
+        //   out). We re-resolve the route to invalidate the stale cache and correct
+        //   the browser URL, reusing the data we just received rather than
+        //   re-fetching it. When the entry already reflects the redirect (e.g. a
+        //   prefetch that followed it), the committed URL matches and no retry is
+        //   needed. See issue #95195.
+        let didCommitWrongUrl = false;
+        if (routeCacheEntry !== null) {
+            const committedUrl = new URL(routeCacheEntry.canonicalUrl, location.origin);
+            didCommitWrongUrl = committedUrl.pathname !== resolvedUrl.pathname || committedUrl.search !== resolvedUrl.search;
+        }
+        const exitStatus = didReceiveUnknownParallelRoute ? 1 : didCommitWrongUrl ? 3 : 0;
         return {
-            exitStatus: didReceiveUnknownParallelRoute ? 1 : 0,
-            url: new URL(result.canonicalUrl, location.origin),
+            exitStatus,
+            url: resolvedUrl,
             seed
         };
     } catch  {
+        if (signal?.aborted) {
+            // A newer HMR refresh superseded this one and aborted its request. Treat
+            // it as canceled rather than a failure, so we don't retry or
+            // hard-navigate.
+            return {
+                exitStatus: -1,
+                url,
+                seed: null
+            };
+        }
         // This shouldn't happen because fetchServerResponse's entire body is
         // wrapped in a try/catch. If it does, though, it implies the server failed
         // to respond with any tree at all. So we must fall back to a hard retry.
@@ -1096,10 +1208,10 @@ async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, f
         };
     }
 }
-function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData, dynamicHead, dynamicStaleAt, debugInfo) {
+function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData, dynamicHead, dynamicStaleAt, debugInfo, revealAfter) {
     if (task.status === 0 && dynamicData !== null) {
         task.status = 1;
-        finishPendingCacheNode(task.node, dynamicData, dynamicHead, debugInfo);
+        finishPendingCacheNode(task.node, dynamicData, dynamicHead, debugInfo, revealAfter);
         // Update the BFCache entry's staleAt for this segment with the value
         // from the dynamic response. This applies the per-page
         // unstable_dynamicStaleTime if set, or the default DYNAMIC_STALETIME_MS.
@@ -1115,8 +1227,7 @@ function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData,
     let didReceiveUnknownParallelRoute = false;
     if (taskChildren !== null) {
         if (serverChildren !== null) {
-            for(const parallelRouteKey in serverChildren){
-                const serverRouteTreeChild = serverChildren[parallelRouteKey];
+            for (const [parallelRouteKey, serverRouteTreeChild] of serverChildren){
                 const dynamicDataChild = dynamicDataChildren !== null ? dynamicDataChildren[parallelRouteKey] : null;
                 const taskChild = taskChildren.get(parallelRouteKey);
                 if (taskChild === undefined) {
@@ -1139,7 +1250,7 @@ function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData,
                     const serverSegment = createSegmentFromRouteTree(serverRouteTreeChild);
                     if ((0, _matchsegments.matchSegment)(serverSegment, taskSegment) && dynamicDataChild !== null && dynamicDataChild !== undefined) {
                         // Found a match for this task. Keep traversing down the task tree.
-                        const childDidReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(taskChild, serverRouteTreeChild, dynamicDataChild, dynamicHead, dynamicStaleAt, debugInfo);
+                        const childDidReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(taskChild, serverRouteTreeChild, dynamicDataChild, dynamicHead, dynamicStaleAt, debugInfo, revealAfter);
                         if (childDidReceiveUnknownParallelRoute) {
                             didReceiveUnknownParallelRoute = true;
                         }
@@ -1155,7 +1266,7 @@ function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData,
     }
     return didReceiveUnknownParallelRoute;
 }
-function finishPendingCacheNode(cacheNode, dynamicData, dynamicHead, debugInfo) {
+function finishPendingCacheNode(cacheNode, dynamicData, dynamicHead, debugInfo, revealAfter) {
     // Writes a dynamic response into an existing Cache Node tree. This does _not_
     // create a new tree, it updates the existing tree in-place. So it must follow
     // the Suspense rules of cache safety — it can resolve pending promises, but
@@ -1184,7 +1295,21 @@ function finishPendingCacheNode(cacheNode, dynamicData, dynamicHead, debugInfo)
         // This is a deferred RSC promise. We can fulfill it with the data we just
         // received from the server. If it was already resolved by a different
         // navigation, then this does nothing because we can't overwrite data.
-        rsc.resolve(dynamicSegmentData, debugInfo);
+        //
+        // In the streaming dev render, defer the fill until `revealAfter` settles,
+        // so React doesn't render the boundary's children before their row has been
+        // decoded (otherwise it suspends on the still-pending children and commits
+        // a premature fallback). Outside that render `revealAfter` is null and we
+        // resolve immediately.
+        if (revealAfter !== null) {
+            const resolveRsc = ()=>rsc.resolve(dynamicSegmentData, debugInfo);
+            // Use the same callback for both outcomes: we don't expect `revealAfter`
+            // to reject, but if it ever did (e.g. a connection drop mid-stream) we'd
+            // still want to resolve the RSC.
+            revealAfter.then(resolveRsc, resolveRsc);
+        } else {
+            rsc.resolve(dynamicSegmentData, debugInfo);
+        }
     } else {
     // This is not a deferred RSC promise, nor is it empty, so it must have
     // been populated by a different navigation. We must not overwrite it.
@@ -1319,16 +1444,24 @@ function createDeferredRsc() {
     pendingRsc._debugInfo = debugInfo;
     return pendingRsc;
 }
-/**
- * Helper for the Instant Navigation Testing API. Waits for the navigation lock
- * to be released before returning. The network request has already completed by
- * the time this is called, so this only delays writing the dynamic data.
- *
- * Not exposed in production builds by default.
- */ async function waitForNavigationLock() {
+function getCurrentNavigationLock() {
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        const { getCurrentNavigationGate } = require('../segment-cache/navigation-testing-lock');
+        return getCurrentNavigationGate();
+    }
+    return null;
+}
+function beginLockedNavigation() {
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        const { beginLockedNavigation: begin } = require('../segment-cache/navigation-testing-lock');
+        return begin();
+    }
+    return null;
+}
+function resetNavigationLockToPending() {
     if (process.env.__NEXT_EXPOSE_TESTING_API) {
-        const { waitForNavigationLockIfActive } = require('../segment-cache/navigation-testing-lock');
-        await waitForNavigationLockIfActive();
+        const { resetNavigationLockToPending: reset } = require('../segment-cache/navigation-testing-lock');
+        reset();
     }
 }