putmein-test 1.0.0

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

@@ -0,0 +1,1474 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    FreshnessPolicy: null,
+    beginLockedNavigation: null,
+    createInitialCacheNodeForHydration: null,
+    getCurrentNavigationLock: null,
+    isDeferredRsc: null,
+    resetNavigationLockToPending: null,
+    spawnDynamicRequests: null,
+    startPPRNavigation: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    FreshnessPolicy: function() {
+        return FreshnessPolicy;
+    },
+    beginLockedNavigation: function() {
+        return beginLockedNavigation;
+    },
+    createInitialCacheNodeForHydration: function() {
+        return createInitialCacheNodeForHydration;
+    },
+    getCurrentNavigationLock: function() {
+        return getCurrentNavigationLock;
+    },
+    isDeferredRsc: function() {
+        return isDeferredRsc;
+    },
+    resetNavigationLockToPending: function() {
+        return resetNavigationLockToPending;
+    },
+    spawnDynamicRequests: function() {
+        return spawnDynamicRequests;
+    },
+    startPPRNavigation: function() {
+        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");
+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, seedDynamicStaleAt) {
+    // Create the initial cache node tree, using the data embedded into the
+    // HTML document.
+    const accumulation = {
+        separateRefreshUrls: null,
+        scrollRef: null
+    };
+    const restrictToShell = false;
+    const task = createCacheNodeOnNavigation(navigatedAt, initialTree, null, 1, seedData, seedHead, seedDynamicStaleAt, false, accumulation, // Hydration is bound to the shared map.
+    _cache.segmentCacheMap, restrictToShell);
+    return task;
+}
+function startPPRNavigation(navigatedAt, oldUrl, oldRenderedSearch, oldCacheNode, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, accumulation, // The segment cache map this navigation is bound to: a locked navigation's
+// driving-task map, or the shared map. See `segmentCacheMap` in cache.ts.
+map, // Instant Navigation Testing API only — restricts segment reads to shell
+// entries. Always false outside the testing API. See navigation-testing-lock.
+restrictToShell) {
+    const parentNeedsDynamicRequest = false;
+    const parentRefreshState = null;
+    const oldRootRefreshState = {
+        canonicalUrl: (0, _createhreffromurl.createHrefFromUrl)(oldUrl),
+        renderedSearch: oldRenderedSearch
+    };
+    return updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode !== null ? oldCacheNode : undefined, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation, map, restrictToShell);
+}
+function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest, oldRootRefreshState, parentRefreshState, accumulation, map, // Instant Navigation Testing API only — restricts segment reads to shell
+// entries. Always false outside the testing API. See navigation-testing-lock.
+restrictToShell) {
+    // Check if this segment matches the one in the previous route. A
+    // search-param-only difference at a page segment falls through to the
+    // matched branch — the CacheNode is rebuilt (so data refetches), but the
+    // bfcacheId carries forward as if the segment had matched.
+    const oldSegment = oldRouterState[0];
+    const newSegment = createSegmentFromRouteTree(newRouteTree);
+    const segmentMatchKind = compareSegments(newSegment, oldSegment);
+    if (segmentMatchKind === 1) {
+        // This segment does not match the previous route. We're now entering the
+        // new part of the target route. Switch to the "create" path.
+        if ((newRouteTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0 && (0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(oldRouterState, newRouteTree) || // The global Not Found route (app/global-not-found.tsx) is a special
+        // case, because it acts like a root layout, but in the router tree, it
+        // is rendered in the same position as app/layout.tsx.
+        //
+        // Any navigation to the global Not Found route should trigger a
+        // full-page navigation.
+        //
+        // TODO: We should probably model this by changing the key of the root
+        // segment when this happens. Then the root layout check would work
+        // as expected, without a special case.
+        newSegment === _segment.NOT_FOUND_SEGMENT_KEY) {
+            return null;
+        }
+        return createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, restrictToShell);
+    }
+    const newSlots = newRouteTree.slots;
+    const oldRouterStateChildren = oldRouterState[1];
+    const seedDataChildren = seedData !== null ? seedData[1] : null;
+    let shouldRefreshDynamicData = false;
+    switch(freshness){
+        case 0:
+        case 2:
+        case 1:
+        case 5:
+            shouldRefreshDynamicData = false;
+            break;
+        case 3:
+        case 4:
+            shouldRefreshDynamicData = true;
+            break;
+        default:
+            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;
+    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);
+        } else {
+            // Normal case: This is a refresh of an existing segment. Carry forward
+            // the old node's scrollRef. This preserves scroll intent when a prior
+            // navigation's CacheNode is replaced by a refresh before the scroll
+            // handler has had a chance to fire — e.g. when router.push() and
+            // router.refresh() are called in the same startTransition batch.
+            if (oldCacheNode !== undefined) {
+                newCacheNode.scrollRef = oldCacheNode.scrollRef;
+            }
+        }
+    }
+    // During a refresh navigation, there's a special case that happens when
+    // 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 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 && 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
+    // of default parallel routes, we preserve the currently active segment. To
+    // avoid mutating the original tree, we clone the router state children along
+    // the return path.
+    let patchedRouterStateChildren = {};
+    let taskChildren = null;
+    // Most navigations require a request to fetch additional data from the
+    // server, either because the data was not already prefetched, or because the
+    // target route contains dynamic data that cannot be prefetched.
+    //
+    // However, if the target route is fully static, and it's already completely
+    // loaded into the segment cache, then we can skip the server request.
+    //
+    // This starts off as `false`, and is set to `true` if any of the child
+    // routes requires a dynamic request.
+    let childNeedsDynamicRequest = false;
+    // As we traverse the children, we'll construct a FlightRouterState that can
+    // be sent to the server to request the dynamic data. If it turns out that
+    // nothing in the subtree is dynamic (i.e. childNeedsDynamicRequest is false
+    // at the end), then this will be discarded.
+    // TODO: We can probably optimize the format of this data structure to only
+    // 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 = {};
+        taskChildren = new Map();
+        for (let [parallelRouteKey, newRouteTreeChild] of newSlots){
+            const oldRouterStateChild = oldRouterStateChildren[parallelRouteKey];
+            if (oldRouterStateChild === undefined) {
+                // This should never happen, but if it does, it suggests a malformed
+                // 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, seedDataChild ?? null, seedHeadChild, seedDynamicStaleAt, isSamePageNavigation, parentNeedsDynamicRequest || needsDynamicRequest, oldRootRefreshState, refreshState, accumulation, map, restrictToShell);
+            if (taskChild === null) {
+                // One of the child tasks discovered a change to the root layout.
+                // Immediately unwind from this recursive traversal. This will trigger a
+                // 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: newFlightRouterState,
+        node: newCacheNode,
+        dynamicRequestTree: createDynamicRequestTree(newFlightRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest),
+        refreshState,
+        children: taskChildren
+    };
+}
+/**
+ * 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:
+        case 5:
+        case 3:
+        case 4:
+            if (accumulation.scrollRef === null) {
+                accumulation.scrollRef = {
+                    current: true
+                };
+            }
+            cacheNode.scrollRef = accumulation.scrollRef;
+            break;
+        case 1:
+            break;
+        case 2:
+            break;
+        default:
+            freshness;
+            break;
+    }
+}
+function createCacheNodeOnNavigation(navigatedAt, newRouteTree, newMetadataVaryPath, freshness, seedData, seedHead, seedDynamicStaleAt, parentNeedsDynamicRequest, accumulation, map, // Instant Navigation Testing API only — restricts segment reads to shell
+// entries. Always false outside the testing API. See navigation-testing-lock.
+restrictToShell) {
+    // Same traversal as updateCacheNodeNavigation, but simpler. We switch to this
+    // path once we reach the part of the tree that was not in the previous route.
+    // We don't need to diff against the old tree, we just need to create a new
+    // 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, // This segment was not part of the previous route, so mint a fresh
+    // bfcacheId.
+    generateBFCacheId(freshness), map, restrictToShell);
+    const newCacheNode = result.cacheNode;
+    const needsDynamicRequest = result.needsDynamicRequest;
+    const isLeafSegment = newSlots === null;
+    if (isLeafSegment) {
+        accumulateScrollRef(freshness, newCacheNode, accumulation);
+    }
+    let patchedRouterStateChildren = {};
+    let taskChildren = null;
+    let childNeedsDynamicRequest = false;
+    let dynamicRequestTreeChildren = {};
+    let newCacheNodeSlots = null;
+    if (newSlots !== null) {
+        newCacheNode.slots = newCacheNodeSlots = {};
+        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);
+            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: 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;
+        }
+        // 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;
+}
+function patchRouterStateWithNewChildren(baseRouterState, newChildren) {
+    const clone = [
+        baseRouterState[0],
+        newChildren
+    ];
+    // Based on equivalent logic in apply-router-state-patch-to-tree, but should
+    // confirm whether we need to copy all of these fields. Not sure the server
+    // ever sends, e.g. the refetch marker.
+    if (2 in baseRouterState) {
+        clone[2] = baseRouterState[2];
+    }
+    if (3 in baseRouterState) {
+        clone[3] = baseRouterState[3];
+    }
+    if (4 in baseRouterState) {
+        clone[4] = baseRouterState[4];
+    }
+    return clone;
+}
+function createDynamicRequestTree(newRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest) {
+    // Create a FlightRouterState that instructs the server how to render the
+    // requested segment.
+    //
+    // Or, if neither this segment nor any of the children require a new data,
+    // then we return `null` to skip the request.
+    let dynamicRequestTree = null;
+    if (needsDynamicRequest) {
+        dynamicRequestTree = patchRouterStateWithNewChildren(newRouterState, dynamicRequestTreeChildren);
+        // The "refetch" marker is set on the top-most segment that requires new
+        // data. We can omit it if a parent was already marked.
+        if (!parentNeedsDynamicRequest) {
+            dynamicRequestTree[3] = 'refetch';
+        }
+    } else if (childNeedsDynamicRequest) {
+        // This segment does not request new data, but at least one of its
+        // children does.
+        dynamicRequestTree = patchRouterStateWithNewChildren(newRouterState, dynamicRequestTreeChildren);
+    } else {
+        dynamicRequestTree = null;
+    }
+    return dynamicRequestTree;
+}
+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
+    // separate request using the old route's URL.
+    //
+    // Track these extra URLs in the accumulated result. Later, we'll construct
+    // an appropriate request for each unique URL in the final set. The reason
+    // 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([
+            refreshUrl
+        ]);
+    } else {
+        separateRefreshUrls.add(refreshUrl);
+    }
+}
+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.
+    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 state.
+        reusedUrl = oldRefreshState[0];
+        reusedRenderedSearch = oldRefreshState[1];
+    } 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
+        // that represents the old route.
+        reusedUrl = oldRootRefreshState.canonicalUrl;
+        reusedRenderedSearch = oldRootRefreshState.renderedSearch;
+    }
+    const acc = {
+        metadataVaryPath: null,
+        treeDivergedFromBase: false
+    };
+    const reusedRouteTree = (0, _cache.convertReusedFlightRouterStateToRouteTree)(parentRouteTree, parallelRouteKey, oldRouterState, reusedRenderedSearch, acc);
+    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 createCacheNodeForSegment(now, tree, seedRsc, metadataVaryPath, seedHead, freshness, dynamicStaleAt, bfcacheId, map, // Instant Navigation Testing API only — restricts segment reads to shell
+// entries. Always false outside the testing API. See navigation-testing-lock.
+restrictToShell) {
+    // Construct a new CacheNode using data from the BFCache, the client's
+    // Segment Cache, or seeded from a server response.
+    //
+    // 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) {
+                    // A regular navigation that happens to read cached data is still a
+                    // fresh navigation, so we use the caller-supplied bfcacheId — the
+                    // BFCacheEntry's id is only restored on history-traversal
+                    // navigations.
+                    return {
+                        cacheNode: createCacheNode(bfcacheEntry.rsc, bfcacheEntry.prefetchRsc, bfcacheEntry.head, bfcacheEntry.prefetchHead, bfcacheId),
+                        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, bfcacheId);
+                if (isPage && metadataVaryPath !== null) {
+                    (0, _bfcache.writeHeadToBFCache)(now, metadataVaryPath, head, prefetchHead, dynamicStaleAt, bfcacheId);
+                }
+                return {
+                    cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId),
+                    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;
+                // Restore the bfcacheId from the cached entry so that back/forward
+                // navigations preserve the original id, regardless of whether
+                // `cacheComponents` Activity preservation is enabled.
+                return {
+                    cacheNode: createCacheNode(bfcacheEntry.rsc, dropPrefetchRsc ? null : bfcacheEntry.prefetchRsc, bfcacheEntry.head, dropPrefetchRsc ? null : bfcacheEntry.prefetchHead, bfcacheEntry.bfcacheId),
+                    needsDynamicRequest: false
+                };
+            }
+            break;
+        case 3:
+        case 4:
+        case 5:
+            break;
+        default:
+            freshness;
+            break;
+    }
+    let cachedRsc = null;
+    let isCachedRscPartial = true;
+    const segmentEntry = (0, _cache.readSegmentCacheEntryForNavigation)(now, map, tree.varyPath, restrictToShell);
+    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;
+    // 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 {
+        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, 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.
+    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);
+        }
+    }
+    return {
+        cacheNode: createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId),
+        // TODO: We should store this field on the CacheNode itself. I think we can
+        // probably unify NavigationTask, CacheNode, and DeferredRsc into a
+        // single type. Or at least CacheNode and DeferredRsc.
+        needsDynamicRequest: doesSegmentNeedDynamicRequest || doesHeadNeedDynamicRequest
+    };
+}
+function createCacheNode(rsc, prefetchRsc, head, prefetchHead, bfcacheId, scrollRef = null) {
+    return {
+        rsc,
+        prefetchRsc,
+        head,
+        prefetchHead,
+        slots: null,
+        scrollRef,
+        bfcacheId
+    };
+}
+// Globally-unique counter for fresh bfcacheIds. Incremented every time a new
+// CacheNode is created on the client. The id surfaces to user code as a
+// string via `useRouter().bfcacheId`.
+let nextBFCacheId = 0;
+function generateBFCacheId(freshness) {
+    // Server-side rendering and the initial client-side hydration tree both
+    // use a fixed sentinel so they reconcile cleanly across hydration. The
+    // counter only advances on real client-side navigations after hydration.
+    if (typeof window === 'undefined') return 0;
+    if (freshness === 1) return 0;
+    return ++nextBFCacheId;
+}
+function compareSegments(newSegment, oldSegment) {
+    if ((0, _matchsegments.matchSegment)(newSegment, oldSegment)) {
+        return 0;
+    }
+    if (typeof newSegment === 'string' && typeof oldSegment === 'string' && newSegment.startsWith(_segment.PAGE_SEGMENT_KEY) && oldSegment.startsWith(_segment.PAGE_SEGMENT_KEY)) {
+        return 2;
+    }
+    return 1;
+}
+// Represents whether the previuos navigation resulted in a route tree mismatch.
+// A mismatch results in a refresh of the page. If there are two successive
+// mismatches, we will fall back to an MPA navigation, to prevent a retry loop.
+let previousNavigationDidMismatch = false;
+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, navigationLock, // The segment cache map this navigation is bound to. See `segmentCacheMap`
+// in cache.ts.
+map, signal) {
+    const dynamicRequestTree = task.dynamicRequestTree;
+    if (dynamicRequestTree === null) {
+        // This navigation was fully cached. There are no dynamic requests to spawn.
+        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
+    // function should result in a separate navigation task, rather than
+    // block the original one.
+    //
+    // In this function we spawn (but do not await) all the network requests that
+    // 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 separateRefreshUrls = accumulation.separateRefreshUrls;
+    let refreshRequestPromises = null;
+    if (separateRefreshUrls !== null) {
+        // There are multiple URLs that we need to request the data from. This
+        // happens when a "default" parallel route slot is present in the tree, and
+        // its data cannot be fetched from the current route. We need to split the
+        // combined dynamic request tree into separate requests per URL.
+        // TODO: Create a scoped dynamic request tree that omits anything that
+        // is not relevant to the given URL. Without doing this, the server may
+        // sometimes render more data than necessary; this is not a regression
+        // compared to the pre-Segment Cache implementation, though, just an
+        // optimization we can make in the future.
+        // Construct a request tree for each additional refresh URL. This will
+        // prune away everything except the parts of the tree that match the
+        // given refresh URL.
+        refreshRequestPromises = [];
+        const canonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(primaryUrl);
+        for (const refreshUrl of separateRefreshUrls){
+            if (refreshUrl === canonicalUrl) {
+                continue;
+            }
+            // TODO: Create a scoped dynamic request tree that omits anything that
+            // is not relevant to the given URL. Without doing this, the server may
+            // sometimes render more data than necessary; this is not a regression
+            // compared to the pre-Segment Cache implementation, though, just an
+            // optimization we can make in the future.
+            // 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
+                // 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
+                // hard refresh.
+                nextUrl, freshnessPolicy, routeCacheEntry, navigationLock, 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);
+    // `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) {
+    // 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
+    // pending tasks. If anything is still pending, it means the server response
+    // does not match the client, and we must refresh to get back to a consistent
+    // state. We can skip this step if we already detected a mismatch during the
+    // 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);
+    }
+    switch(exitStatus){
+        case -1:
+            {
+                // This navigation was superseded and its request aborted. Its cache nodes
+                // may already be reused by the newer navigation, so leave them untouched
+                // for the newer request to fulfill. If the tree was abandoned entirely,
+                // it can be garbage collected along with its unresolved promises. We do
+                // not retry or hard-navigate.
+                return;
+            }
+        case 0:
+            {
+                // The task has completely finished. There's no missing data. Exit.
+                previousNavigationDidMismatch = false;
+                return;
+            }
+        case 1:
+            {
+                // Some data failed to finish loading. Trigger a soft retry that re-fetches
+                // the tree's dynamic data.
+                // TODO: As an extra precaution against soft retry loops, consider
+                // tracking whether a navigation was itself triggered by a retry. If two
+                // happen in a row, fall back to a hard retry.
+                const isHardRetry = false;
+                const primaryRequestResult = await primaryRequestPromise;
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType, 3);
+                return;
+            }
+        case 3:
+            {
+                // The route matched, but the request was redirected, so we committed the
+                // wrong canonical URL. Re-resolve the route to invalidate the now-stale
+                // route cache and correct the URL — but reuse the data we already received
+                // (HistoryTraversal) instead of re-fetching it. See issue #95195.
+                const isHardRetry = false;
+                const primaryRequestResult = await primaryRequestPromise;
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType, 2);
+                return;
+            }
+        case 2:
+            {
+                // Some data failed to finish loading in a non-recoverable way, such as a
+                // network error. Trigger an MPA navigation.
+                //
+                // Hard navigating/refreshing is how we prevent an infinite retry loop
+                // caused by a network error — when the network fails, we fall back to the
+                // browser behavior for offline navigations. In the future, Next.js may
+                // introduce its own custom handling of offline navigations, but that
+                // doesn't exist yet.
+                const isHardRetry = true;
+                const primaryRequestResult = await primaryRequestPromise;
+                dispatchRetryDueToTreeMismatch(isHardRetry, primaryRequestResult.url, nextUrl, primaryRequestResult.seed, task.route, routeCacheEntry, navigateType, 3);
+                return;
+            }
+        default:
+            {
+                return exitStatus;
+            }
+    }
+}
+function waitForRequestsToFinish(primaryRequestPromise, refreshRequestPromises) {
+    // Custom async combinator logic. This could be replaced by Promise.any but
+    // 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
+    // requests finish.
+    //
+    // Or, resolve as soon as one of the requests fails, without waiting for the
+    // others to finish.
+    return new Promise((resolve)=>{
+        const onFulfill = (result)=>{
+            if (result.exitStatus === 0) {
+                remainingCount--;
+                if (remainingCount === 0) {
+                    // All the requests finished successfully.
+                    resolve(0);
+                }
+            } else {
+                // One of the requests failed. Exit with a failing status.
+                // NOTE: It's possible for one of the requests to fail with SoftRetry
+                // and a later one to fail with HardRetry. In this case, we choose to
+                // retry immediately, rather than delay the retry until all the requests
+                // finish. If it fails again, we will hard retry on the next
+                // attempt, anyway.
+                resolve(result.exitStatus);
+            }
+        };
+        // onReject shouldn't ever be called because fetchMissingDynamicData's
+        // entire body is wrapped in a try/catch. This is just defensive.
+        const onReject = ()=>resolve(2);
+        // Attach the listeners to the promises.
+        let remainingCount = 1;
+        primaryRequestPromise.then(onFulfill, onReject);
+        if (refreshRequestPromises !== null) {
+            remainingCount += refreshRequestPromises.length;
+            refreshRequestPromises.forEach((refreshRequestPromise)=>refreshRequestPromise.then(onFulfill, onReject));
+        }
+    });
+}
+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, // Freshness policy for the retry navigation. `RefreshAll` re-fetches the
+// tree's dynamic data (used for genuine tree mismatches). `HistoryTraversal`
+// reuses the data already in the tree (used when only the URL needs
+// correcting after a redirect).
+retryFreshnessPolicy) {
+    // If the navigation used a route prediction, mark it as having a dynamic
+    // rewrite since it resulted in a mismatch.
+    if (routeCacheEntry !== null) {
+        (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, retryUrl.search, 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,
+        navigateType: retryNavigateType,
+        freshnessPolicy: retryFreshnessPolicy
+    };
+    (0, _useactionqueue.dispatchAppRouterAction)(retryAction);
+}
+async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, freshnessPolicy, routeCacheEntry, navigationLock, map, signal) {
+    try {
+        const result = await (0, _fetchserverresponse.fetchServerResponse)(url, {
+            flightRouterState: dynamicRequestTree,
+            nextUrl,
+            isHmrRefresh: freshnessPolicy === 4,
+            signal
+        });
+        if (typeof result === 'string') {
+            // fetchServerResponse will return an href to indicate that the SPA
+            // navigation failed. For example, if the server triggered a hard
+            // redirect, or the fetch request errored. Initiate an MPA navigation
+            // to the given href.
+            return {
+                exitStatus: 2,
+                url: new URL(result, location.origin),
+                seed: null
+            };
+        }
+        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 && 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.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(()=>{
+            // 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, result.revealAfter);
+        const resolvedUrl = new URL(result.canonicalUrl, location.origin);
+        // Decide whether the navigation needs to be retried.
+        //
+        // - A tree mismatch (unknown parallel route) means the data is incomplete,
+        //   so we soft-retry and re-fetch the whole tree.
+        // - Otherwise, the navigation committed the canonical URL from the route
+        //   cache entry it used (a prediction or prefetch). If the request resolved
+        //   to a *different* canonical URL — e.g. a middleware/proxy redirect the
+        //   prediction didn't account for — then the committed URL is wrong and the
+        //   route cache it came from is no longer reliable (the redirect implies a
+        //   server change the prediction couldn't know about, like logging in or
+        //   out). We re-resolve the route to invalidate the stale cache and correct
+        //   the browser URL, reusing the data we just received rather than
+        //   re-fetching it. When the entry already reflects the redirect (e.g. a
+        //   prefetch that followed it), the committed URL matches and no retry is
+        //   needed. See issue #95195.
+        let didCommitWrongUrl = false;
+        if (routeCacheEntry !== null) {
+            const committedUrl = new URL(routeCacheEntry.canonicalUrl, location.origin);
+            didCommitWrongUrl = committedUrl.pathname !== resolvedUrl.pathname || committedUrl.search !== resolvedUrl.search;
+        }
+        const exitStatus = didReceiveUnknownParallelRoute ? 1 : didCommitWrongUrl ? 3 : 0;
+        return {
+            exitStatus,
+            url: resolvedUrl,
+            seed
+        };
+    } catch  {
+        if (signal?.aborted) {
+            // A newer HMR refresh superseded this one and aborted its request. Treat
+            // it as canceled rather than a failure, so we don't retry or
+            // hard-navigate.
+            return {
+                exitStatus: -1,
+                url,
+                seed: null
+            };
+        }
+        // This shouldn't happen because fetchServerResponse's entire body is
+        // wrapped in a try/catch. If it does, though, it implies the server failed
+        // to respond with any tree at all. So we must fall back to a hard retry.
+        return {
+            exitStatus: 2,
+            url: url,
+            seed: null
+        };
+    }
+}
+function writeDynamicDataIntoNavigationTask(task, serverRouteTree, dynamicData, dynamicHead, dynamicStaleAt, debugInfo, revealAfter) {
+    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 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.
+                    //
+                    // 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, revealAfter);
+                        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;
+}
+function finishPendingCacheNode(cacheNode, dynamicData, dynamicHead, debugInfo, revealAfter) {
+    // Writes a dynamic response into an existing Cache Node tree. This does _not_
+    // create a new tree, it updates the existing tree in-place. So it must follow
+    // the Suspense rules of cache safety — it can resolve pending promises, but
+    // 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.
+    //
+    // 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.
+    const rsc = cacheNode.rsc;
+    const dynamicSegmentData = dynamicData[0];
+    if (dynamicSegmentData === null) {
+        // This is an empty CacheNode; 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;
+    }
+    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)) {
+        // 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.
+        //
+        // In the streaming dev render, defer the fill until `revealAfter` settles,
+        // so React doesn't render the boundary's children before their row has been
+        // decoded (otherwise it suspends on the still-pending children and commits
+        // a premature fallback). Outside that render `revealAfter` is null and we
+        // resolve immediately.
+        if (revealAfter !== null) {
+            const resolveRsc = ()=>rsc.resolve(dynamicSegmentData, debugInfo);
+            // Use the same callback for both outcomes: we don't expect `revealAfter`
+            // to reject, but if it ever did (e.g. a connection drop mid-stream) we'd
+            // still want to resolve the RSC.
+            revealAfter.then(resolveRsc, resolveRsc);
+        } else {
+            rsc.resolve(dynamicSegmentData, debugInfo);
+        }
+    } else {
+    // This is not a deferred RSC promise, nor is it empty, so it must have
+    // been populated by a different navigation. We must not overwrite it.
+    }
+    // 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);
+    }
+}
+function abortRemainingPendingTasks(task, error, debugInfo) {
+    let exitStatus;
+    if (task.status === 0) {
+        // The data for this segment is still missing.
+        task.status = 2;
+        abortPendingCacheNode(task.node, 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.
+        //
+        // In an app with fully static routes and no proxy-driven redirects or
+        // rewrites, this should never happen, because the route for a URL would
+        // always be the same across multiple requests. So, this implies that some
+        // runtime routing condition changed, likely in a proxy, without being
+        // pushed to the client.
+        //
+        // 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) {
+            // Trigger a "soft" refresh. Essentially the same as calling `refresh()`
+            // in a Server Action.
+            exitStatus = 1;
+        } else {
+            // The mismatch was discovered inside an inactive parallel route. This
+            // implies the inactive parallel route is no longer reachable at the URL
+            // that originally rendered it. Fall back to an MPA refresh.
+            // TODO: An alternative could be to trigger a soft refresh but to _not_
+            // re-use the inactive parallel routes this time. Similar to what would
+            // happen if were to do a hard refrehs, but without the HTML page.
+            exitStatus = 2;
+        }
+    } else {
+        // This segment finished. (An error here is treated as Done because they are
+        // surfaced to the application during render.)
+        exitStatus = 0;
+    }
+    const taskChildren = task.children;
+    if (taskChildren !== null) {
+        for (const [, taskChild] of taskChildren){
+            const childExitStatus = abortRemainingPendingTasks(taskChild, error, debugInfo);
+            // Propagate the exit status up the tree. The statuses are ordered by
+            // their precedence.
+            if (childExitStatus > exitStatus) {
+                exitStatus = childExitStatus;
+            }
+        }
+    }
+    return exitStatus;
+}
+function abortPendingCacheNode(cacheNode, error, debugInfo) {
+    const rsc = cacheNode.rsc;
+    if (isDeferredRsc(rsc)) {
+        if (error === null) {
+            // This will trigger a lazy fetch during render.
+            rsc.resolve(null, debugInfo);
+        } else {
+            // This will trigger an error during rendering.
+            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) {
+    return value && typeof value === 'object' && value.tag === DEFERRED;
+}
+function createDeferredRsc() {
+    // Create an unresolved promise that represents data derived from a Flight
+    // response. The promise will be resolved later as soon as we start receiving
+    // data from the server, i.e. as soon as the Flight client decodes and returns
+    // the top-level response object.
+    // The `_debugInfo` field contains profiling information. Promises that are
+    // created by Flight already have this info added by React; for any derived
+    // promise created by the router, we need to transfer the Flight debug info
+    // onto the derived promise.
+    //
+    // The debug info represents the latency between the start of the navigation
+    // and the start of rendering. (It does not represent the time it takes for
+    // whole stream to finish.)
+    const debugInfo = [];
+    let resolve;
+    let reject;
+    const pendingRsc = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    pendingRsc.status = 'pending';
+    pendingRsc.resolve = (value, responseDebugInfo)=>{
+        if (pendingRsc.status === 'pending') {
+            const fulfilledRsc = pendingRsc;
+            fulfilledRsc.status = 'fulfilled';
+            fulfilledRsc.value = value;
+            if (responseDebugInfo !== null) {
+                // Transfer the debug info to the derived promise.
+                debugInfo.push.apply(debugInfo, responseDebugInfo);
+            }
+            resolve(value);
+        }
+    };
+    pendingRsc.reject = (error, responseDebugInfo)=>{
+        if (pendingRsc.status === 'pending') {
+            const rejectedRsc = pendingRsc;
+            rejectedRsc.status = 'rejected';
+            rejectedRsc.reason = error;
+            if (responseDebugInfo !== null) {
+                // Transfer the debug info to the derived promise.
+                debugInfo.push.apply(debugInfo, responseDebugInfo);
+            }
+            reject(error);
+        }
+    };
+    pendingRsc.tag = DEFERRED;
+    pendingRsc._debugInfo = debugInfo;
+    return pendingRsc;
+}
+function getCurrentNavigationLock() {
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        const { getCurrentNavigationGate } = require('../segment-cache/navigation-testing-lock');
+        return getCurrentNavigationGate();
+    }
+    return null;
+}
+function beginLockedNavigation() {
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        const { beginLockedNavigation: begin } = require('../segment-cache/navigation-testing-lock');
+        return begin();
+    }
+    return null;
+}
+function resetNavigationLockToPending() {
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        const { resetNavigationLockToPending: reset } = require('../segment-cache/navigation-testing-lock');
+        reset();
+    }
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=ppr-navigations.js.map