failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/client/components/{router-reducer/ppr-navigations.js → render-tree.js}

@@ -5,7 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     FreshnessPolicy: null,
     beginLockedNavigation: null,
-    createInitialCacheNodeForHydration: null,
+    createInitialRenderTreeForHydration: null,
+    createRootNavigationTask: null,
     getCurrentNavigationLock: null,
     isDeferredRsc: null,
     resetNavigationLockToPending: null,
@@ -25,8 +26,11 @@ _export(exports, {
     beginLockedNavigation: function() {
         return beginLockedNavigation;
     },
-    createInitialCacheNodeForHydration: function() {
-        return createInitialCacheNodeForHydration;
+    createInitialRenderTreeForHydration: function() {
+        return createInitialRenderTreeForHydration;
+    },
+    createRootNavigationTask: function() {
+        return createRootNavigationTask;
     },
     getCurrentNavigationLock: function() {
         return getCurrentNavigationLock;
@@ -44,23 +48,26 @@ _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 _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 _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 _routeparams = require("../../route-params");
-const _varypath = require("../segment-cache/vary-path");
-const _bfcache = require("../segment-cache/bfcache");
+const _approutertypes = require("../../shared/lib/app-router-types");
+const _segment = require("../../shared/lib/segment");
+const _segmentvalueencoding = require("../../shared/lib/segment-cache/segment-value-encoding");
+const _createhreffromurl = require("./router-reducer/create-href-from-url");
+const _fetchserverresponse = require("./router-reducer/fetch-server-response");
+const _useactionqueue = require("./use-action-queue");
+const _routerreducertypes = require("./router-reducer/router-reducer-types");
+const _isnavigatingtonewrootlayout = require("./router-reducer/is-navigating-to-new-root-layout");
+const _committedstate = require("./router-reducer/reducers/committed-state");
+const _decodeserverresponse = require("./segment-cache/decode-server-response");
+const _cache = require("./segment-cache/cache");
+const _optimisticroutes = require("./segment-cache/optimistic-routes");
+const _varypath = require("./segment-cache/vary-path");
+const _bfcache = require("./segment-cache/bfcache");
+function createRootNavigationTask(tree, head) {
+    return {
+        tree,
+        head
+    };
+}
 var FreshnessPolicy = /*#__PURE__*/ function(FreshnessPolicy) {
     FreshnessPolicy[FreshnessPolicy["Default"] = 0] = "Default";
     FreshnessPolicy[FreshnessPolicy["Hydration"] = 1] = "Hydration";
@@ -71,19 +78,22 @@ var FreshnessPolicy = /*#__PURE__*/ function(FreshnessPolicy) {
     return FreshnessPolicy;
 }({});
 const noop = ()=>{};
-function createInitialCacheNodeForHydration(navigatedAt, initialTree, seedData, seedHead, seedDynamicStaleAt) {
+function createInitialRenderTreeForHydration(navigatedAt, initialRoot, seedDynamicStaleAt) {
     // Create the initial cache node tree, using the data embedded into the
     // HTML document.
     const accumulation = {
         separateRefreshUrls: null,
         scrollRef: null
     };
+    const parentNeedsDynamicRequest = false;
     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;
+    // Hydration is bound to the shared map.
+    const map = _cache.segmentCacheMap;
+    const tree = createRenderTreeOnNavigation(navigatedAt, initialRoot.tree, 1, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, restrictToShell);
+    const head = createRenderTreeOnNavigation(navigatedAt, initialRoot.head, 1, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, restrictToShell);
+    return createRootNavigationTask(tree, head);
 }
-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
+function startPPRNavigation(navigatedAt, oldUrl, oldRenderedSearch, oldRoot, newRoot, freshness, 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.
@@ -94,22 +104,39 @@ restrictToShell) {
         canonicalUrl: (0, _createhreffromurl.createHrefFromUrl)(oldUrl),
         renderedSearch: oldRenderedSearch
     };
-    return updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode !== null ? oldCacheNode : undefined, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation, map, restrictToShell);
+    const tree = updateRenderTreeOnNavigation(navigatedAt, oldRoot.tree, newRoot.tree, freshness, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation, map, restrictToShell);
+    if (tree === null) {
+        // The route tree changed at or above the root layout. Perform a full-page
+        // navigation.
+        return null;
+    }
+    const head = updateRenderTreeOnNavigation(navigatedAt, oldRoot.head, newRoot.head, freshness, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation, map, restrictToShell);
+    if (head === null) {
+        // Unreachable: a one-node tree has no root layout to change and no slots.
+        return null;
+    }
+    return createRootNavigationTask(tree, head);
+}
+// TODO: Unify NavigationTask with CacheNode.
+function createNavigationTask(status, route, node, dynamicRequestTree, children) {
+    return {
+        status,
+        route,
+        node,
+        dynamicRequestTree,
+        children
+    };
 }
-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
+function updateRenderTreeOnNavigation(navigatedAt, oldRenderTree, newRouteTree, freshness, 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);
-    const segmentMatchKind = compareSegments(newSegment, oldSegment);
-    if (segmentMatchKind === 1) {
+    // Check if the route structure changed. If only the params changed, that's
+    // handled further down.
+    const newSegment = newRouteTree.segment;
+    if (!(0, _cache.doesRouteStructureMatch)(oldRenderTree, newRouteTree)) {
         // 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 ((newRouteTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0 && (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)(oldRenderTree, 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,11 +149,9 @@ restrictToShell) {
         newSegment === _segment.NOT_FOUND_SEGMENT_KEY) {
             return null;
         }
-        return createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, restrictToShell);
+        return createRenderTreeOnNavigation(navigatedAt, newRouteTree, freshness, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, restrictToShell);
     }
     const newSlots = newRouteTree.slots;
-    const oldRouterStateChildren = oldRouterState[1];
-    const seedDataChildren = seedData !== null ? seedData[1] : null;
     let shouldRefreshDynamicData = false;
     switch(freshness){
         case 0:
@@ -143,52 +168,82 @@ restrictToShell) {
             freshness;
             break;
     }
-    // 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 = 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
-    // may need to consult the prefetch cache, like we would for a new segment.
-    let newCacheNode;
+    // usually we just reuse the data from the old render tree. If the params
+    // changed, or during a refresh or revalidation, consult the prefetch cache
+    // or response seed instead.
+    let newRenderTree;
     let needsDynamicRequest;
-    if (oldCacheNode !== undefined && !shouldRefreshDynamicData && // During a same-page navigation, we always refetch the page segments
-    !(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);
-        needsDynamicRequest = false;
-    } else {
-        // 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, // 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;
-        // 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);
+    const paramsChange = (0, _varypath.compareParams)(oldRenderTree.varyPath, newRouteTree.varyPath);
+    if (paramsChange !== _varypath.ParamsChange.None) {
+        // Path params are part of LayoutRouter's React key, so changing one
+        // remounts this segment and everything below it. Generate a new bfcacheId
+        // to match. Search params aren't part of the key, so a page whose search
+        // params changed keeps its existing id.
+        let bfcacheId;
+        if (paramsChange === _varypath.ParamsChange.PathParam) {
+            bfcacheId = generateBFCacheId(freshness);
         } 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;
-            }
+            bfcacheId = oldRenderTree.data.bfcacheId;
+        }
+        switch(freshness){
+            case 0:
+            case 5:
+                {
+                    // If the existing data didn't read any of the params that changed, we
+                    // can keep using it. Refreshes always fetch new data, and back/forward
+                    // navigations restore the entry from the BFCache instead.
+                    const oldCacheNode = oldRenderTree.data;
+                    if (!(0, _varypath.didReadChangedParam)(oldRenderTree.varyPath, newRouteTree.varyPath, oldCacheNode.varyParams)) {
+                        const cacheNode = createCacheNode(oldCacheNode.rsc, oldCacheNode.prefetchRsc, oldCacheNode.varyParams, bfcacheId);
+                        if (freshness !== 5) {
+                            (0, _bfcache.writeToBFCache)(navigatedAt, newRouteTree.varyPath, cacheNode, seedDynamicStaleAt);
+                        }
+                        newRenderTree = createRenderTree(newRouteTree, cacheNode);
+                        needsDynamicRequest = false;
+                        break;
+                    }
+                // Intentional fallthrough
+                }
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+                {
+                    const result = createRenderTreeForSegment(navigatedAt, newRouteTree, freshness, seedDynamicStaleAt, bfcacheId, map, restrictToShell);
+                    newRenderTree = result.node;
+                    needsDynamicRequest = result.needsDynamicRequest;
+                    break;
+                }
+        }
+        // A param change mostly acts the same as a refresh, except it does
+        // trigger a scroll.
+        if (isLeafSegment) {
+            accumulateScrollRef(freshness, newRenderTree.data, accumulation);
         }
+    } else if (shouldRefreshDynamicData || // During a same-page navigation, we always refetch the page segments
+    isLeafSegment && isSamePageNavigation) {
+        // This is a refresh of an existing segment. Ignore the existing render
+        // tree and create a new one.
+        const result = createRenderTreeForSegment(navigatedAt, newRouteTree, freshness, seedDynamicStaleAt, // Refreshing data preserves the identity of the active segment.
+        oldRenderTree.data.bfcacheId, map, restrictToShell);
+        newRenderTree = result.node;
+        needsDynamicRequest = result.needsDynamicRequest;
+        // Carry forward the old node's scrollRef. This preserves scroll intent
+        // when a prior navigation's render tree 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.
+        newRenderTree.data.scrollRef = oldRenderTree.data.scrollRef;
+    } else {
+        // This segment appears in both the old and new routes. Reuse the existing
+        // data without triggering a request.
+        // TODO: Consider adding a fast path where if this segment is unchanged and
+        // all of its children are unchanged, we return the exact same RenderTree
+        // object. Reusing the exact previous object gives React more of a chance to
+        // bail out of rendering.
+        newRenderTree = createRenderTree(newRouteTree, oldRenderTree.data);
+        needsDynamicRequest = false;
     }
     // 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
@@ -198,6 +253,7 @@ restrictToShell) {
     const maybeRefreshState = newRouteTree.refreshState;
     const refreshState = maybeRefreshState !== undefined && maybeRefreshState !== null ? // refresh URL as we continue traversing the tree.
     maybeRefreshState : parentRefreshState;
+    newRenderTree.refreshState = refreshState;
     // 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.
@@ -229,37 +285,32 @@ restrictToShell) {
     // include paths that are dynamic. Instead of reusing the
     // FlightRouterState type.
     let dynamicRequestTreeChildren = {};
-    let newCacheNodeSlots = null;
     if (newSlots !== null) {
-        const oldCacheNodeSlots = oldCacheNode !== undefined ? oldCacheNode.slots : null;
-        newCacheNode.slots = newCacheNodeSlots = {};
+        const oldRenderTreeSlots = oldRenderTree.slots;
+        const newRenderTreeSlots = new Map();
+        newRenderTree.slots = newRenderTreeSlots;
         taskChildren = new Map();
         for (let [parallelRouteKey, newRouteTreeChild] of newSlots){
-            const oldRouterStateChild = oldRouterStateChildren[parallelRouteKey];
-            if (oldRouterStateChild === undefined) {
+            const oldRenderTreeChild = oldRenderTreeSlots?.get(parallelRouteKey);
+            if (oldRenderTreeChild === 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;
+            const oldSegmentChild = oldRenderTreeChild.segment;
+            const newSegmentChild = newRouteTreeChild.segment;
             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) {
+            freshness !== 2 && newSegmentChild === _segment.DEFAULT_SEGMENT_KEY && oldSegmentChild !== _segment.DEFAULT_SEGMENT_KEY && // The active segment was rendered with this layout's params. If a
+            // path param changed, we can't keep it. Use the default segment from
+            // the server instead.
+            paramsChange !== _varypath.ParamsChange.PathParam) {
                 // 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;
+                newRouteTreeChild = reuseActiveSegmentInDefaultSlot(oldRootRefreshState, oldRenderTreeChild);
             }
-            const oldCacheNodeChild = oldCacheNodeSlots !== null ? oldCacheNodeSlots[parallelRouteKey] : undefined;
-            const taskChild = updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNodeChild, oldRouterStateChild, newRouteTreeChild, newMetadataVaryPath, freshness, seedDataChild ?? null, seedHeadChild, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest || needsDynamicRequest, oldRootRefreshState, refreshState, accumulation, map, restrictToShell);
+            const taskChild = updateRenderTreeOnNavigation(navigatedAt, oldRenderTreeChild, newRouteTreeChild, freshness, 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
@@ -268,7 +319,7 @@ restrictToShell) {
             }
             // Recursively propagate up the child tasks.
             taskChildren.set(parallelRouteKey, taskChild);
-            newCacheNodeSlots[parallelRouteKey] = taskChild.node;
+            newRenderTreeSlots.set(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.
@@ -284,24 +335,8 @@ restrictToShell) {
             }
         }
     }
-    const newFlightRouterState = [
-        createSegmentFromRouteTree(newRouteTree),
-        patchedRouterStateChildren,
-        refreshState !== null ? [
-            refreshState.canonicalUrl,
-            refreshState.renderedSearch
-        ] : null,
-        null,
-        newRouteTree.prefetchHints
-    ];
-    return {
-        status: needsDynamicRequest ? 0 : 1,
-        route: newFlightRouterState,
-        node: newCacheNode,
-        dynamicRequestTree: createDynamicRequestTree(newFlightRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest),
-        refreshState,
-        children: taskChildren
-    };
+    const newFlightRouterState = createRouterStateForSegment(newRouteTree, patchedRouterStateChildren, refreshState);
+    return createNavigationTask(needsDynamicRequest ? 0 : 1, newFlightRouterState, newRenderTree, createDynamicRequestTree(newFlightRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest), taskChildren);
 }
 /**
  * Assigns a ScrollRef to a new leaf CacheNode so the scroll handler
@@ -309,16 +344,14 @@ restrictToShell) {
  * 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).
+ * Called for newly entered segments, and for segments whose params changed
+ * (even if their data was reused). Refreshes keep the existing scroll ref.
  *
  * Skipped during hydration (initial render should not scroll) and
  * history traversal (scroll restoration is handled separately).
+ *
+ * The head passes through here as a leaf too; its `scrollRef` is never read
+ * (only LayoutRouter reads one), and the page leaf sets the same shared ref.
  */ function accumulateScrollRef(freshness, cacheNode, accumulation) {
     switch(freshness){
         case 0:
@@ -341,44 +374,40 @@ restrictToShell) {
             break;
     }
 }
-function createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, // Instant Navigation Testing API only — restricts segment reads to shell
+function createRenderTreeOnNavigation(navigatedAt, newRouteTree, freshness, 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
+    // Same traversal as updateRenderTreeOnNavigation, 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
+    // For the most part, this is a subset of updateRenderTreeOnNavigation, 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, // This segment was not part of the previous route, so mint a fresh
+    const result = createRenderTreeForSegment(navigatedAt, newRouteTree, 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 newRenderTree = result.node;
     const needsDynamicRequest = result.needsDynamicRequest;
     const isLeafSegment = newSlots === null;
     if (isLeafSegment) {
-        accumulateScrollRef(freshness, newCacheNode, accumulation);
+        accumulateScrollRef(freshness, newRenderTree.data, accumulation);
     }
     let patchedRouterStateChildren = {};
     let taskChildren = null;
     let childNeedsDynamicRequest = false;
     let dynamicRequestTreeChildren = {};
-    let newCacheNodeSlots = null;
     if (newSlots !== null) {
-        newCacheNode.slots = newCacheNodeSlots = {};
+        const newRenderTreeSlots = new Map();
+        newRenderTree.slots = newRenderTreeSlots;
         taskChildren = new Map();
         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, map, restrictToShell);
+            const taskChild = createRenderTreeOnNavigation(navigatedAt, newRouteTreeChild, freshness, seedDynamicStaleAt, parentNeedsDynamicRequest || needsDynamicRequest, accumulation, map, restrictToShell);
             taskChildren.set(parallelRouteKey, taskChild);
-            newCacheNodeSlots[parallelRouteKey] = taskChild.node;
+            newRenderTreeSlots.set(parallelRouteKey, taskChild.node);
             const taskChildRoute = taskChild.route;
             patchedRouterStateChildren[parallelRouteKey] = taskChildRoute;
             const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
@@ -390,47 +419,32 @@ restrictToShell) {
             }
         }
     }
-    const newFlightRouterState = [
-        newSegment,
-        patchedRouterStateChildren,
-        null,
+    // This route is not part of the current tree, so there's no reason to
+    // track the refresh URL.
+    const refreshState = null;
+    const newFlightRouterState = createRouterStateForSegment(newRouteTree, patchedRouterStateChildren, refreshState);
+    return createNavigationTask(needsDynamicRequest ? 0 : 1, newFlightRouterState, newRenderTree, createDynamicRequestTree(newFlightRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest), taskChildren);
+}
+// Converts a route tree node into the router state the client sends back to
+// the server. Page nodes carry their rendered search in its own slot.
+function createRouterStateForSegment(routeTree, children, refreshState) {
+    const routerState = [
+        routeTree.segment,
+        children,
+        refreshState !== null ? [
+            refreshState.canonicalUrl,
+            refreshState.renderedSearch
+        ] : null,
         null,
-        newRouteTree.prefetchHints
+        routeTree.prefetchHints
     ];
-    return {
-        status: needsDynamicRequest ? 0 : 1,
-        route: newFlightRouterState,
-        node: newCacheNode,
-        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.
-        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;
+    if (routeTree.segment === _segment.PAGE_SEGMENT_KEY) {
+        const renderedSearch = (0, _varypath.getRenderedSearchFromVaryPath)(routeTree.varyPath);
+        if (renderedSearch !== null) {
+            routerState[5] = renderedSearch;
         }
-        // This is based on equivalent logic in addSearchParamsIfPageSegment, used
-        // on the server.
-        const stringifiedQuery = JSON.stringify((0, _routeparams.urlSearchParamsToParsedUrlQuery)(new URLSearchParams(renderedSearch)));
-        return stringifiedQuery !== '{}' ? _segment.PAGE_SEGMENT_KEY + '?' + stringifiedQuery : _segment.PAGE_SEGMENT_KEY;
     }
-    return newRouteTree.segment;
+    return routerState;
 }
 function patchRouterStateWithNewChildren(baseRouterState, newChildren) {
     const clone = [
@@ -449,6 +463,9 @@ function patchRouterStateWithNewChildren(baseRouterState, newChildren) {
     if (4 in baseRouterState) {
         clone[4] = baseRouterState[4];
     }
+    if (5 in baseRouterState) {
+        clone[5] = baseRouterState[5];
+    }
     return clone;
 }
 function createDynamicRequestTree(newRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest) {
@@ -495,20 +512,20 @@ function accumulateRefreshUrl(accumulation, refreshState) {
         separateRefreshUrls.add(refreshUrl);
     }
 }
-function reuseActiveSegmentInDefaultSlot(parentRouteTree, parallelRouteKey, oldRootRefreshState, oldRouterState) {
+function reuseActiveSegmentInDefaultSlot(oldRootRefreshState, oldRenderTree) {
     // 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.
+    // URL. We store the refresh context on the active render tree.
     let reusedUrl;
     let reusedRenderedSearch;
-    const oldRefreshState = oldRouterState[2];
-    if (oldRefreshState !== undefined && oldRefreshState !== null) {
+    const oldRefreshState = oldRenderTree.refreshState;
+    if (oldRefreshState !== null) {
         // This segment was already reused from an even older route. Keep its
         // existing URL and refresh state.
-        reusedUrl = oldRefreshState[0];
-        reusedRenderedSearch = oldRefreshState[1];
+        reusedUrl = oldRefreshState.canonicalUrl;
+        reusedRenderedSearch = oldRefreshState.renderedSearch;
     } else {
         // 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
@@ -516,29 +533,31 @@ function reuseActiveSegmentInDefaultSlot(parentRouteTree, parallelRouteKey, oldR
         reusedUrl = oldRootRefreshState.canonicalUrl;
         reusedRenderedSearch = oldRootRefreshState.renderedSearch;
     }
-    const acc = {
-        metadataVaryPath: null,
-        treeDivergedFromBase: false
-    };
-    const reusedRouteTree = (0, _cache.convertReusedFlightRouterStateToRouteTree)(parentRouteTree, parallelRouteKey, oldRouterState, reusedRenderedSearch, acc);
+    const reusedRouteTree = (0, _cache.rebaseInactiveRouteTree)(oldRenderTree);
     reusedRouteTree.refreshState = {
         canonicalUrl: reusedUrl,
         renderedSearch: reusedRenderedSearch
     };
     return reusedRouteTree;
 }
-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).
-    // 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 createRenderTree(routeTree, cacheNode) {
+    return {
+        requestKey: routeTree.requestKey,
+        segment: routeTree.segment,
+        shellVaryPath: routeTree.shellVaryPath,
+        refreshState: null,
+        data: cacheNode,
+        varyPath: routeTree.varyPath,
+        slots: null,
+        prefetchHints: routeTree.prefetchHints
+    };
 }
-function createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHead, freshness, dynamicStaleAt, bfcacheId, map, // Instant Navigation Testing API only — restricts segment reads to shell
+function createRenderTreeForSegment(now, // A route tree node, or the one-node metadata tree that stands in for the
+// head (see createMetadataRouteTree).
+tree, 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
+    // Construct an owned render tree 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
@@ -552,7 +571,9 @@ restrictToShell) {
     // 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;
+    const seedData = tree.data;
+    const seedRsc = seedData !== null ? seedData.rsc : null;
+    const seedVaryParams = seedData !== null ? seedData.varyParams : null;
     // During certain kinds of navigations, we may be able to render from
     // the BFCache.
     switch(freshness){
@@ -569,7 +590,7 @@ restrictToShell) {
                     // BFCacheEntry's id is only restored on history-traversal
                     // navigations.
                     return {
-                        cacheNode: createCacheNode(bfcacheEntry.rsc, bfcacheEntry.prefetchRsc, bfcacheEntry.head, bfcacheEntry.prefetchHead, bfcacheId),
+                        node: createRenderTree(tree, createCacheNode(bfcacheEntry.rsc, bfcacheEntry.prefetchRsc, bfcacheEntry.varyParams, bfcacheId)),
                         needsDynamicRequest: false
                     };
                 }
@@ -592,17 +613,11 @@ restrictToShell) {
                 // 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, bfcacheId);
-                if (isPage && metadataVaryPath !== null) {
-                    (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt, bfcacheId);
-                }
+                // case in updateRenderTreeOnNavigation.
+                const cacheNode = createCacheNode(seedRsc, null, seedVaryParams, bfcacheId);
+                (0, _bfcache.writeToBFCache)(now, tree.varyPath, cacheNode, dynamicStaleAt);
                 return {
-                    cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId),
+                    node: createRenderTree(tree, cacheNode),
                     needsDynamicRequest: false
                 };
             }
@@ -626,7 +641,7 @@ restrictToShell) {
                 // 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, bfcacheEntry.bfcacheId),
+                    node: createRenderTree(tree, createCacheNode(bfcacheEntry.rsc, dropPrefetchRsc ? null : bfcacheEntry.prefetchRsc, bfcacheEntry.varyParams, bfcacheEntry.bfcacheId)),
                     needsDynamicRequest: false
                 };
             }
@@ -641,6 +656,7 @@ restrictToShell) {
     }
     let cachedRsc = null;
     let isCachedRscPartial = true;
+    let cachedVaryParams = null;
     const segmentEntry = (0, _cache.readSegmentCacheEntryForNavigation)(now, map, tree.varyPath, restrictToShell);
     if (segmentEntry !== null) {
         switch(segmentEntry.status){
@@ -649,6 +665,7 @@ restrictToShell) {
                     // Happy path: a cache hit
                     cachedRsc = segmentEntry.rsc;
                     isCachedRscPartial = segmentEntry.isPartial;
+                    cachedVaryParams = segmentEntry.varyParams;
                     break;
                 }
             case _cache.EntryStatus.Pending:
@@ -658,6 +675,8 @@ restrictToShell) {
                     // 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);
+                    // The entry's data hasn't arrived, and neither has the source of the
+                    // params it depends on; `cachedVaryParams` stays 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
@@ -683,6 +702,24 @@ restrictToShell) {
                 }
         }
     }
+    if (process.env.__NEXT_OPTIMISTIC_ROUTING && tree.segment === _segmentvalueencoding.HEAD_REQUEST_KEY && isCachedRscPartial) {
+        // 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.
+        cachedRsc = '';
+    }
     // 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
@@ -694,6 +731,10 @@ restrictToShell) {
     // means the data failed to load; the LayoutRouter will suspend indefinitely
     // until the router updates again (refer to finishNavigationTask).
     let rsc;
+    // The source of the params `rsc` depends on. A server response or a
+    // fulfilled segment cache entry carries one; a deferred `rsc` gets its
+    // source when the response arrives (finishPendingCacheNode).
+    let varyParams;
     let doesSegmentNeedDynamicRequest;
     if (seedRsc !== null) {
         // We already have a dynamic server response for this segment.
@@ -702,6 +743,7 @@ restrictToShell) {
             // partial cached state in the meantime.
             prefetchRsc = cachedRsc;
             rsc = seedRsc;
+            varyParams = seedVaryParams;
         } 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
@@ -709,6 +751,7 @@ restrictToShell) {
             // already fully cached, and the server will skip rendering them.
             prefetchRsc = null;
             rsc = cachedRsc;
+            varyParams = cachedVaryParams;
         }
         doesSegmentNeedDynamicRequest = false;
     } else {
@@ -721,118 +764,38 @@ restrictToShell) {
             // data arrives from the server.
             prefetchRsc = cachedRsc;
             rsc = createDeferredRsc();
+            varyParams = null;
         } else {
             // The data is fully cached.
             prefetchRsc = null;
             rsc = cachedRsc;
+            varyParams = cachedVaryParams;
         }
         doesSegmentNeedDynamicRequest = isCachedRscPartial;
     }
-    // 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.readSegmentCacheEntryForNavigation)(now, map, metadataVaryPath, restrictToShell);
-            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 {
-            if (isCachedHeadPartial) {
-                prefetchHead = cachedHead;
-                head = createDeferredRsc();
-            } else {
-                prefetchHead = null;
-                head = cachedHead;
-            }
-            doesHeadNeedDynamicRequest = isCachedHeadPartial;
-        }
-    }
     // 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.
+    const cacheNode = createCacheNode(rsc, prefetchRsc, varyParams, bfcacheId);
     if (freshness !== 5) {
-        (0, _bfcache.writeToBFCache)(now, tree.varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt, bfcacheId);
-        if (isPage && metadataVaryPath !== null) {
-            (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt, bfcacheId);
-        }
+        (0, _bfcache.writeToBFCache)(now, tree.varyPath, cacheNode, dynamicStaleAt);
     }
     return {
-        cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId),
+        node: createRenderTree(tree, cacheNode),
         // 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
+        needsDynamicRequest: doesSegmentNeedDynamicRequest
     };
 }
-function createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId, scrollRef = null) {
+function createCacheNode(rsc, prefetchRsc, varyParams, bfcacheId, scrollRef = null) {
     return {
         rsc,
         prefetchRsc,
-        head,
-        prefetchHead,
-        slots: null,
+        varyParams,
         scrollRef,
         bfcacheId
     };
@@ -849,20 +812,11 @@ function generateBFCacheId(freshness) {
     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.
 let previousNavigationDidMismatch = false;
-function spawnDynamicRequests(task, primaryUrl, nextUrl, freshnessPolicy, accumulation, // The route cache entry used for this navigation, if it came from route
+function spawnDynamicRequests(navigation, 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).
@@ -872,11 +826,17 @@ routeCacheEntry, // The original navigation's push/replace intent. Threaded thro
 navigateType, navigationLock, // The segment cache map this navigation is bound to. See `segmentCacheMap`
 // in cache.ts.
 map, signal) {
-    const dynamicRequestTree = task.dynamicRequestTree;
+    let dynamicRequestTree = navigation.tree.dynamicRequestTree;
     if (dynamicRequestTree === null) {
-        // This navigation was fully cached. There are no dynamic requests to spawn.
-        previousNavigationDidMismatch = false;
-        return;
+        if (navigation.head.status === 0) {
+            // Every segment is cached, but the head is not. Ask the server for the
+            // head alone.
+            dynamicRequestTree = _cache.MetadataOnlyRequestTree;
+        } else {
+            // This navigation was fully cached. There are no dynamic requests to spawn.
+            previousNavigationDidMismatch = false;
+            return;
+        }
     }
     // This is intentionally not an async function to discourage the caller from
     // awaiting the result. Any subsequent async operations spawned by this
@@ -887,7 +847,7 @@ map, signal) {
     // 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, navigationLock, map, signal);
+    const primaryRequestPromise = fetchMissingDynamicData(navigation.tree, navigation.head, dynamicRequestTree, primaryUrl, nextUrl, freshnessPolicy, routeCacheEntry, navigationLock, map, signal);
     const separateRefreshUrls = accumulation.separateRefreshUrls;
     let refreshRequestPromises = null;
     if (separateRefreshUrls !== null) {
@@ -917,7 +877,8 @@ map, signal) {
             // const scopedDynamicRequestTree = splitTaskByURL(task, refreshUrl)
             const scopedDynamicRequestTree = dynamicRequestTree;
             if (scopedDynamicRequestTree !== null) {
-                refreshRequestPromises.push(fetchMissingDynamicData(task, scopedDynamicRequestTree, new URL(refreshUrl, location.origin), // TODO: Just noticed that this should actually the Next-Url at the
+                refreshRequestPromises.push(fetchMissingDynamicData(navigation.tree, // The head belongs to the primary URL.
+                null, scopedDynamicRequestTree, new URL(refreshUrl, location.origin), // TODO: Just noticed that this should actually the Next-Url at the
                 // time the refresh URL was set, not the current Next-Url. Need to
                 // start tracking this alongside the refresh URL. In the meantime,
                 // if a refresh fails due to a mismatch, it will trigger a
@@ -928,12 +889,12 @@ map, signal) {
     }
     // Further async operations are moved into this separate function to
     // discourage sequential network requests.
-    const voidPromise = finishNavigationTask(task, nextUrl, primaryRequestPromise, refreshRequestPromises, routeCacheEntry, navigateType);
+    const voidPromise = finishNavigationTask(navigation, 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, routeCacheEntry, navigateType) {
+async function finishNavigationTask(navigation, 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
@@ -943,7 +904,15 @@ async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refres
     // first phase; it doesn't matter in that case because we're going to refresh
     // the whole tree regardless.
     if (exitStatus === 0) {
-        exitStatus = abortRemainingPendingTasks(task, null, null);
+        exitStatus = abortRemainingPendingTasks(navigation.tree, null, null);
+        // A response without a head is a mismatch, like any missing segment. The
+        // head's deferred rsc must be resolved to `null` here, never rejected: it
+        // renders at the app root, so a rejection would hit the root error
+        // boundary while the retry is in flight.
+        const headExitStatus = abortRemainingPendingTasks(navigation.head, null, null);
+        if (headExitStatus > exitStatus) {
+            exitStatus = headExitStatus;
+        }
     }
     switch(exitStatus){
         case -1:
@@ -970,7 +939,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, routeCacheEntry, navigateType, 3);
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, navigation, routeCacheEntry, navigateType, 3);
                 return;
             }
         case 3:
@@ -981,7 +950,7 @@ async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refres
                 // (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);
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, navigation, routeCacheEntry, navigateType, 2);
                 return;
             }
         case 2:
@@ -996,7 +965,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, 3);
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, navigation, routeCacheEntry, navigateType, 3);
                 return;
             }
         default:
@@ -1010,7 +979,7 @@ function waitForRequestsToFinish(primaryRequestPromise, refreshRequestPromises)
     // we don't assume that's available.
     //
     // Each promise resolves once the server responsds and the data is written
-    // into the CacheNode tree. Resolve the combined promise once all the
+    // into the render tree. Resolve the combined promise once all the
     // requests finish.
     //
     // Or, resolve as soon as one of the requests fails, without waiting for the
@@ -1045,7 +1014,7 @@ function waitForRequestsToFinish(primaryRequestPromise, refreshRequestPromises)
         }
     });
 }
-function dispatchRetryDueToTreeMismatch(isHardRetry, retryUrl, retryNextUrl, seed, baseTree, // The route cache entry used for this navigation, if it came from route
+function dispatchRetryDueToTreeMismatch(isHardRetry, retryUrl, retryNextUrl, seed, navigation, // 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.
@@ -1054,26 +1023,32 @@ originalNavigateType, // Freshness policy for the retry navigation. `RefreshAll`
 // 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 the navigation used a route prediction, mark the node it was predicted
+    // from as having a dynamic rewrite since it resulted in a mismatch. A route
+    // entry the server resolved has nothing to mark: nothing was predicted
+    // from it.
     if (routeCacheEntry !== null) {
-        (0, _cache.markRouteEntryAsDynamicRewrite)(routeCacheEntry);
+        const predictedFrom = routeCacheEntry.predictedFrom;
+        if (predictedFrom !== null) {
+            predictedFrom.hasDynamicRewrite = true;
+        }
     } 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, retryUrl.search, retryNextUrl, null, seed.routeTree, metadataVaryPath, false, (0, _createhreffromurl.createHrefFromUrl)(retryUrl), false, true // hasDynamicRewrite
-            );
-        }
+        const now = Date.now();
+        (0, _optimisticroutes.discoverKnownRoute)(now, retryUrl.pathname, retryUrl.search, retryNextUrl, null, seed.root, false, (0, _createhreffromurl.createHrefFromUrl)(retryUrl), seed.renderedSearch, 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
+    // Invalidate all route cache entries. If the navigation used a route entry
+    // the server resolved, its tree is what the server just contradicted, so
+    // the retry must re-fetch it rather than navigate with it again. This also
     // triggers re-prefetching of visible links.
-    (0, _cache.invalidateRouteCacheEntries)(retryNextUrl, baseTree);
+    (0, _cache.invalidateRouteCacheEntries)(retryNextUrl, {
+        tree: navigation.tree.node,
+        head: navigation.head.node
+    });
     // 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;
@@ -1092,6 +1067,7 @@ retryFreshnessPolicy) {
     // 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 baseTree = navigation.tree.route;
     const lastCommitted = (0, _committedstate.getLastCommittedTree)();
     const retryNavigateType = lastCommitted !== null && baseTree !== lastCommitted ? originalNavigateType : 'replace';
     const retryAction = {
@@ -1106,7 +1082,7 @@ retryFreshnessPolicy) {
     };
     (0, _useactionqueue.dispatchAppRouterAction)(retryAction);
 }
-async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, freshnessPolicy, routeCacheEntry, navigationLock, map, signal) {
+async function fetchMissingDynamicData(tree, head, dynamicRequestTree, url, nextUrl, freshnessPolicy, routeCacheEntry, navigationLock, map, signal) {
     try {
         const result = await (0, _fetchserverresponse.fetchServerResponse)(url, {
             flightRouterState: dynamicRequestTree,
@@ -1126,32 +1102,22 @@ async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, f
             };
         }
         const now = Date.now();
-        const seed = (0, _navigation.convertServerPatchToFullTree)(now, task.route, result.flightData, result.renderedSearch, result.dynamicStaleTime);
+        const seed = (0, _decodeserverresponse.createNavigationSeed)(now, tree.route, result.transportData, // Navigation responses stream in incrementally, so their vary params
+        // can't be drained here; they decode as null.
+        null, result.isResponsePartial, // Navigation responses always include the param values in the tree, so
+        // there's no pathname to parse them from (nor a need to).
+        null, result.renderedSearch, null, 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 && 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.resolveStaleAt)(now, staticStageResponse.s).then((staleAt)=>{
-                const buildId = result.responseHeaders.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? staticStageResponse.b;
-                (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.
-            });
+        if (routeCacheEntry !== null && result.staticStageResponse !== null) {
+            (0, _cache.spawnStaticStageCacheWrite)(now, result.staticStageResponse, result.isResponsePartial, result.responseHeaders, dynamicRequestTree, result.renderedSearch, map);
         }
         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.rootVaryParamsIterable, processed.staleAt, processed.navigationSeed, null, map);
-                }
-            }).catch(()=>{
+            (0, _cache.writeRuntimePrefetchStreamIntoCache)(now, result.runtimePrefetchStream, dynamicRequestTree, result.renderedSearch, map).catch(()=>{
             // The runtime prefetch cache write failed. Not fatal — the
             // navigation completed normally, we just won't cache runtime data.
             });
@@ -1159,7 +1125,10 @@ 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, result.revealAfter);
+        const didReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(tree, seed.root.tree, dynamicStaleAt, result.debugInfo, result.revealAfter);
+        if (head !== null) {
+            writeDynamicDataIntoNavigationTask(head, seed.root.head, dynamicStaleAt, result.debugInfo, result.revealAfter);
+        }
         const resolvedUrl = new URL(result.canonicalUrl, location.origin);
         // Decide whether the navigation needs to be retried.
         //
@@ -1208,27 +1177,31 @@ async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, f
         };
     }
 }
-function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData, dynamicHead, dynamicStaleAt, debugInfo, revealAfter) {
+function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicStaleAt, debugInfo, revealAfter) {
+    // A non-null data object means the response accounted for this segment,
+    // even if it didn't render it (data.rsc may still be null, e.g. for the
+    // intermediate segments on the path to a rendered subtree).
+    const dynamicData = serverRouteTree.data;
     if (task.status === 0 && dynamicData !== null) {
         task.status = 1;
-        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.
-        // We only update segments that received dynamic data — static segments
-        // are unaffected.
-        (0, _bfcache.updateBFCacheEntryStaleAt)(serverRouteTree.varyPath, dynamicStaleAt);
+        const cacheNode = task.node.data;
+        finishPendingCacheNode(cacheNode, dynamicData, debugInfo, revealAfter);
+        // The BFCache entry for this segment was written before the response
+        // arrived. Bring it up to date with what the response filled in: its
+        // staleAt (the per-page unstable_dynamicStaleTime if set, or the default
+        // DYNAMIC_STALETIME_MS) and the source of the params its data depends
+        // on. We only update segments that received dynamic data — static
+        // segments are unaffected.
+        (0, _bfcache.updateBFCacheEntryFromDynamicResponse)(serverRouteTree.varyPath, cacheNode, dynamicStaleAt);
     }
     const taskChildren = task.children;
     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) {
         if (serverChildren !== null) {
             for (const [parallelRouteKey, serverRouteTreeChild] of serverChildren){
-                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.
@@ -1246,11 +1219,11 @@ function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData,
                     // 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) {
+                    // Check that the response is for the route we expected: same route
+                    // structure and same params, including the page's search params.
+                    if ((0, _cache.doesRouteStructureMatch)(taskChild.node, serverRouteTreeChild) && serverRouteTreeChild.data !== null && (0, _varypath.compareParams)(taskChild.node.varyPath, serverRouteTreeChild.varyPath) === _varypath.ParamsChange.None) {
                         // Found a match for this task. Keep traversing down the task tree.
-                        const childDidReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(taskChild, serverRouteTreeChild, dynamicDataChild, dynamicHead, dynamicStaleAt, debugInfo, revealAfter);
+                        const childDidReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(taskChild, serverRouteTreeChild, dynamicStaleAt, debugInfo, revealAfter);
                         if (childDidReceiveUnknownParallelRoute) {
                             didReceiveUnknownParallelRoute = true;
                         }
@@ -1266,41 +1239,47 @@ function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData,
     }
     return didReceiveUnknownParallelRoute;
 }
-function finishPendingCacheNode(cacheNode, dynamicData, dynamicHead, debugInfo, revealAfter) {
-    // Writes a dynamic response into an existing Cache Node tree. This does _not_
+function finishPendingCacheNode(cacheNode, dynamicData, debugInfo, revealAfter) {
+    // Writes a dynamic response into an existing render 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
     // it cannot overwrite existing data. It can add segments to the tree (because
-    // a missing segment will cause the layout router to suspend).
-    // but it cannot delete them.
+    // a missing segment will cause the layout router to suspend) but it cannot
+    // delete them.
     //
     // We must resolve every promise in the tree, or else it will suspend
     // indefinitely. If we did not receive data for a segment, we will resolve its
     // data promise to `null` to trigger a lazy fetch during render.
-    // Use the dynamic data from the server to fulfill the deferred RSC promise
-    // on the Cache Node.
+    // Use the dynamic data from the server to fulfill the deferred RSC promise.
     const rsc = cacheNode.rsc;
-    const dynamicSegmentData = dynamicData[0];
+    const dynamicSegmentData = dynamicData.rsc;
     if (dynamicSegmentData === null) {
-        // This is an empty CacheNode; this particular server request did not
+        // This particular server request did not
         // render this segment. There may be a separate pending request that will,
         // though, so we won't abort the task until all pending requests finish.
         return;
     }
+    // TODO: `varyParams` must always describe the render that produced `rsc`,
+    // but nothing in the CacheNode type ties the two fields together; this
+    // function keeps them in lockstep by writing both at once. Eventually the
+    // whole CacheNode should be a thenable whose fields are populated through
+    // dedicated helpers that own the state transition.
     if (rsc === null) {
         // This is a lazy cache node. We can overwrite it. This is only safe
         // because we know that the LayoutRouter suspends if `rsc` is `null`.
         cacheNode.rsc = dynamicSegmentData;
-    } else if (isDeferredRsc(rsc)) {
+        cacheNode.varyParams = dynamicData.varyParams;
+    } else if (isDeferredRsc(rsc) && rsc.status === 'pending') {
         // 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.
+        // received from the server. The source of the params that data depends
+        // on travels with it.
         //
         // 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.
+        cacheNode.varyParams = dynamicData.varyParams;
         if (revealAfter !== null) {
             const resolveRsc = ()=>rsc.resolve(dynamicSegmentData, debugInfo);
             // Use the same callback for both outcomes: we don't expect `revealAfter`
@@ -1311,15 +1290,9 @@ function finishPendingCacheNode(cacheNode, dynamicData, dynamicHead, debugInfo,
             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.
-    }
-    // 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.
-    const head = cacheNode.head;
-    if (isDeferredRsc(head)) {
-        head.resolve(dynamicHead, debugInfo);
+    // This is not a deferred RSC promise that's still pending, nor is it
+    // empty, so it must have been populated by a different navigation. We
+    // must not overwrite it (nor its dependency source).
     }
 }
 function abortRemainingPendingTasks(task, error, debugInfo) {
@@ -1327,7 +1300,7 @@ function abortRemainingPendingTasks(task, error, debugInfo) {
     if (task.status === 0) {
         // The data for this segment is still missing.
         task.status = 2;
-        abortPendingCacheNode(task.node, error, debugInfo);
+        abortPendingCacheNode(task.node.data, error, debugInfo);
         // If the server failed to fulfill the data for this segment, it implies
         // that the route tree received from the server mismatched the tree that
         // was previously prefetched.
@@ -1340,7 +1313,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.refreshState === null) {
+        if (task.node.refreshState === null) {
             // Trigger a "soft" refresh. Essentially the same as calling `refresh()`
             // in a Server Action.
             exitStatus = 1;
@@ -1382,14 +1355,6 @@ function abortPendingCacheNode(cacheNode, error, debugInfo) {
             rsc.reject(error, 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
-    // the app. We want the segment to error, not the entire app.
-    const head = cacheNode.head;
-    if (isDeferredRsc(head)) {
-        head.resolve(null, debugInfo);
-    }
 }
 const DEFERRED = Symbol();
 function isDeferredRsc(value) {
@@ -1446,21 +1411,21 @@ function createDeferredRsc() {
 }
 function getCurrentNavigationLock() {
     if (process.env.__NEXT_EXPOSE_TESTING_API) {
-        const { getCurrentNavigationGate } = require('../segment-cache/navigation-testing-lock');
+        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');
+        const { beginLockedNavigation: begin } = require('./segment-cache/navigation-testing-lock');
         return begin();
     }
     return null;
 }
 function resetNavigationLockToPending() {
     if (process.env.__NEXT_EXPOSE_TESTING_API) {
-        const { resetNavigationLockToPending: reset } = require('../segment-cache/navigation-testing-lock');
+        const { resetNavigationLockToPending: reset } = require('./segment-cache/navigation-testing-lock');
         reset();
     }
 }
@@ -1471,4 +1436,4 @@ if ((typeof exports.default === 'function' || (typeof exports.default === 'objec
   module.exports = exports.default;
 }
 
-//# sourceMappingURL=ppr-navigations.js.map
+//# sourceMappingURL=render-tree.js.map