@semiont/frontend 0.3.3 → 0.3.4

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

@@ -32,59 +32,56 @@ _export(exports, {
         return startPPRNavigation;
     }
 });
+const _approutertypes = require("../../../shared/lib/app-router-types");
 const _segment = require("../../../shared/lib/segment");
 const _matchsegments = require("../match-segments");
 const _createhreffromurl = require("./create-href-from-url");
-const _createroutercachekey = require("./create-router-cache-key");
 const _fetchserverresponse = require("./fetch-server-response");
 const _useactionqueue = require("../use-action-queue");
 const _routerreducertypes = require("./router-reducer-types");
 const _isnavigatingtonewrootlayout = require("./is-navigating-to-new-root-layout");
-const _navigatereducer = require("./reducers/navigate-reducer");
+const _committedstate = require("./reducers/committed-state");
 const _navigation = require("../segment-cache/navigation");
+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 _varypath = require("../segment-cache/vary-path");
+const _bfcache = require("../segment-cache/bfcache");
 var FreshnessPolicy = /*#__PURE__*/ function(FreshnessPolicy) {
     FreshnessPolicy[FreshnessPolicy["Default"] = 0] = "Default";
     FreshnessPolicy[FreshnessPolicy["Hydration"] = 1] = "Hydration";
     FreshnessPolicy[FreshnessPolicy["HistoryTraversal"] = 2] = "HistoryTraversal";
     FreshnessPolicy[FreshnessPolicy["RefreshAll"] = 3] = "RefreshAll";
     FreshnessPolicy[FreshnessPolicy["HMRRefresh"] = 4] = "HMRRefresh";
+    FreshnessPolicy[FreshnessPolicy["Gesture"] = 5] = "Gesture";
     return FreshnessPolicy;
 }({});
 const noop = ()=>{};
-function createInitialCacheNodeForHydration(navigatedAt, initialTree, seedData, seedHead) {
+function createInitialCacheNodeForHydration(navigatedAt, initialTree, seedData, seedHead, seedDynamicStaleAt) {
     // Create the initial cache node tree, using the data embedded into the
     // HTML document.
     const accumulation = {
-        scrollableSegments: null,
-        separateRefreshUrls: null
+        separateRefreshUrls: null,
+        scrollRef: null
     };
-    const task = createCacheNodeOnNavigation(navigatedAt, initialTree, undefined, 1, seedData, seedHead, null, null, false, null, null, false, accumulation);
-    // NOTE: We intentionally don't check if any data needs to be fetched from the
-    // server. We assume the initial hydration payload is sufficient to render
-    // the page.
-    //
-    // The completeness of the initial data is an important property that we rely
-    // on as a last-ditch mechanism for recovering the app; we must always be able
-    // to reload a fresh HTML document to get to a consistent state.
-    //
-    // In the future, there may be cases where the server intentionally sends
-    // partial data and expects the client to fill in the rest, in which case this
-    // logic may change. (There already is a similar case where the server sends
-    // _no_ hydration data in the HTML document at all, and the client fetches it
-    // separately, but that's different because we still end up hydrating with a
-    // complete tree.)
-    return task.node;
+    const task = createCacheNodeOnNavigation(navigatedAt, initialTree, null, 1, seedData, seedHead, seedDynamicStaleAt, false, accumulation);
+    return task;
 }
-function startPPRNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouterState, freshness, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, accumulation) {
+function startPPRNavigation(navigatedAt, oldUrl, oldRenderedSearch, oldCacheNode, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, accumulation) {
     const didFindRootLayout = false;
     const parentNeedsDynamicRequest = false;
-    const parentRefreshUrl = null;
-    return updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode !== null ? oldCacheNode : undefined, oldRouterState, newRouterState, freshness, didFindRootLayout, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, null, null, parentNeedsDynamicRequest, parentRefreshUrl, accumulation);
+    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);
 }
-function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouterState, freshness, didFindRootLayout, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, parentSegmentPath, parentParallelRouteKey, parentNeedsDynamicRequest, parentRefreshUrl, accumulation) {
+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.
     const oldSegment = oldRouterState[0];
-    const newSegment = newRouterState[0];
+    const newSegment = createSegmentFromRouteTree(newRouteTree);
     if (!(0, _matchsegments.matchSegment)(newSegment, oldSegment)) {
         // This segment does not match the previous route. We're now entering the
         // new part of the target route. Switch to the "create" path.
@@ -109,7 +106,7 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
         // 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, newRouterState) || // The global Not Found route (app/global-not-found.tsx) is a special
+        !didFindRootLayout && (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.
         //
@@ -122,71 +119,37 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
         newSegment === _segment.NOT_FOUND_SEGMENT_KEY) {
             return null;
         }
-        if (parentSegmentPath === null || parentParallelRouteKey === null) {
-            // The root should never mismatch. If it does, it suggests an internal
-            // Next.js error, or a malformed server response. Trigger a full-
-            // page navigation.
-            return null;
-        }
-        return createCacheNodeOnNavigation(navigatedAt, newRouterState, oldCacheNode, freshness, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, parentSegmentPath, parentParallelRouteKey, parentNeedsDynamicRequest, accumulation);
+        return createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation);
     }
-    // TODO: The segment paths are tracked so that LayoutRouter knows which
-    // segments to scroll to after a navigation. But we should just mark this
-    // information on the CacheNode directly. It used to be necessary to do this
-    // separately because CacheNodes were created lazily during render, not when
-    // rather than when creating the route tree.
-    const segmentPath = parentParallelRouteKey !== null && parentSegmentPath !== null ? parentSegmentPath.concat([
-        parentParallelRouteKey,
-        newSegment
-    ]) : [];
-    const newRouterStateChildren = newRouterState[1];
+    const newSlots = newRouteTree.slots;
     const oldRouterStateChildren = oldRouterState[1];
     const seedDataChildren = seedData !== null ? seedData[1] : null;
-    const prefetchDataChildren = prefetchData !== null ? prefetchData[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 isRootLayout = newRouterState[4] === true;
-    const childDidFindRootLayout = didFindRootLayout || isRootLayout;
-    const oldParallelRoutes = oldCacheNode !== undefined ? oldCacheNode.parallelRoutes : undefined;
-    // Clone the current set of segment children, even if they aren't active in
-    // the new tree.
-    // TODO: We currently retain all the inactive segments indefinitely, until
-    // there's an explicit refresh, or a parent layout is lazily refreshed. We
-    // rely on this for popstate navigations, which update the Router State Tree
-    // but do not eagerly perform a data fetch, because they expect the segment
-    // data to already be in the Cache Node tree. For highly static sites that
-    // are mostly read-only, this may happen only rarely, causing memory to
-    // leak. We should figure out a better model for the lifetime of inactive
-    // segments, so we can maintain instant back/forward navigations without
-    // leaking memory indefinitely.
-    let shouldDropSiblingCaches = false;
+    const childDidFindRootLayout = didFindRootLayout || (newRouteTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayout) !== 0;
     let shouldRefreshDynamicData = false;
     switch(freshness){
         case 0:
         case 2:
         case 1:
-            // We should never drop dynamic data in shared layouts, except during
-            // a refresh.
-            shouldDropSiblingCaches = false;
+        case 5:
             shouldRefreshDynamicData = false;
             break;
         case 3:
         case 4:
-            shouldDropSiblingCaches = true;
             shouldRefreshDynamicData = true;
             break;
         default:
             freshness;
             break;
     }
-    const newParallelRoutes = new Map(shouldDropSiblingCaches ? undefined : oldParallelRoutes);
     // TODO: We're not consistent about how we do this check. Some places
     // check if the segment starts with PAGE_SEGMENT_KEY, but most seem to
     // check if there any any children, which is why I'm doing it here. We
     // should probably encode an empty children set as `null` though. Either
     // way, we should update all the checks to be consistent.
-    const isLeafSegment = Object.keys(newRouterStateChildren).length === 0;
+    const isLeafSegment = newSlots === null;
     // Get the data for this segment. Since it was part of the previous route,
     // usually we just clone the data from the old CacheNode. However, during a
     // refresh or a revalidation, there won't be any existing CacheNode. So we
@@ -197,46 +160,37 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
     !(isLeafSegment && isSamePageNavigation)) {
         // Reuse the existing CacheNode
         const dropPrefetchRsc = false;
-        newCacheNode = reuseDynamicCacheNode(dropPrefetchRsc, oldCacheNode, newParallelRoutes);
+        newCacheNode = reuseSharedCacheNode(dropPrefetchRsc, oldCacheNode);
         needsDynamicRequest = false;
-    } else if (seedData !== null && seedData[0] !== null) {
-        // If this navigation was the result of an action, then check if the
-        // server sent back data in the action response. We should favor using
-        // that, rather than performing a separate request. This is both better
-        // for performance and it's more likely to be consistent with any
-        // writes that were just performed by the action, compared to a
-        // separate request.
-        const seedRsc = seedData[0];
-        const seedLoading = seedData[2];
-        const isSeedRscPartial = false;
-        const isSeedHeadPartial = seedHead === null;
-        newCacheNode = readCacheNodeFromSeedData(seedRsc, seedLoading, isSeedRscPartial, seedHead, isSeedHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
-        needsDynamicRequest = isLeafSegment && isSeedHeadPartial;
-    } else if (prefetchData !== null) {
-        // Consult the prefetch cache.
-        const prefetchRsc = prefetchData[0];
-        const prefetchLoading = prefetchData[2];
-        const isPrefetchRSCPartial = prefetchData[3];
-        newCacheNode = readCacheNodeFromSeedData(prefetchRsc, prefetchLoading, isPrefetchRSCPartial, prefetchHead, isPrefetchHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
-        needsDynamicRequest = isPrefetchRSCPartial || isLeafSegment && isPrefetchHeadPartial;
     } else {
-        // Spawn a request to fetch new data from the server.
-        newCacheNode = spawnNewCacheNode(newParallelRoutes, isLeafSegment, navigatedAt, freshness);
-        needsDynamicRequest = true;
+        // 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);
+        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;
+        }
     }
     // During a refresh navigation, there's a special case that happens when
     // entering a "default" slot. The default slot may not be part of the
     // current route; it may have been reused from an older route. If so,
     // we need to fetch its data from the old route's URL rather than current
     // route's URL. Keep track of this as we traverse the tree.
-    const href = newRouterState[2];
-    const refreshUrl = typeof href === 'string' && newRouterState[3] === 'refresh' ? // refresh URL as we continue traversing the tree.
-    href : parentRefreshUrl;
+    const maybeRefreshState = newRouteTree.refreshState;
+    const refreshState = maybeRefreshState !== undefined && maybeRefreshState !== null ? // refresh URL as we continue traversing the tree.
+    maybeRefreshState : parentRefreshState;
     // If this segment itself needs to fetch new data from the server, then by
     // definition it is being refreshed. Track its refresh URL so we know which
     // URL to request the data from.
-    if (needsDynamicRequest && refreshUrl !== null) {
-        accumulateRefreshUrl(accumulation, refreshUrl);
+    if (needsDynamicRequest && refreshState !== null) {
+        accumulateRefreshUrl(accumulation, refreshState);
     }
     // As we diff the trees, we may sometimes modify (copy-on-write, not mutate)
     // the Route Tree that was returned by the server — for example, in the case
@@ -263,260 +217,207 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
     // include paths that are dynamic. Instead of reusing the
     // FlightRouterState type.
     let dynamicRequestTreeChildren = {};
-    for(let parallelRouteKey in newRouterStateChildren){
-        let newRouterStateChild = newRouterStateChildren[parallelRouteKey];
-        const oldRouterStateChild = oldRouterStateChildren[parallelRouteKey];
-        if (oldRouterStateChild === undefined) {
-            // This should never happen, but if it does, it suggests a malformed
-            // server response. Trigger a full-page navigation.
-            return null;
-        }
-        const oldSegmentMapChild = oldParallelRoutes !== undefined ? oldParallelRoutes.get(parallelRouteKey) : undefined;
-        let seedDataChild = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] : null;
-        let prefetchDataChild = prefetchDataChildren !== null ? prefetchDataChildren[parallelRouteKey] : null;
-        let newSegmentChild = newRouterStateChild[0];
-        let seedHeadChild = seedHead;
-        let prefetchHeadChild = prefetchHead;
-        let isPrefetchHeadPartialChild = isPrefetchHeadPartial;
-        if (// Skip this branch during a history traversal. We restore the tree that
-        // was stashed in the history entry as-is.
-        freshness !== 2 && newSegmentChild === _segment.DEFAULT_SEGMENT_KEY) {
-            // This is a "default" segment. These are never sent by the server during
-            // a soft navigation; instead, the client reuses whatever segment was
-            // already active in that slot on the previous route.
-            newRouterStateChild = reuseActiveSegmentInDefaultSlot(oldUrl, oldRouterStateChild);
-            newSegmentChild = newRouterStateChild[0];
-            // Since we're switching to a different route tree, these are no
-            // longer valid, because they correspond to the outer tree.
-            seedDataChild = null;
-            seedHeadChild = null;
-            prefetchDataChild = null;
-            prefetchHeadChild = null;
-            isPrefetchHeadPartialChild = false;
-        }
-        const newSegmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(newSegmentChild);
-        const oldCacheNodeChild = oldSegmentMapChild !== undefined ? oldSegmentMapChild.get(newSegmentKeyChild) : undefined;
-        const taskChild = updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNodeChild, oldRouterStateChild, newRouterStateChild, freshness, childDidFindRootLayout, seedDataChild ?? null, seedHeadChild, prefetchDataChild ?? null, prefetchHeadChild, isPrefetchHeadPartialChild, isSamePageNavigation, segmentPath, parallelRouteKey, parentNeedsDynamicRequest || needsDynamicRequest, refreshUrl, accumulation);
-        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
-            // full-page navigation.
-            return null;
-        }
-        // Recursively propagate up the child tasks.
-        if (taskChildren === null) {
-            taskChildren = new Map();
-        }
-        taskChildren.set(parallelRouteKey, taskChild);
-        const newCacheNodeChild = taskChild.node;
-        if (newCacheNodeChild !== null) {
-            const newSegmentMapChild = new Map(shouldDropSiblingCaches ? undefined : oldSegmentMapChild);
-            newSegmentMapChild.set(newSegmentKeyChild, newCacheNodeChild);
-            newParallelRoutes.set(parallelRouteKey, newSegmentMapChild);
-        }
-        // The child tree's route state may be different from the prefetched
-        // route sent by the server. We need to clone it as we traverse back up
-        // the tree.
-        const taskChildRoute = taskChild.route;
-        patchedRouterStateChildren[parallelRouteKey] = taskChildRoute;
-        const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
-        if (dynamicRequestTreeChild !== null) {
-            // Something in the child tree is dynamic.
-            childNeedsDynamicRequest = true;
-            dynamicRequestTreeChildren[parallelRouteKey] = dynamicRequestTreeChild;
-        } else {
-            dynamicRequestTreeChildren[parallelRouteKey] = taskChildRoute;
+    let newCacheNodeSlots = null;
+    if (newSlots !== null) {
+        const oldCacheNodeSlots = oldCacheNode !== undefined ? oldCacheNode.slots : null;
+        newCacheNode.slots = newCacheNodeSlots = {};
+        taskChildren = new Map();
+        for(let parallelRouteKey in newSlots){
+            let newRouteTreeChild = newSlots[parallelRouteKey];
+            const oldRouterStateChild = oldRouterStateChildren[parallelRouteKey];
+            if (oldRouterStateChild === undefined) {
+                // This should never happen, but if it does, it suggests a malformed
+                // server response. Trigger a full-page navigation.
+                return null;
+            }
+            let seedDataChild = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] : null;
+            const oldSegmentChild = oldRouterStateChild[0];
+            let newSegmentChild = createSegmentFromRouteTree(newRouteTreeChild);
+            let seedHeadChild = seedHead;
+            if (// Skip this branch during a history traversal. We restore the tree that
+            // was stashed in the history entry as-is.
+            freshness !== 2 && newSegmentChild === _segment.DEFAULT_SEGMENT_KEY && oldSegmentChild !== _segment.DEFAULT_SEGMENT_KEY) {
+                // This is a "default" segment. These are never sent by the server during
+                // a soft navigation; instead, the client reuses whatever segment was
+                // already active in that slot on the previous route.
+                newRouteTreeChild = reuseActiveSegmentInDefaultSlot(newRouteTree, parallelRouteKey, oldRootRefreshState, oldRouterStateChild);
+                newSegmentChild = createSegmentFromRouteTree(newRouteTreeChild);
+                // Since we're switching to a different route tree, these are no
+                // longer valid, because they correspond to the outer tree.
+                seedDataChild = null;
+                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);
+            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
+                // full-page navigation.
+                return null;
+            }
+            // Recursively propagate up the child tasks.
+            taskChildren.set(parallelRouteKey, taskChild);
+            newCacheNodeSlots[parallelRouteKey] = taskChild.node;
+            // The child tree's route state may be different from the prefetched
+            // route sent by the server. We need to clone it as we traverse back up
+            // the tree.
+            const taskChildRoute = taskChild.route;
+            patchedRouterStateChildren[parallelRouteKey] = taskChildRoute;
+            const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
+            if (dynamicRequestTreeChild !== null) {
+                // Something in the child tree is dynamic.
+                childNeedsDynamicRequest = true;
+                dynamicRequestTreeChildren[parallelRouteKey] = dynamicRequestTreeChild;
+            } else {
+                dynamicRequestTreeChildren[parallelRouteKey] = taskChildRoute;
+            }
         }
     }
+    const newFlightRouterState = [
+        createSegmentFromRouteTree(newRouteTree),
+        patchedRouterStateChildren,
+        refreshState !== null ? [
+            refreshState.canonicalUrl,
+            refreshState.renderedSearch
+        ] : null,
+        null,
+        newRouteTree.prefetchHints
+    ];
     return {
         status: needsDynamicRequest ? 0 : 1,
-        route: patchRouterStateWithNewChildren(newRouterState, patchedRouterStateChildren),
+        route: newFlightRouterState,
         node: newCacheNode,
-        dynamicRequestTree: createDynamicRequestTree(newRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest),
-        refreshUrl,
+        dynamicRequestTree: createDynamicRequestTree(newFlightRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest),
+        refreshState,
         children: taskChildren
     };
 }
-function createCacheNodeOnNavigation(navigatedAt, newRouterState, oldCacheNode, freshness, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, parentSegmentPath, parentParallelRouteKey, parentNeedsDynamicRequest, accumulation) {
-    // 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
-    // one. We also don't need to worry about any refresh-related logic.
-    //
-    // For the most part, this is a subset of updateCacheNodeOnNavigation, so any
-    // change that happens in this function likely needs to be applied to that
-    // one, too. However there are some places where the behavior intentionally
-    // diverges, which is why we keep them separate.
-    const newSegment = newRouterState[0];
-    const segmentPath = parentParallelRouteKey !== null && parentSegmentPath !== null ? parentSegmentPath.concat([
-        parentParallelRouteKey,
-        newSegment
-    ]) : [];
-    const newRouterStateChildren = newRouterState[1];
-    const prefetchDataChildren = prefetchData !== null ? prefetchData[1] : null;
-    const seedDataChildren = seedData !== null ? seedData[1] : null;
-    const oldParallelRoutes = oldCacheNode !== undefined ? oldCacheNode.parallelRoutes : undefined;
-    let shouldDropSiblingCaches = false;
-    let shouldRefreshDynamicData = false;
-    let dropPrefetchRsc = false;
+/**
+ * Assigns a ScrollRef to a new leaf CacheNode so the scroll handler
+ * knows to scroll to it after navigation. All leaves in the same
+ * navigation share the same ScrollRef — the first segment to scroll
+ * consumes it, preventing others from also scrolling.
+ *
+ * This is only called inside `createCacheNodeOnNavigation`, which only
+ * runs when segments diverge from the previous route. So for a refresh
+ * where the route structure stays the same, segments match, the update
+ * path is taken, and this function is never called — no scroll ref is
+ * assigned. A scroll ref is only assigned when the route actually
+ * changed (e.g. a redirect, or a dynamic condition on the server that
+ * produces a different route).
+ *
+ * Skipped during hydration (initial render should not scroll) and
+ * history traversal (scroll restoration is handled separately).
+ */ function accumulateScrollRef(freshness, cacheNode, accumulation) {
     switch(freshness){
         case 0:
-            // We should never drop dynamic data in sibling caches except during
-            // a refresh.
-            shouldDropSiblingCaches = false;
-            // Only reuse the dynamic data if experimental.staleTimes.dynamic config
-            // is set, and the data is not stale. (This is not a recommended API with
-            // Cache Components, but it's supported for backwards compatibility. Use
-            // cacheLife instead.)
-            //
-            // DYNAMIC_STALETIME_MS defaults to 0, but it can be increased.
-            shouldRefreshDynamicData = oldCacheNode === undefined || navigatedAt - oldCacheNode.navigatedAt >= _navigatereducer.DYNAMIC_STALETIME_MS;
-            dropPrefetchRsc = false;
+        case 5:
+        case 3:
+        case 4:
+            if (accumulation.scrollRef === null) {
+                accumulation.scrollRef = {
+                    current: true
+                };
+            }
+            cacheNode.scrollRef = accumulation.scrollRef;
             break;
         case 1:
-            // During hydration, we assume the data sent by the server is both
-            // consistent and complete.
-            shouldRefreshDynamicData = false;
-            shouldDropSiblingCaches = false;
-            dropPrefetchRsc = false;
             break;
         case 2:
-            // During back/forward navigations, we reuse the dynamic data regardless
-            // of how stale it may be.
-            shouldRefreshDynamicData = false;
-            shouldRefreshDynamicData = false;
-            // Only show prefetched data if the dynamic data is still pending. This
-            // avoids a flash back to the prefetch state in a case where it's highly
-            // likely to have already streamed in.
-            //
-            // Tehnically, what we're actually checking is whether the dynamic network
-            // response was received. But since it's a streaming response, this does
-            // not mean that all the dynamic data has fully streamed in. It just means
-            // that _some_ of the dynamic data was received. But as a heuristic, we
-            // assume that the rest dynamic data will stream in quickly, so it's still
-            // better to skip the prefetch state.
-            if (oldCacheNode !== undefined) {
-                const oldRsc = oldCacheNode.rsc;
-                const oldRscDidResolve = !isDeferredRsc(oldRsc) || oldRsc.status !== 'pending';
-                dropPrefetchRsc = oldRscDidResolve;
-            } else {
-                dropPrefetchRsc = false;
-            }
-            break;
-        case 3:
-        case 4:
-            // Drop all dynamic data.
-            shouldRefreshDynamicData = true;
-            shouldDropSiblingCaches = true;
-            dropPrefetchRsc = false;
             break;
         default:
             freshness;
             break;
     }
-    const newParallelRoutes = new Map(shouldDropSiblingCaches ? undefined : oldParallelRoutes);
-    const isLeafSegment = Object.keys(newRouterStateChildren).length === 0;
+}
+function createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation) {
+    // 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
+    // one. We also don't need to worry about any refresh-related logic.
+    //
+    // For the most part, this is a subset of updateCacheNodeOnNavigation, so any
+    // change that happens in this function likely needs to be applied to that
+    // one, too. However there are some places where the behavior intentionally
+    // diverges, which is why we keep them separate.
+    const newSegment = createSegmentFromRouteTree(newRouteTree);
+    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 newCacheNode = result.cacheNode;
+    const needsDynamicRequest = result.needsDynamicRequest;
+    const isLeafSegment = newSlots === null;
     if (isLeafSegment) {
-        // The segment path of every leaf segment (i.e. page) is collected into
-        // a result array. This is used by the LayoutRouter to scroll to ensure that
-        // new pages are visible after a navigation.
-        //
-        // This only happens for new pages, not for refreshed pages.
-        //
-        // TODO: We should use a string to represent the segment path instead of
-        // an array. We already use a string representation for the path when
-        // accessing the Segment Cache, so we can use the same one.
-        if (accumulation.scrollableSegments === null) {
-            accumulation.scrollableSegments = [];
-        }
-        accumulation.scrollableSegments.push(segmentPath);
-    }
-    let newCacheNode;
-    let needsDynamicRequest;
-    if (!shouldRefreshDynamicData && oldCacheNode !== undefined) {
-        // Reuse the existing CacheNode
-        newCacheNode = reuseDynamicCacheNode(dropPrefetchRsc, oldCacheNode, newParallelRoutes);
-        needsDynamicRequest = false;
-    } else if (seedData !== null && seedData[0] !== null) {
-        // If this navigation was the result of an action, then check if the
-        // server sent back data in the action response. We should favor using
-        // that, rather than performing a separate request. This is both better
-        // for performance and it's more likely to be consistent with any
-        // writes that were just performed by the action, compared to a
-        // separate request.
-        const seedRsc = seedData[0];
-        const seedLoading = seedData[2];
-        const isSeedRscPartial = false;
-        const isSeedHeadPartial = seedHead === null && freshness !== 1;
-        newCacheNode = readCacheNodeFromSeedData(seedRsc, seedLoading, isSeedRscPartial, seedHead, isSeedHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
-        needsDynamicRequest = isLeafSegment && isSeedHeadPartial;
-    } else if (freshness === 1 && isLeafSegment && seedHead !== null) {
-        // This is another weird case related to "not found" pages and hydration.
-        // There will be a head sent by the server, but no page seed data.
-        // TODO: We really should get rid of all these "not found" specific quirks
-        // and make sure the tree is always consistent.
-        const seedRsc = null;
-        const seedLoading = null;
-        const isSeedRscPartial = false;
-        const isSeedHeadPartial = false;
-        newCacheNode = readCacheNodeFromSeedData(seedRsc, seedLoading, isSeedRscPartial, seedHead, isSeedHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
-        needsDynamicRequest = false;
-    } else if (freshness !== 1 && prefetchData !== null) {
-        // Consult the prefetch cache.
-        const prefetchRsc = prefetchData[0];
-        const prefetchLoading = prefetchData[2];
-        const isPrefetchRSCPartial = prefetchData[3];
-        newCacheNode = readCacheNodeFromSeedData(prefetchRsc, prefetchLoading, isPrefetchRSCPartial, prefetchHead, isPrefetchHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
-        needsDynamicRequest = isPrefetchRSCPartial || isLeafSegment && isPrefetchHeadPartial;
-    } else {
-        // Spawn a request to fetch new data from the server.
-        newCacheNode = spawnNewCacheNode(newParallelRoutes, isLeafSegment, navigatedAt, freshness);
-        needsDynamicRequest = true;
+        accumulateScrollRef(freshness, newCacheNode, accumulation);
     }
     let patchedRouterStateChildren = {};
     let taskChildren = null;
     let childNeedsDynamicRequest = false;
     let dynamicRequestTreeChildren = {};
-    for(let parallelRouteKey in newRouterStateChildren){
-        const newRouterStateChild = newRouterStateChildren[parallelRouteKey];
-        const oldSegmentMapChild = oldParallelRoutes !== undefined ? oldParallelRoutes.get(parallelRouteKey) : undefined;
-        const seedDataChild = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] : null;
-        const prefetchDataChild = prefetchDataChildren !== null ? prefetchDataChildren[parallelRouteKey] : null;
-        const newSegmentChild = newRouterStateChild[0];
-        const newSegmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(newSegmentChild);
-        const oldCacheNodeChild = oldSegmentMapChild !== undefined ? oldSegmentMapChild.get(newSegmentKeyChild) : undefined;
-        const taskChild = createCacheNodeOnNavigation(navigatedAt, newRouterStateChild, oldCacheNodeChild, freshness, seedDataChild ?? null, seedHead, prefetchDataChild ?? null, prefetchHead, isPrefetchHeadPartial, segmentPath, parallelRouteKey, parentNeedsDynamicRequest || needsDynamicRequest, accumulation);
-        if (taskChildren === null) {
-            taskChildren = new Map();
-        }
-        taskChildren.set(parallelRouteKey, taskChild);
-        const newCacheNodeChild = taskChild.node;
-        if (newCacheNodeChild !== null) {
-            const newSegmentMapChild = new Map(shouldDropSiblingCaches ? undefined : oldSegmentMapChild);
-            newSegmentMapChild.set(newSegmentKeyChild, newCacheNodeChild);
-            newParallelRoutes.set(parallelRouteKey, newSegmentMapChild);
-        }
-        const taskChildRoute = taskChild.route;
-        patchedRouterStateChildren[parallelRouteKey] = taskChildRoute;
-        const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
-        if (dynamicRequestTreeChild !== null) {
-            childNeedsDynamicRequest = true;
-            dynamicRequestTreeChildren[parallelRouteKey] = dynamicRequestTreeChild;
-        } else {
-            dynamicRequestTreeChildren[parallelRouteKey] = taskChildRoute;
+    let newCacheNodeSlots = null;
+    if (newSlots !== null) {
+        newCacheNode.slots = newCacheNodeSlots = {};
+        taskChildren = new Map();
+        for(let parallelRouteKey in newSlots){
+            const newRouteTreeChild = newSlots[parallelRouteKey];
+            const seedDataChild = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] : null;
+            const taskChild = createCacheNodeOnNavigation(navigatedAt, newRouteTreeChild, newMetadataVaryPath, freshness, seedDataChild ?? null, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest || needsDynamicRequest, accumulation);
+            taskChildren.set(parallelRouteKey, taskChild);
+            newCacheNodeSlots[parallelRouteKey] = taskChild.node;
+            const taskChildRoute = taskChild.route;
+            patchedRouterStateChildren[parallelRouteKey] = taskChildRoute;
+            const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
+            if (dynamicRequestTreeChild !== null) {
+                childNeedsDynamicRequest = true;
+                dynamicRequestTreeChildren[parallelRouteKey] = dynamicRequestTreeChild;
+            } else {
+                dynamicRequestTreeChildren[parallelRouteKey] = taskChildRoute;
+            }
         }
     }
+    const newFlightRouterState = [
+        newSegment,
+        patchedRouterStateChildren,
+        null,
+        null,
+        newRouteTree.prefetchHints
+    ];
     return {
         status: needsDynamicRequest ? 0 : 1,
-        route: patchRouterStateWithNewChildren(newRouterState, patchedRouterStateChildren),
+        route: newFlightRouterState,
         node: newCacheNode,
-        dynamicRequestTree: createDynamicRequestTree(newRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest),
+        dynamicRequestTree: createDynamicRequestTree(newFlightRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest),
         // This route is not part of the current tree, so there's no reason to
         // track the refresh URL.
-        refreshUrl: null,
+        refreshState: null,
         children: taskChildren
     };
 }
+function createSegmentFromRouteTree(newRouteTree) {
+    if (newRouteTree.isPage) {
+        // In a dynamic server response, the server embeds the search params into
+        // the segment key, but in a static one it's omitted. The client handles
+        // this inconsistency by adding the search params back right at the end.
+        //
+        // TODO: The only thing this is used for is to create a cache key for
+        // ChildSegmentMap. But we already track the `renderedSearch` everywhere as
+        // part of the varyPath. The plan is get rid of ChildSegmentMap and
+        // store the page data in a CacheMap using the varyPath, like we do
+        // for prefetches. Then we can remove it from the segment key.
+        //
+        // As an incremental step, we can grab the search params from the varyPath.
+        const renderedSearch = (0, _varypath.getRenderedSearchFromVaryPath)(newRouteTree.varyPath);
+        if (renderedSearch === null) {
+            return _segment.PAGE_SEGMENT_KEY;
+        }
+        // This is based on equivalent logic in addSearchParamsIfPageSegment, used
+        // on the server.
+        const stringifiedQuery = JSON.stringify(Object.fromEntries(new URLSearchParams(renderedSearch)));
+        return stringifiedQuery !== '{}' ? _segment.PAGE_SEGMENT_KEY + '?' + stringifiedQuery : _segment.PAGE_SEGMENT_KEY;
+    }
+    return newRouteTree.segment;
+}
 function patchRouterStateWithNewChildren(baseRouterState, newChildren) {
     const clone = [
         baseRouterState[0],
@@ -559,7 +460,7 @@ function createDynamicRequestTree(newRouterState, dynamicRequestTreeChildren, ne
     }
     return dynamicRequestTree;
 }
-function accumulateRefreshUrl(accumulation, refreshUrl) {
+function accumulateRefreshUrl(accumulation, refreshState) {
     // This is a refresh navigation, and we're inside a "default" slot that's
     // not part of the current route; it was reused from an older route. In
     // order to get fresh data for this reused route, we need to issue a
@@ -570,6 +471,7 @@ function accumulateRefreshUrl(accumulation, refreshUrl) {
     // we don't do it immediately here is so we can deduplicate multiple
     // instances of the same URL into a single request. See
     // listenForDynamicRequest for more details.
+    const refreshUrl = refreshState.canonicalUrl;
     const separateRefreshUrls = accumulation.separateRefreshUrls;
     if (separateRefreshUrls === null) {
         accumulation.separateRefreshUrls = new Set([
@@ -579,123 +481,347 @@ function accumulateRefreshUrl(accumulation, refreshUrl) {
         separateRefreshUrls.add(refreshUrl);
     }
 }
-function reuseActiveSegmentInDefaultSlot(oldUrl, oldRouterState) {
+function reuseActiveSegmentInDefaultSlot(parentRouteTree, parallelRouteKey, oldRootRefreshState, oldRouterState) {
     // This is a "default" segment. These are never sent by the server during a
     // soft navigation; instead, the client reuses whatever segment was already
     // active in that slot on the previous route. This means if we later need to
     // refresh the segment, it will have to be refetched from the previous route's
     // URL. We store it in the Flight Router State.
-    //
-    // TODO: We also mark the segment with a "refresh" marker but I think we can
-    // get rid of that eventually by making sure we only add URLs to page segments
-    // that are reused. Then the presence of the URL alone is enough.
-    let reusedRouterState;
-    const oldRefreshMarker = oldRouterState[3];
-    if (oldRefreshMarker === 'refresh') {
+    let reusedUrl;
+    let reusedRenderedSearch;
+    const oldRefreshState = oldRouterState[2];
+    if (oldRefreshState !== undefined && oldRefreshState !== null) {
         // This segment was already reused from an even older route. Keep its
-        // existing URL and refresh marker.
-        reusedRouterState = oldRouterState;
+        // existing URL and refresh state.
+        reusedUrl = oldRefreshState[0];
+        reusedRenderedSearch = oldRefreshState[1];
     } else {
-        // This segment was not previously reused, and it's not on the new route.
-        // So it must have been delivered in the old route.
-        reusedRouterState = patchRouterStateWithNewChildren(oldRouterState, oldRouterState[1]);
-        reusedRouterState[2] = (0, _createhreffromurl.createHrefFromUrl)(oldUrl);
-        reusedRouterState[3] = 'refresh';
+        // Since this route didn't already have a refresh state, it must have been
+        // reachable from the root of the old route. So we use the refresh state
+        // that represents the old route.
+        reusedUrl = oldRootRefreshState.canonicalUrl;
+        reusedRenderedSearch = oldRootRefreshState.renderedSearch;
     }
-    return reusedRouterState;
-}
-function reuseDynamicCacheNode(dropPrefetchRsc, existingCacheNode, parallelRoutes) {
-    // Clone an existing CacheNode's data, with (possibly) new children.
-    const cacheNode = {
-        rsc: existingCacheNode.rsc,
-        prefetchRsc: dropPrefetchRsc ? null : existingCacheNode.prefetchRsc,
-        head: existingCacheNode.head,
-        prefetchHead: dropPrefetchRsc ? null : existingCacheNode.prefetchHead,
-        loading: existingCacheNode.loading,
-        parallelRoutes,
-        // Don't update the navigatedAt timestamp, since we're reusing
-        // existing data.
-        navigatedAt: existingCacheNode.navigatedAt
+    const acc = {
+        metadataVaryPath: null
     };
-    return cacheNode;
+    const reusedRouteTree = (0, _cache.convertReusedFlightRouterStateToRouteTree)(parentRouteTree, parallelRouteKey, oldRouterState, reusedRenderedSearch, acc);
+    reusedRouteTree.refreshState = {
+        canonicalUrl: reusedUrl,
+        renderedSearch: reusedRenderedSearch
+    };
+    return reusedRouteTree;
 }
-function readCacheNodeFromSeedData(seedRsc, seedLoading, isSeedRscPartial, seedHead, isSeedHeadPartial, isPageSegment, parallelRoutes, navigatedAt) {
-    // TODO: Currently this is threaded through the navigation logic using the
-    // CacheNodeSeedData type, but in the future this will read directly from
-    // the Segment Cache. See readRenderSnapshotFromCache.
-    let rsc;
+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);
+}
+function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHead, freshness, dynamicStaleAt) {
+    // Construct a new CacheNode using data from the BFCache, the client's
+    // Segment Cache, or seeded from a server response.
+    //
+    // If there's a cache miss, or if we only have a partial hit, we'll render
+    // the partial state immediately, and spawn a request to the server to fill
+    // in the missing data.
+    //
+    // If the segment is fully cached on the client already, we can omit this
+    // segment from the server request.
+    //
+    // If we already have a dynamic data response associated with this navigation,
+    // as in the case of a Server Action-initiated redirect or refresh, we may
+    // also be able to use that data without spawning a new request. (This is
+    // referred to as the "seed" data.)
+    const isPage = tree.isPage;
+    // During certain kinds of navigations, we may be able to render from
+    // the BFCache.
+    switch(freshness){
+        case 0:
+            {
+                // Check BFCache during regular navigations. The entry's staleAt
+                // determines whether it's still fresh. This is used when
+                // staleTimes.dynamic is configured globally or when a page exports
+                // unstable_dynamicStaleTime for per-page control.
+                const bfcacheEntry = (0, _bfcache.readFromBFCacheDuringRegularNavigation)(now, tree.varyPath);
+                if (bfcacheEntry !== null) {
+                    return {
+                        cacheNode: createCacheNode(bfcacheEntry.rsc, bfcacheEntry.prefetchRsc, bfcacheEntry.head, bfcacheEntry.prefetchHead),
+                        needsDynamicRequest: false
+                    };
+                }
+                break;
+            }
+        case 1:
+            {
+                // This is not related to the BFCache but it is a special case.
+                //
+                // We should never spawn network requests during hydration. We must treat
+                // the initial payload as authoritative, because the initial page load is
+                // used as a last-ditch mechanism for recovering the app.
+                //
+                // This is also an important safety check because if this leaks into the
+                // server rendering path (which theoretically it never should because the
+                // server payload should be consistent), the server would hang because these
+                // promises would never resolve.
+                //
+                // TODO: There is an existing case where the global "not found" boundary
+                // triggers this path. But it does render correctly despite that. That's an
+                // unusual render path so it's not surprising, but we should look into
+                // modeling it in a more consistent way. See also the /_notFound special
+                // case in updateCacheNodeOnNavigation.
+                const rsc = seedRsc;
+                const prefetchRsc = null;
+                const head = isPage ? seedHead : null;
+                const prefetchHead = null;
+                (0, _bfcache.writeToBFCache)(now, tree.varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt);
+                if (isPage && metadataVaryPath !== null) {
+                    (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt);
+                }
+                return {
+                    cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead),
+                    needsDynamicRequest: false
+                };
+            }
+        case 2:
+            const bfcacheEntry = (0, _bfcache.readFromBFCache)(tree.varyPath);
+            if (bfcacheEntry !== null) {
+                // Only show prefetched data if the dynamic data is still pending. This
+                // avoids a flash back to the prefetch state in a case where it's highly
+                // likely to have already streamed in.
+                //
+                // Tehnically, what we're actually checking is whether the dynamic
+                // network response was received. But since it's a streaming response,
+                // this does not mean that all the dynamic data has fully streamed in.
+                // It just means that _some_ of the dynamic data was received. But as a
+                // heuristic, we assume that the rest dynamic data will stream in
+                // quickly, so it's still better to skip the prefetch state.
+                const oldRsc = bfcacheEntry.rsc;
+                const oldRscDidResolve = !isDeferredRsc(oldRsc) || oldRsc.status !== 'pending';
+                const dropPrefetchRsc = oldRscDidResolve;
+                return {
+                    cacheNode: createCacheNode(bfcacheEntry.rsc, dropPrefetchRsc ? null : bfcacheEntry.prefetchRsc, bfcacheEntry.head, dropPrefetchRsc ? null : bfcacheEntry.prefetchHead),
+                    needsDynamicRequest: false
+                };
+            }
+            break;
+        case 3:
+        case 4:
+        case 5:
+            break;
+        default:
+            freshness;
+            break;
+    }
+    let cachedRsc = null;
+    let isCachedRscPartial = true;
+    const segmentEntry = (0, _cache.readSegmentCacheEntry)(now, tree.varyPath);
+    if (segmentEntry !== null) {
+        switch(segmentEntry.status){
+            case _cache.EntryStatus.Fulfilled:
+                {
+                    // Happy path: a cache hit
+                    cachedRsc = segmentEntry.rsc;
+                    isCachedRscPartial = segmentEntry.isPartial;
+                    break;
+                }
+            case _cache.EntryStatus.Pending:
+                {
+                    // We haven't received data for this segment yet, but there's already
+                    // an in-progress request. Since it's extremely likely to arrive
+                    // before the dynamic data response, we might as well use it.
+                    const promiseForFulfilledEntry = (0, _cache.waitForSegmentCacheEntry)(segmentEntry);
+                    cachedRsc = promiseForFulfilledEntry.then((entry)=>entry !== null ? entry.rsc : null);
+                    // Because the request is still pending, we typically don't know yet
+                    // whether the response will be partial. We shouldn't skip this segment
+                    // during the dynamic navigation request. Otherwise, we might need to
+                    // do yet another request to fill in the remaining data, creating
+                    // a waterfall.
+                    //
+                    // The one exception is if this segment is being fetched with via
+                    // prefetch={true} (i.e. the "force stale" or "full" strategy). If so,
+                    // we can assume the response will be full. This field is set to `false`
+                    // for such segments.
+                    isCachedRscPartial = segmentEntry.isPartial;
+                    break;
+                }
+            case _cache.EntryStatus.Empty:
+            case _cache.EntryStatus.Rejected:
+                {
+                    break;
+                }
+            default:
+                {
+                    segmentEntry;
+                    break;
+                }
+        }
+    }
+    // Now combine the cached data with the seed data to determine what we can
+    // render immediately, versus what needs to stream in later.
+    // A partial state to show immediately while we wait for the final data to
+    // arrive. If `rsc` is already a complete value (not partial), or if we
+    // don't have any useful partial state, this will be `null`.
     let prefetchRsc;
-    if (isSeedRscPartial) {
-        // The prefetched data contains dynamic holes. Create a pending promise that
-        // will be fulfilled when the dynamic data is received from the server.
-        prefetchRsc = seedRsc;
-        rsc = createDeferredRsc();
+    // The final, resolved segment data. If the data is missing, this will be a
+    // promise that resolves to the eventual data. A resolved value of `null`
+    // means the data failed to load; the LayoutRouter will suspend indefinitely
+    // until the router updates again (refer to finishNavigationTask).
+    let rsc;
+    let doesSegmentNeedDynamicRequest;
+    if (seedRsc !== null) {
+        // We already have a dynamic server response for this segment.
+        if (isCachedRscPartial) {
+            // The seed data may still be streaming in, so it's worth showing the
+            // partial cached state in the meantime.
+            prefetchRsc = cachedRsc;
+            rsc = seedRsc;
+        } else {
+            // We already have a completely cached segment. Ignore the seed data,
+            // which may still be streaming in. This shouldn't happen in the normal
+            // case because the client will inform the server which segments are
+            // already fully cached, and the server will skip rendering them.
+            prefetchRsc = null;
+            rsc = cachedRsc;
+        }
+        doesSegmentNeedDynamicRequest = false;
     } else {
-        // The prefetched data is complete. Use it directly.
-        prefetchRsc = null;
-        rsc = seedRsc;
+        if (isCachedRscPartial) {
+            // The cached data contains dynamic holes, or it's missing entirely. We'll
+            // show the partial state immediately (if available), and stream in the
+            // final data.
+            //
+            // Create a pending promise that we can later write to when the
+            // data arrives from the server.
+            prefetchRsc = cachedRsc;
+            rsc = createDeferredRsc();
+        } else {
+            // The data is fully cached.
+            prefetchRsc = null;
+            rsc = cachedRsc;
+        }
+        doesSegmentNeedDynamicRequest = isCachedRscPartial;
     }
-    // If this is a page segment, also read the head.
-    let prefetchHead;
-    let head;
-    if (isPageSegment) {
-        if (isSeedHeadPartial) {
-            prefetchHead = seedHead;
-            head = createDeferredRsc();
+    // If this is a page segment, we need to do the same for the head. This
+    // follows analogous logic to the segment data above.
+    // TODO: We don't need to store the head on the page segment's CacheNode; we
+    // can lift it to the main state object. Then we can also delete
+    // findHeadCache.
+    let prefetchHead = null;
+    let head = null;
+    let doesHeadNeedDynamicRequest = isPage;
+    if (isPage) {
+        let cachedHead = null;
+        let isCachedHeadPartial = true;
+        if (metadataVaryPath !== null) {
+            const metadataEntry = (0, _cache.readSegmentCacheEntry)(now, metadataVaryPath);
+            if (metadataEntry !== null) {
+                switch(metadataEntry.status){
+                    case _cache.EntryStatus.Fulfilled:
+                        {
+                            cachedHead = metadataEntry.rsc;
+                            isCachedHeadPartial = metadataEntry.isPartial;
+                            break;
+                        }
+                    case _cache.EntryStatus.Pending:
+                        {
+                            cachedHead = (0, _cache.waitForSegmentCacheEntry)(metadataEntry).then((entry)=>entry !== null ? entry.rsc : null);
+                            isCachedHeadPartial = metadataEntry.isPartial;
+                            break;
+                        }
+                    case _cache.EntryStatus.Empty:
+                    case _cache.EntryStatus.Rejected:
+                        {
+                            break;
+                        }
+                    default:
+                        {
+                            metadataEntry;
+                            break;
+                        }
+                }
+            }
+        }
+        if (process.env.__NEXT_OPTIMISTIC_ROUTING && isCachedHeadPartial) {
+            // TODO: When optimistic routing is enabled, don't block on waiting for
+            // the viewport to resolve. This is a temporary workaround until Vary
+            // Params are tracked when rendering the metadata. We'll fix it before
+            // this feature is stable. However, it's not a critical issue because 1)
+            // it will stream in eventually anyway 2) metadata is wrapped in an
+            // internal Suspense boundary, so is always non-blocking; this only
+            // affects the viewport node, which is meant to blocking, however... 3)
+            // before Segment Cache landed this wasn't always the case, anyway, so
+            // it's unlikely that many people are relying on this behavior. Still,
+            // will be fixed before stable. It's the very next step in the sequence of
+            // work on this project.
+            //
+            // This line of code works because the App Router treats `null` as
+            // "no renderable head available", rather than an empty head. React treats
+            // an empty string as empty.
+            cachedHead = '';
+        }
+        if (seedHead !== null) {
+            if (isCachedHeadPartial) {
+                prefetchHead = cachedHead;
+                head = seedHead;
+            } else {
+                prefetchHead = null;
+                head = cachedHead;
+            }
+            doesHeadNeedDynamicRequest = false;
         } else {
-            prefetchHead = null;
-            head = seedHead;
+            if (isCachedHeadPartial) {
+                prefetchHead = cachedHead;
+                head = createDeferredRsc();
+            } else {
+                prefetchHead = null;
+                head = cachedHead;
+            }
+            doesHeadNeedDynamicRequest = isCachedHeadPartial;
         }
-    } else {
-        prefetchHead = null;
-        head = null;
     }
-    const cacheNode = {
+    // Now that we're creating a new segment, write its data to the BFCache. A
+    // subsequent back/forward navigation will reuse this same data, until or
+    // unless it's cleared by a refresh/revalidation.
+    //
+    // 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);
+        if (isPage && metadataVaryPath !== null) {
+            (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt);
+        }
+    }
+    return {
+        cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead),
+        // 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) {
+    return {
         rsc,
         prefetchRsc,
         head,
         prefetchHead,
-        // TODO: Technically, a loading boundary could contain dynamic data. We
-        // should have separate `loading` and `prefetchLoading` fields to handle
-        // this, like we do for the segment data and head.
-        loading: seedLoading,
-        parallelRoutes,
-        navigatedAt
+        slots: null,
+        scrollRef
     };
-    return cacheNode;
-}
-function spawnNewCacheNode(parallelRoutes, isLeafSegment, navigatedAt, freshness) {
-    // We should never spawn network requests during hydration. We must treat the
-    // initial payload as authoritative, because the initial page load is used
-    // as a last-ditch mechanism for recovering the app.
-    //
-    // This is also an important safety check because if this leaks into the
-    // server rendering path (which theoretically it never should because
-    // the server payload should be consistent), the server would hang because
-    // these promises would never resolve.
-    //
-    // TODO: There is an existing case where the global "not found" boundary
-    // triggers this path. But it does render correctly despite that. That's an
-    // unusual render path so it's not surprising, but we should look into
-    // modeling it in a more consistent way. See also the /_notFound special
-    // case in updateCacheNodeOnNavigation.
-    const isHydration = freshness === 1;
-    const cacheNode = {
-        rsc: !isHydration ? createDeferredRsc() : null,
-        prefetchRsc: null,
-        head: !isHydration && isLeafSegment ? createDeferredRsc() : null,
-        prefetchHead: null,
-        loading: !isHydration ? createDeferredRsc() : null,
-        parallelRoutes,
-        navigatedAt
-    };
-    return cacheNode;
 }
 // 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.
 let previousNavigationDidMismatch = false;
-function spawnDynamicRequests(task, primaryUrl, nextUrl, freshnessPolicy, accumulation) {
+function spawnDynamicRequests(task, primaryUrl, nextUrl, freshnessPolicy, accumulation, // 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 than expected (indicating
+// dynamic rewrite behavior that varies by param value).
+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) {
     const dynamicRequestTree = task.dynamicRequestTree;
     if (dynamicRequestTree === null) {
         // This navigation was fully cached. There are no dynamic requests to spawn.
@@ -711,7 +837,7 @@ function spawnDynamicRequests(task, primaryUrl, nextUrl, freshnessPolicy, accumu
     // 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);
+    const primaryRequestPromise = fetchMissingDynamicData(task, dynamicRequestTree, primaryUrl, nextUrl, freshnessPolicy, routeCacheEntry);
     const separateRefreshUrls = accumulation.separateRefreshUrls;
     let refreshRequestPromises = null;
     if (separateRefreshUrls !== null) {
@@ -746,18 +872,18 @@ function spawnDynamicRequests(task, primaryUrl, nextUrl, freshnessPolicy, accumu
                 // 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));
+                nextUrl, freshnessPolicy, routeCacheEntry));
             }
         }
     }
     // Further async operations are moved into this separate function to
     // discourage sequential network requests.
-    const voidPromise = finishNavigationTask(task, nextUrl, primaryRequestPromise, refreshRequestPromises);
+    const voidPromise = finishNavigationTask(task, nextUrl, primaryRequestPromise, refreshRequestPromises, routeCacheEntry, navigateType);
     // `finishNavigationTask` is responsible for error handling, so we can attach
     // noop callbacks to this promise.
     voidPromise.then(noop, noop);
 }
-async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refreshRequestPromises) {
+async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refreshRequestPromises, routeCacheEntry, navigateType) {
     // Wait for all the requests to finish, or for the first one to fail.
     let exitStatus = await waitForRequestsToFinish(primaryRequestPromise, refreshRequestPromises);
     // Once the all the requests have finished, check the tree for any remaining
@@ -784,7 +910,7 @@ async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refres
                 // 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);
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType);
                 return;
             }
         case 2:
@@ -799,7 +925,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);
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType);
                 return;
             }
         default:
@@ -848,22 +974,63 @@ function waitForRequestsToFinish(primaryRequestPromise, refreshRequestPromises)
         }
     });
 }
-function dispatchRetryDueToTreeMismatch(isHardRetry, retryUrl, retryNextUrl, seed, baseTree) {
+function dispatchRetryDueToTreeMismatch(isHardRetry, retryUrl, retryNextUrl, seed, baseTree, // The route cache entry used for this navigation, if it came from route
+// 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) {
+    // If the navigation used a route prediction, mark it as having a dynamic
+    // rewrite since it resulted in a mismatch.
+    if (routeCacheEntry !== null) {
+        (0, _cache.markRouteEntryAsDynamicRewrite)(routeCacheEntry);
+    } else if (seed !== null) {
+        // Even without a direct reference to the route cache entry, we can still
+        // mark the route as having a dynamic rewrite by traversing the known route
+        // tree. This handles cases where the navigation didn't originate from a
+        // route prediction, but still needs to mark the pattern.
+        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
+            );
+        }
+    }
+    // Invalidate all route cache entries. Other entries may have been derived
+    // from the template before we knew it had a dynamic rewrite. This also
+    // triggers re-prefetching of visible links.
+    (0, _cache.invalidateRouteCacheEntries)(retryNextUrl, baseTree);
     // If this is the second time in a row that a navigation resulted in a
     // mismatch, fall back to a hard (MPA) refresh.
     isHardRetry = isHardRetry || previousNavigationDidMismatch;
     previousNavigationDidMismatch = true;
+    // If the original navigation hasn't committed to the browser history yet
+    // (the transition suspended before React committed), inherit its push/replace
+    // intent. Otherwise, the pushState already ran, so use 'replace' to avoid
+    // creating a duplicate history entry.
+    //
+    // This works because React entangles the retry's state update with the
+    // original pending transition — they commit together as a single batch,
+    // so the navigate type from the retry is what HistoryUpdater ultimately sees.
+    //
+    // TODO: Ideally this check would happen right before we schedule the React
+    // update (i.e., closer to where the action is dispatched into the queue),
+    // not here where the action is constructed. But the current action queue
+    // doesn't provide a natural place for that. Revisit when we refactor the
+    // action queue into a more reactive navigation model.
+    const lastCommitted = (0, _committedstate.getLastCommittedTree)();
+    const retryNavigateType = lastCommitted !== null && baseTree !== lastCommitted ? originalNavigateType : 'replace';
     const retryAction = {
         type: _routerreducertypes.ACTION_SERVER_PATCH,
         previousTree: baseTree,
         url: retryUrl,
         nextUrl: retryNextUrl,
         seed,
-        mpa: isHardRetry
+        mpa: isHardRetry,
+        navigateType: retryNavigateType
     };
     (0, _useactionqueue.dispatchAppRouterAction)(retryAction);
 }
-async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, freshnessPolicy) {
+async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, freshnessPolicy, routeCacheEntry) {
     try {
         const result = await (0, _fetchserverresponse.fetchServerResponse)(url, {
             flightRouterState: dynamicRequestTree,
@@ -881,8 +1048,38 @@ async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, f
                 seed: null
             };
         }
-        const seed = (0, _navigation.convertServerPatchToFullTree)(task.route, result.flightData, result.renderedSearch);
-        const didReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(task, seed.tree, seed.data, seed.head, result.debugInfo);
+        const now = Date.now();
+        const seed = (0, _navigation.convertServerPatchToFullTree)(now, task.route, result.flightData, result.renderedSearch, result.dynamicStaleTime);
+        // 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 (routeCacheEntry !== null && result.staticStageData !== null) {
+            const { response: staticStageResponse, isResponsePartial } = result.staticStageData;
+            (0, _cache.getStaleAt)(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);
+            }).catch(()=>{
+            // The static stage processing failed. Not fatal — the navigation
+            // completed normally, we just won't write into the cache.
+            });
+        }
+        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);
+                }
+            }).catch(()=>{
+            // The runtime prefetch cache write failed. Not fatal — the
+            // navigation completed normally, we just won't cache runtime data.
+            });
+        }
+        // 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);
         return {
             exitStatus: didReceiveUnknownParallelRoute ? 1 : 0,
             url: new URL(result.canonicalUrl, location.origin),
@@ -899,47 +1096,61 @@ async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, f
         };
     }
 }
-function writeDynamicDataIntoNavigationTask(task, serverRouterState, dynamicData, dynamicHead, debugInfo) {
+function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData, dynamicHead, dynamicStaleAt, debugInfo) {
     if (task.status === 0 && dynamicData !== null) {
         task.status = 1;
         finishPendingCacheNode(task.node, dynamicData, dynamicHead, debugInfo);
+        // 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.
+        // We only update segments that received dynamic data — static segments
+        // are unaffected.
+        (0, _bfcache.updateBFCacheEntryStaleAt)(serverRouteTree.varyPath, dynamicStaleAt);
     }
     const taskChildren = task.children;
-    const serverChildren = serverRouterState[1];
+    const serverChildren = serverRouteTree.slots;
     const dynamicDataChildren = dynamicData !== null ? dynamicData[1] : null;
     // Detect whether the server sends a parallel route slot that the client
     // doesn't know about.
     let didReceiveUnknownParallelRoute = false;
     if (taskChildren !== null) {
-        for(const parallelRouteKey in serverChildren){
-            const serverRouterStateChild = serverChildren[parallelRouteKey];
-            const dynamicDataChild = dynamicDataChildren !== null ? dynamicDataChildren[parallelRouteKey] : null;
-            const taskChild = taskChildren.get(parallelRouteKey);
-            if (taskChild === undefined) {
-                // The server sent a child segment that the client doesn't know about.
-                //
-                // When we receive an unknown parallel route, we must consider it a
-                // mismatch. This is unlike the case where the segment itself
-                // mismatches, because multiple routes can be active simultaneously.
-                // But a given layout should never have a mismatching set of
-                // child slots.
-                //
-                // Theoretically, this should only happen in development during an HMR
-                // refresh, because the set of parallel routes for a layout does not
-                // change over the lifetime of a build/deployment. In production, we
-                // should have already mismatched on either the build id or the segment
-                // path. But as an extra precaution, we validate in prod, too.
-                didReceiveUnknownParallelRoute = true;
-            } else {
-                const taskSegment = taskChild.route[0];
-                if ((0, _matchsegments.matchSegment)(serverRouterStateChild[0], taskSegment) && dynamicDataChild !== null && dynamicDataChild !== undefined) {
-                    // Found a match for this task. Keep traversing down the task tree.
-                    const childDidReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(taskChild, serverRouterStateChild, dynamicDataChild, dynamicHead, debugInfo);
-                    if (childDidReceiveUnknownParallelRoute) {
-                        didReceiveUnknownParallelRoute = true;
+        if (serverChildren !== null) {
+            for(const parallelRouteKey in serverChildren){
+                const serverRouteTreeChild = serverChildren[parallelRouteKey];
+                const dynamicDataChild = dynamicDataChildren !== null ? dynamicDataChildren[parallelRouteKey] : null;
+                const taskChild = taskChildren.get(parallelRouteKey);
+                if (taskChild === undefined) {
+                    // The server sent a child segment that the client doesn't know about.
+                    //
+                    // When we receive an unknown parallel route, we must consider it a
+                    // mismatch. This is unlike the case where the segment itself
+                    // mismatches, because multiple routes can be active simultaneously.
+                    // But a given layout should never have a mismatching set of
+                    // child slots.
+                    //
+                    // Theoretically, this should only happen in development during an HMR
+                    // refresh, because the set of parallel routes for a layout does not
+                    // change over the lifetime of a build/deployment. In production, we
+                    // should have already mismatched on either the build id or the segment
+                    // path. But as an extra precaution, we validate in prod, too.
+                    didReceiveUnknownParallelRoute = true;
+                } else {
+                    const taskSegment = taskChild.route[0];
+                    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);
+                        if (childDidReceiveUnknownParallelRoute) {
+                            didReceiveUnknownParallelRoute = true;
+                        }
                     }
                 }
             }
+        } else {
+            if (serverChildren !== null) {
+                // The server sent a child segment that the client doesn't know about.
+                didReceiveUnknownParallelRoute = true;
+            }
         }
     }
     return didReceiveUnknownParallelRoute;
@@ -978,13 +1189,6 @@ function finishPendingCacheNode(cacheNode, dynamicData, dynamicHead, debugInfo)
     // 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.
     }
-    // If we navigated without a prefetch, then `loading` will be a deferred promise too.
-    // Fulfill it using the dynamic response so that we can display the loading boundary.
-    const loading = cacheNode.loading;
-    if (isDeferredRsc(loading)) {
-        const dynamicLoading = dynamicData[2];
-        loading.resolve(dynamicLoading, debugInfo);
-    }
     // Check if this is a leaf segment. If so, it will have a `head` property with
     // a pending promise that needs to be resolved with the dynamic head from
     // the server.
@@ -1011,7 +1215,7 @@ function abortRemainingPendingTasks(task, error, debugInfo) {
         //
         // When this happens, we treat this the same as a refresh(). The entire
         // tree will be re-rendered from the root.
-        if (task.refreshUrl === null) {
+        if (task.refreshState === null) {
             // Trigger a "soft" refresh. Essentially the same as calling `refresh()`
             // in a Server Action.
             exitStatus = 1;
@@ -1053,10 +1257,6 @@ function abortPendingCacheNode(cacheNode, error, debugInfo) {
             rsc.reject(error, debugInfo);
         }
     }
-    const loading = cacheNode.loading;
-    if (isDeferredRsc(loading)) {
-        loading.resolve(null, debugInfo);
-    }
     // Check if this is a leaf segment. If so, it will have a `head` property with
     // a pending promise that needs to be resolved. If an error was provided, we
     // will not resolve it with an error, since this is rendered at the root of
@@ -1119,6 +1319,18 @@ 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() {
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        const { waitForNavigationLockIfActive } = require('../segment-cache/navigation-testing-lock');
+        await waitForNavigationLockIfActive();
+    }
+}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });