qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

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

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    abortTask: null,
-    listenForDynamicRequest: null,
-    startPPRNavigation: null,
-    updateCacheNodeOnPopstateRestoration: null
+    FreshnessPolicy: null,
+    createInitialCacheNodeForHydration: null,
+    isDeferredRsc: null,
+    spawnDynamicRequests: null,
+    startPPRNavigation: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -15,51 +16,139 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    abortTask: function() {
-        return abortTask;
+    FreshnessPolicy: function() {
+        return FreshnessPolicy;
     },
-    listenForDynamicRequest: function() {
-        return listenForDynamicRequest;
+    createInitialCacheNodeForHydration: function() {
+        return createInitialCacheNodeForHydration;
+    },
+    isDeferredRsc: function() {
+        return isDeferredRsc;
+    },
+    spawnDynamicRequests: function() {
+        return spawnDynamicRequests;
     },
     startPPRNavigation: function() {
         return startPPRNavigation;
-    },
-    updateCacheNodeOnPopstateRestoration: function() {
-        return updateCacheNodeOnPopstateRestoration;
     }
 });
 const _segment = require("../../../shared/lib/segment");
 const _matchsegments = require("../match-segments");
 const _createhreffromurl = require("./create-href-from-url");
 const _createroutercachekey = require("./create-router-cache-key");
+const _fetchserverresponse = require("./fetch-server-response");
+const _useactionqueue = require("../use-action-queue");
+const _routerreducertypes = require("./router-reducer-types");
 const _isnavigatingtonewrootlayout = require("./is-navigating-to-new-root-layout");
 const _navigatereducer = require("./reducers/navigate-reducer");
-const MPA_NAVIGATION_TASK = {
-    route: null,
-    node: null,
-    dynamicRequestTree: null,
-    children: null
-};
-function startPPRNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouterState, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, scrollableSegmentsResult) {
-    const segmentPath = [];
-    return updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouterState, false, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, segmentPath, scrollableSegmentsResult);
+const _navigation = require("../segment-cache/navigation");
+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";
+    return FreshnessPolicy;
+}({});
+const noop = ()=>{};
+function createInitialCacheNodeForHydration(navigatedAt, initialTree, seedData, seedHead) {
+    // Create the initial cache node tree, using the data embedded into the
+    // HTML document.
+    const accumulation = {
+        scrollableSegments: null,
+        separateRefreshUrls: null
+    };
+    const task = createCacheNodeOnNavigation(navigatedAt, initialTree, undefined, 1, seedData, seedHead, null, null, false, null, null, false, accumulation);
+    // NOTE: We intentionally don't check if any data needs to be fetched from the
+    // server. We assume the initial hydration payload is sufficient to render
+    // the page.
+    //
+    // The completeness of the initial data is an important property that we rely
+    // on as a last-ditch mechanism for recovering the app; we must always be able
+    // to reload a fresh HTML document to get to a consistent state.
+    //
+    // In the future, there may be cases where the server intentionally sends
+    // partial data and expects the client to fill in the rest, in which case this
+    // logic may change. (There already is a similar case where the server sends
+    // _no_ hydration data in the HTML document at all, and the client fetches it
+    // separately, but that's different because we still end up hydrating with a
+    // complete tree.)
+    return task.node;
 }
-function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouterState, didFindRootLayout, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, segmentPath, scrollableSegmentsResult) {
-    // Diff the old and new trees to reuse the shared layouts.
-    const oldRouterStateChildren = oldRouterState[1];
-    const newRouterStateChildren = newRouterState[1];
-    const prefetchDataChildren = prefetchData !== null ? prefetchData[1] : null;
-    if (!didFindRootLayout) {
-        // We're currently traversing the part of the tree that was also part of
-        // the previous route. If we discover a root layout, then we don't need to
-        // trigger an MPA navigation. See beginRenderingNewRouteTree for context.
-        const isRootLayout = newRouterState[4] === true;
-        if (isRootLayout) {
-            // Found a matching root layout.
-            didFindRootLayout = true;
+function startPPRNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouterState, freshness, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, accumulation) {
+    const didFindRootLayout = false;
+    const parentNeedsDynamicRequest = false;
+    const parentRefreshUrl = null;
+    return updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode !== null ? oldCacheNode : undefined, oldRouterState, newRouterState, freshness, didFindRootLayout, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, null, null, parentNeedsDynamicRequest, parentRefreshUrl, accumulation);
+}
+function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRouterState, newRouterState, freshness, didFindRootLayout, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, parentSegmentPath, parentParallelRouteKey, parentNeedsDynamicRequest, parentRefreshUrl, accumulation) {
+    // Check if this segment matches the one in the previous route.
+    const oldSegment = oldRouterState[0];
+    const newSegment = newRouterState[0];
+    if (!(0, _matchsegments.matchSegment)(newSegment, oldSegment)) {
+        // This segment does not match the previous route. We're now entering the
+        // new part of the target route. Switch to the "create" path.
+        if (// Check if the route tree changed before we reached a layout. (The
+        // highest-level layout in a route tree is referred to as the "root"
+        // layout.) This could mean that we're navigating between two different
+        // root layouts. When this happens, we perform a full-page (MPA-style)
+        // navigation.
+        //
+        // However, the algorithm for deciding where to start rendering a route
+        // (i.e. the one performed in order to reach this function) is stricter
+        // than the one used to detect a change in the root layout. So just
+        // because we're re-rendering a segment outside of the root layout does
+        // not mean we should trigger a full-page navigation.
+        //
+        // Specifically, we handle dynamic parameters differently: two segments
+        // are considered the same even if their parameter values are different.
+        //
+        // Refer to isNavigatingToNewRootLayout for details.
+        //
+        // Note that we only have to perform this extra traversal if we didn't
+        // already discover a root layout in the part of the tree that is
+        // unchanged. We also only need to compare the subtree that is not
+        // shared. In the common case, this branch is skipped completely.
+        !didFindRootLayout && (0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(oldRouterState, newRouterState) || // 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;
         }
+        if (parentSegmentPath === null || parentParallelRouteKey === null) {
+            // The root should never mismatch. If it does, it suggests an internal
+            // Next.js error, or a malformed server response. Trigger a full-
+            // page navigation.
+            return null;
+        }
+        return createCacheNodeOnNavigation(navigatedAt, newRouterState, oldCacheNode, freshness, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, parentSegmentPath, parentParallelRouteKey, parentNeedsDynamicRequest, accumulation);
     }
-    const oldParallelRoutes = oldCacheNode.parallelRoutes;
+    // TODO: The segment paths are tracked so that LayoutRouter knows which
+    // segments to scroll to after a navigation. But we should just mark this
+    // information on the CacheNode directly. It used to be necessary to do this
+    // separately because CacheNodes were created lazily during render, not when
+    // rather than when creating the route tree.
+    const segmentPath = parentParallelRouteKey !== null && parentSegmentPath !== null ? parentSegmentPath.concat([
+        parentParallelRouteKey,
+        newSegment
+    ]) : [];
+    const newRouterStateChildren = newRouterState[1];
+    const oldRouterStateChildren = oldRouterState[1];
+    const seedDataChildren = seedData !== null ? seedData[1] : null;
+    const prefetchDataChildren = prefetchData !== null ? prefetchData[1] : null;
+    // We're currently traversing the part of the tree that was also part of
+    // the previous route. If we discover a root layout, then we don't need to
+    // trigger an MPA navigation.
+    const isRootLayout = newRouterState[4] === true;
+    const childDidFindRootLayout = didFindRootLayout || isRootLayout;
+    const oldParallelRoutes = oldCacheNode !== undefined ? oldCacheNode.parallelRoutes : undefined;
     // Clone the current set of segment children, even if they aren't active in
     // the new tree.
     // TODO: We currently retain all the inactive segments indefinitely, until
@@ -71,7 +160,84 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
     // leak. We should figure out a better model for the lifetime of inactive
     // segments, so we can maintain instant back/forward navigations without
     // leaking memory indefinitely.
-    const prefetchParallelRoutes = new Map(oldParallelRoutes);
+    let shouldDropSiblingCaches = false;
+    let shouldRefreshDynamicData = false;
+    switch(freshness){
+        case 0:
+        case 2:
+        case 1:
+            // We should never drop dynamic data in shared layouts, except during
+            // a refresh.
+            shouldDropSiblingCaches = false;
+            shouldRefreshDynamicData = false;
+            break;
+        case 3:
+        case 4:
+            shouldDropSiblingCaches = true;
+            shouldRefreshDynamicData = true;
+            break;
+        default:
+            freshness;
+            break;
+    }
+    const newParallelRoutes = new Map(shouldDropSiblingCaches ? undefined : oldParallelRoutes);
+    // TODO: We're not consistent about how we do this check. Some places
+    // check if the segment starts with PAGE_SEGMENT_KEY, but most seem to
+    // check if there any any children, which is why I'm doing it here. We
+    // should probably encode an empty children set as `null` though. Either
+    // way, we should update all the checks to be consistent.
+    const isLeafSegment = Object.keys(newRouterStateChildren).length === 0;
+    // 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)) {
+        // Reuse the existing CacheNode
+        const dropPrefetchRsc = false;
+        newCacheNode = reuseDynamicCacheNode(dropPrefetchRsc, oldCacheNode, newParallelRoutes);
+        needsDynamicRequest = false;
+    } else if (seedData !== null && seedData[0] !== null) {
+        // If this navigation was the result of an action, then check if the
+        // server sent back data in the action response. We should favor using
+        // that, rather than performing a separate request. This is both better
+        // for performance and it's more likely to be consistent with any
+        // writes that were just performed by the action, compared to a
+        // separate request.
+        const seedRsc = seedData[0];
+        const seedLoading = seedData[2];
+        const isSeedRscPartial = false;
+        const isSeedHeadPartial = seedHead === null;
+        newCacheNode = readCacheNodeFromSeedData(seedRsc, seedLoading, isSeedRscPartial, seedHead, isSeedHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
+        needsDynamicRequest = isLeafSegment && isSeedHeadPartial;
+    } else if (prefetchData !== null) {
+        // Consult the prefetch cache.
+        const prefetchRsc = prefetchData[0];
+        const prefetchLoading = prefetchData[2];
+        const isPrefetchRSCPartial = prefetchData[3];
+        newCacheNode = readCacheNodeFromSeedData(prefetchRsc, prefetchLoading, isPrefetchRSCPartial, prefetchHead, isPrefetchHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
+        needsDynamicRequest = isPrefetchRSCPartial || isLeafSegment && isPrefetchHeadPartial;
+    } else {
+        // Spawn a request to fetch new data from the server.
+        newCacheNode = spawnNewCacheNode(newParallelRoutes, isLeafSegment, navigatedAt, freshness);
+        needsDynamicRequest = true;
+    }
+    // During a refresh navigation, there's a special case that happens when
+    // entering a "default" slot. The default slot may not be part of the
+    // current route; it may have been reused from an older route. If so,
+    // we need to fetch its data from the old route's URL rather than current
+    // route's URL. Keep track of this as we traverse the tree.
+    const href = newRouterState[2];
+    const refreshUrl = typeof href === 'string' && newRouterState[3] === 'refresh' ? // refresh URL as we continue traversing the tree.
+    href : parentRefreshUrl;
+    // If this segment itself needs to fetch new data from the server, then by
+    // definition it is being refreshed. Track its refresh URL so we know which
+    // URL to request the data from.
+    if (needsDynamicRequest && refreshUrl !== null) {
+        accumulateRefreshUrl(accumulation, refreshUrl);
+    }
     // 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
@@ -88,302 +254,266 @@ function updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNode, oldRoute
     //
     // This starts off as `false`, and is set to `true` if any of the child
     // routes requires a dynamic request.
-    let needsDynamicRequest = false;
+    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. needsDynamicRequest is false at the
-    // end), then this will be discarded.
+    // 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 = {};
     for(let parallelRouteKey in newRouterStateChildren){
-        const newRouterStateChild = newRouterStateChildren[parallelRouteKey];
+        let newRouterStateChild = newRouterStateChildren[parallelRouteKey];
         const oldRouterStateChild = oldRouterStateChildren[parallelRouteKey];
-        const oldSegmentMapChild = oldParallelRoutes.get(parallelRouteKey);
-        const prefetchDataChild = prefetchDataChildren !== null ? prefetchDataChildren[parallelRouteKey] : null;
-        const newSegmentChild = newRouterStateChild[0];
-        const newSegmentPathChild = segmentPath.concat([
-            parallelRouteKey,
-            newSegmentChild
-        ]);
+        if (oldRouterStateChild === undefined) {
+            // This should never happen, but if it does, it suggests a malformed
+            // server response. Trigger a full-page navigation.
+            return null;
+        }
+        const oldSegmentMapChild = oldParallelRoutes !== undefined ? oldParallelRoutes.get(parallelRouteKey) : undefined;
+        let seedDataChild = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] : null;
+        let prefetchDataChild = prefetchDataChildren !== null ? prefetchDataChildren[parallelRouteKey] : null;
+        let newSegmentChild = newRouterStateChild[0];
+        let seedHeadChild = seedHead;
+        let prefetchHeadChild = prefetchHead;
+        let isPrefetchHeadPartialChild = isPrefetchHeadPartial;
+        if (// Skip this branch during a history traversal. We restore the tree that
+        // was stashed in the history entry as-is.
+        freshness !== 2 && newSegmentChild === _segment.DEFAULT_SEGMENT_KEY) {
+            // This is a "default" segment. These are never sent by the server during
+            // a soft navigation; instead, the client reuses whatever segment was
+            // already active in that slot on the previous route.
+            newRouterStateChild = reuseActiveSegmentInDefaultSlot(oldUrl, oldRouterStateChild);
+            newSegmentChild = newRouterStateChild[0];
+            // Since we're switching to a different route tree, these are no
+            // longer valid, because they correspond to the outer tree.
+            seedDataChild = null;
+            seedHeadChild = null;
+            prefetchDataChild = null;
+            prefetchHeadChild = null;
+            isPrefetchHeadPartialChild = false;
+        }
         const newSegmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(newSegmentChild);
-        const oldSegmentChild = oldRouterStateChild !== undefined ? oldRouterStateChild[0] : undefined;
         const oldCacheNodeChild = oldSegmentMapChild !== undefined ? oldSegmentMapChild.get(newSegmentKeyChild) : undefined;
-        let taskChild;
-        if (newSegmentChild === _segment.DEFAULT_SEGMENT_KEY) {
-            // This is another kind of leaf segment — a default route.
-            //
-            // Default routes have special behavior. When there's no matching segment
-            // for a parallel route, Next.js preserves the currently active segment
-            // during a client navigation — but not for initial render. The server
-            // leaves it to the client to account for this. So we need to handle
-            // it here.
-            if (oldRouterStateChild !== undefined) {
-                // Reuse the existing Router State for this segment. We spawn a "task"
-                // just to keep track of the updated router state; unlike most, it's
-                // already fulfilled and won't be affected by the dynamic response.
-                taskChild = reuseActiveSegmentInDefaultSlot(oldUrl, oldRouterStateChild);
-            } else {
-                // There's no currently active segment. Switch to the "create" path.
-                taskChild = beginRenderingNewRouteTree(navigatedAt, oldRouterStateChild, newRouterStateChild, oldCacheNodeChild, didFindRootLayout, prefetchDataChild !== undefined ? prefetchDataChild : null, prefetchHead, isPrefetchHeadPartial, newSegmentPathChild, scrollableSegmentsResult);
-            }
-        } else if (isSamePageNavigation && // Check if this is a page segment.
-        // 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.
-        Object.keys(newRouterStateChild[1]).length === 0) {
-            // We special case navigations to the exact same URL as the current
-            // location. It's a common UI pattern for apps to refresh when you click a
-            // link to the current page. So when this happens, we refresh the dynamic
-            // data in the page segments.
-            //
-            // Note that this does not apply if the any part of the hash or search
-            // query has changed. This might feel a bit weird but it makes more sense
-            // when you consider that the way to trigger this behavior is to click
-            // the same link multiple times.
-            //
-            // TODO: We should probably refresh the *entire* route when this case
-            // occurs, not just the page segments. Essentially treating it the same as
-            // a refresh() triggered by an action, which is the more explicit way of
-            // modeling the UI pattern described above.
-            //
-            // Also note that this only refreshes the dynamic data, not static/
-            // cached data. If the page segment is fully static and prefetched, the
-            // request is skipped. (This is also how refresh() works.)
-            taskChild = beginRenderingNewRouteTree(navigatedAt, oldRouterStateChild, newRouterStateChild, oldCacheNodeChild, didFindRootLayout, prefetchDataChild !== undefined ? prefetchDataChild : null, prefetchHead, isPrefetchHeadPartial, newSegmentPathChild, scrollableSegmentsResult);
-        } else if (oldRouterStateChild !== undefined && oldSegmentChild !== undefined && (0, _matchsegments.matchSegment)(newSegmentChild, oldSegmentChild)) {
-            if (oldCacheNodeChild !== undefined && oldRouterStateChild !== undefined) {
-                // This segment exists in both the old and new trees. Recursively update
-                // the children.
-                taskChild = updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNodeChild, oldRouterStateChild, newRouterStateChild, didFindRootLayout, prefetchDataChild, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, newSegmentPathChild, scrollableSegmentsResult);
-            } else {
-                // There's no existing Cache Node for this segment. Switch to the
-                // "create" path.
-                taskChild = beginRenderingNewRouteTree(navigatedAt, oldRouterStateChild, newRouterStateChild, oldCacheNodeChild, didFindRootLayout, prefetchDataChild !== undefined ? prefetchDataChild : null, prefetchHead, isPrefetchHeadPartial, newSegmentPathChild, scrollableSegmentsResult);
-            }
-        } else {
-            // This is a new tree. Switch to the "create" path.
-            taskChild = beginRenderingNewRouteTree(navigatedAt, oldRouterStateChild, newRouterStateChild, oldCacheNodeChild, didFindRootLayout, prefetchDataChild !== undefined ? prefetchDataChild : null, prefetchHead, isPrefetchHeadPartial, newSegmentPathChild, scrollableSegmentsResult);
+        const taskChild = updateCacheNodeOnNavigation(navigatedAt, oldUrl, oldCacheNodeChild, oldRouterStateChild, newRouterStateChild, freshness, childDidFindRootLayout, seedDataChild ?? null, seedHeadChild, prefetchDataChild ?? null, prefetchHeadChild, isPrefetchHeadPartialChild, isSamePageNavigation, segmentPath, parallelRouteKey, parentNeedsDynamicRequest || needsDynamicRequest, refreshUrl, accumulation);
+        if (taskChild === null) {
+            // One of the child tasks discovered a change to the root layout.
+            // Immediately unwind from this recursive traversal. This will trigger a
+            // full-page navigation.
+            return null;
         }
-        if (taskChild !== null) {
-            // Recursively propagate up the child tasks.
-            if (taskChild.route === null) {
-                // One of the child tasks discovered a change to the root layout.
-                // Immediately unwind from this recursive traversal.
-                return MPA_NAVIGATION_TASK;
-            }
-            if (taskChildren === null) {
-                taskChildren = new Map();
-            }
-            taskChildren.set(parallelRouteKey, taskChild);
-            const newCacheNodeChild = taskChild.node;
-            if (newCacheNodeChild !== null) {
-                const newSegmentMapChild = new Map(oldSegmentMapChild);
-                newSegmentMapChild.set(newSegmentKeyChild, newCacheNodeChild);
-                prefetchParallelRoutes.set(parallelRouteKey, newSegmentMapChild);
-            }
-            // The child tree's route state may be different from the prefetched
-            // route sent by the server. We need to clone it as we traverse back up
-            // the tree.
-            const taskChildRoute = taskChild.route;
-            patchedRouterStateChildren[parallelRouteKey] = taskChildRoute;
-            const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
-            if (dynamicRequestTreeChild !== null) {
-                // Something in the child tree is dynamic.
-                needsDynamicRequest = true;
-                dynamicRequestTreeChildren[parallelRouteKey] = dynamicRequestTreeChild;
-            } else {
-                dynamicRequestTreeChildren[parallelRouteKey] = taskChildRoute;
-            }
+        // Recursively propagate up the child tasks.
+        if (taskChildren === null) {
+            taskChildren = new Map();
+        }
+        taskChildren.set(parallelRouteKey, taskChild);
+        const newCacheNodeChild = taskChild.node;
+        if (newCacheNodeChild !== null) {
+            const newSegmentMapChild = new Map(shouldDropSiblingCaches ? undefined : oldSegmentMapChild);
+            newSegmentMapChild.set(newSegmentKeyChild, newCacheNodeChild);
+            newParallelRoutes.set(parallelRouteKey, newSegmentMapChild);
+        }
+        // The child tree's route state may be different from the prefetched
+        // route sent by the server. We need to clone it as we traverse back up
+        // the tree.
+        const taskChildRoute = taskChild.route;
+        patchedRouterStateChildren[parallelRouteKey] = taskChildRoute;
+        const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
+        if (dynamicRequestTreeChild !== null) {
+            // Something in the child tree is dynamic.
+            childNeedsDynamicRequest = true;
+            dynamicRequestTreeChildren[parallelRouteKey] = dynamicRequestTreeChild;
         } else {
-            // The child didn't change. We can use the prefetched router state.
-            patchedRouterStateChildren[parallelRouteKey] = newRouterStateChild;
-            dynamicRequestTreeChildren[parallelRouteKey] = newRouterStateChild;
+            dynamicRequestTreeChildren[parallelRouteKey] = taskChildRoute;
         }
     }
-    if (taskChildren === null) {
-        // No new tasks were spawned.
-        return null;
-    }
-    const newCacheNode = {
-        lazyData: null,
-        rsc: oldCacheNode.rsc,
-        // We intentionally aren't updating the prefetchRsc field, since this node
-        // is already part of the current tree, because it would be weird for
-        // prefetch data to be newer than the final data. It probably won't ever be
-        // observable anyway, but it could happen if the segment is unmounted then
-        // mounted again, because LayoutRouter will momentarily switch to rendering
-        // prefetchRsc, via useDeferredValue.
-        prefetchRsc: oldCacheNode.prefetchRsc,
-        head: oldCacheNode.head,
-        prefetchHead: oldCacheNode.prefetchHead,
-        loading: oldCacheNode.loading,
-        // Everything is cloned except for the children, which we computed above.
-        parallelRoutes: prefetchParallelRoutes,
-        navigatedAt
-    };
     return {
-        // Return a cloned copy of the router state with updated children.
+        status: needsDynamicRequest ? 0 : 1,
         route: patchRouterStateWithNewChildren(newRouterState, patchedRouterStateChildren),
         node: newCacheNode,
-        dynamicRequestTree: needsDynamicRequest ? patchRouterStateWithNewChildren(newRouterState, dynamicRequestTreeChildren) : null,
+        dynamicRequestTree: createDynamicRequestTree(newRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest),
+        refreshUrl,
         children: taskChildren
     };
 }
-function beginRenderingNewRouteTree(navigatedAt, oldRouterState, newRouterState, existingCacheNode, didFindRootLayout, prefetchData, possiblyPartialPrefetchHead, isPrefetchHeadPartial, segmentPath, scrollableSegmentsResult) {
-    if (!didFindRootLayout) {
-        // The route tree changed before we reached a layout. (The highest-level
-        // layout in a route tree is referred to as the "root" layout.) This could
-        // mean that we're navigating between two different root layouts. When this
-        // happens, we perform a full-page (MPA-style) navigation.
-        //
-        // However, the algorithm for deciding where to start rendering a route
-        // (i.e. the one performed in order to reach this function) is stricter
-        // than the one used to detect a change in the root layout. So just because
-        // we're re-rendering a segment outside of the root layout does not mean we
-        // should trigger a full-page navigation.
-        //
-        // Specifically, we handle dynamic parameters differently: two segments are
-        // considered the same even if their parameter values are different.
-        //
-        // Refer to isNavigatingToNewRootLayout for details.
-        //
-        // Note that we only have to perform this extra traversal if we didn't
-        // already discover a root layout in the part of the tree that is unchanged.
-        // In the common case, this branch is skipped completely.
-        if (oldRouterState === undefined || (0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(oldRouterState, newRouterState)) {
-            // The root layout changed. Perform a full-page navigation.
-            return MPA_NAVIGATION_TASK;
-        }
-    }
-    return createCacheNodeOnNavigation(navigatedAt, newRouterState, existingCacheNode, prefetchData, possiblyPartialPrefetchHead, isPrefetchHeadPartial, segmentPath, scrollableSegmentsResult);
-}
-function createCacheNodeOnNavigation(navigatedAt, routerState, existingCacheNode, prefetchData, possiblyPartialPrefetchHead, isPrefetchHeadPartial, segmentPath, scrollableSegmentsResult) {
-    // Same traversal as updateCacheNodeNavigation, but 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.
-    // The head is assigned to every leaf segment delivered by the server. Based
-    // on corresponding logic in fill-lazy-items-till-leaf-with-head.ts
-    const routerStateChildren = routerState[1];
-    const isLeafSegment = Object.keys(routerStateChildren).length === 0;
-    // Even we're rendering inside the "new" part of the target tree, we may have
-    // a locally cached segment that we can reuse. This may come from either 1)
-    // the CacheNode tree, which lives in React state and is populated by previous
-    // navigations; or 2) the prefetch cache, which is a separate cache that is
-    // populated by prefetches.
-    let rsc;
-    let loading;
-    let head;
-    let cacheNodeNavigatedAt;
-    if (existingCacheNode !== undefined && // DYNAMIC_STALETIME_MS defaults to 0, but it can be increased using
-    // the experimental.staleTimes.dynamic config. When set, we'll avoid
-    // refetching dynamic data if it was fetched within the given threshold.
-    existingCacheNode.navigatedAt + _navigatereducer.DYNAMIC_STALETIME_MS > navigatedAt) {
-        // We have an existing CacheNode for this segment, and it's not stale. We
-        // should reuse it rather than request a new one.
-        rsc = existingCacheNode.rsc;
-        loading = existingCacheNode.loading;
-        head = existingCacheNode.head;
-        // Don't update the navigatedAt timestamp, since we're reusing stale data.
-        cacheNodeNavigatedAt = existingCacheNode.navigatedAt;
-    } else if (prefetchData !== null) {
-        // There's no existing CacheNode for this segment, but we do have prefetch
-        // data. If the prefetch data is fully static (i.e. does not contain any
-        // dynamic holes), we don't need to request it from the server.
-        rsc = prefetchData[0];
-        loading = prefetchData[2];
-        head = isLeafSegment ? possiblyPartialPrefetchHead : null;
-        // Even though we're accessing the data from the prefetch cache, this is
-        // conceptually a new segment, not a reused one. So we should update the
-        // navigatedAt timestamp.
-        cacheNodeNavigatedAt = navigatedAt;
-        const isPrefetchRscPartial = prefetchData[3];
-        if (// Check if the segment data is partial
-        isPrefetchRscPartial || // Check if the head is partial (only relevant if this is a leaf segment)
-        isPrefetchHeadPartial && isLeafSegment) {
-            // We only have partial data from this segment. Like missing segments, we
-            // must request the full data from the server.
-            return spawnPendingTask(navigatedAt, routerState, prefetchData, possiblyPartialPrefetchHead, isPrefetchHeadPartial, segmentPath, scrollableSegmentsResult);
-        } else {
-        // The prefetch data is fully static, so we can omit it from the
-        // navigation request.
-        }
-    } else {
-        // There's no prefetch for this segment. Everything from this point will be
-        // requested from the server, even if there are static children below it.
-        // Create a terminal task node that will later be fulfilled by
-        // server response.
-        return spawnPendingTask(navigatedAt, routerState, null, possiblyPartialPrefetchHead, isPrefetchHeadPartial, segmentPath, scrollableSegmentsResult);
-    }
-    // We already have a full segment we can render, so we don't need to request a
-    // new one from the server. Keep traversing down the tree until we reach
-    // something that requires a dynamic request.
+function createCacheNodeOnNavigation(navigatedAt, newRouterState, oldCacheNode, freshness, seedData, seedHead, prefetchData, prefetchHead, isPrefetchHeadPartial, parentSegmentPath, parentParallelRouteKey, parentNeedsDynamicRequest, accumulation) {
+    // Same traversal as updateCacheNodeNavigation, but simpler. We switch to this
+    // path once we reach the part of the tree that was not in the previous route.
+    // We don't need to diff against the old tree, we just need to create a new
+    // one. We also don't need to worry about any refresh-related logic.
+    //
+    // For the most part, this is a subset of updateCacheNodeOnNavigation, so any
+    // change that happens in this function likely needs to be applied to that
+    // one, too. However there are some places where the behavior intentionally
+    // diverges, which is why we keep them separate.
+    const newSegment = newRouterState[0];
+    const segmentPath = parentParallelRouteKey !== null && parentSegmentPath !== null ? parentSegmentPath.concat([
+        parentParallelRouteKey,
+        newSegment
+    ]) : [];
+    const newRouterStateChildren = newRouterState[1];
     const prefetchDataChildren = prefetchData !== null ? prefetchData[1] : null;
-    const taskChildren = new Map();
-    const existingCacheNodeChildren = existingCacheNode !== undefined ? existingCacheNode.parallelRoutes : null;
-    const cacheNodeChildren = new Map(existingCacheNodeChildren);
-    let dynamicRequestTreeChildren = {};
-    let needsDynamicRequest = false;
+    const seedDataChildren = seedData !== null ? seedData[1] : null;
+    const oldParallelRoutes = oldCacheNode !== undefined ? oldCacheNode.parallelRoutes : undefined;
+    let shouldDropSiblingCaches = false;
+    let shouldRefreshDynamicData = false;
+    let dropPrefetchRsc = false;
+    switch(freshness){
+        case 0:
+            // We should never drop dynamic data in sibling caches except during
+            // a refresh.
+            shouldDropSiblingCaches = false;
+            // Only reuse the dynamic data if experimental.staleTimes.dynamic config
+            // is set, and the data is not stale. (This is not a recommended API with
+            // Cache Components, but it's supported for backwards compatibility. Use
+            // cacheLife instead.)
+            //
+            // DYNAMIC_STALETIME_MS defaults to 0, but it can be increased.
+            shouldRefreshDynamicData = oldCacheNode === undefined || navigatedAt - oldCacheNode.navigatedAt >= _navigatereducer.DYNAMIC_STALETIME_MS;
+            dropPrefetchRsc = false;
+            break;
+        case 1:
+            // During hydration, we assume the data sent by the server is both
+            // consistent and complete.
+            shouldRefreshDynamicData = false;
+            shouldDropSiblingCaches = false;
+            dropPrefetchRsc = false;
+            break;
+        case 2:
+            // During back/forward navigations, we reuse the dynamic data regardless
+            // of how stale it may be.
+            shouldRefreshDynamicData = false;
+            shouldRefreshDynamicData = false;
+            // Only show prefetched data if the dynamic data is still pending. This
+            // avoids a flash back to the prefetch state in a case where it's highly
+            // likely to have already streamed in.
+            //
+            // Tehnically, what we're actually checking is whether the dynamic network
+            // response was received. But since it's a streaming response, this does
+            // not mean that all the dynamic data has fully streamed in. It just means
+            // that _some_ of the dynamic data was received. But as a heuristic, we
+            // assume that the rest dynamic data will stream in quickly, so it's still
+            // better to skip the prefetch state.
+            if (oldCacheNode !== undefined) {
+                const oldRsc = oldCacheNode.rsc;
+                const oldRscDidResolve = !isDeferredRsc(oldRsc) || oldRsc.status !== 'pending';
+                dropPrefetchRsc = oldRscDidResolve;
+            } else {
+                dropPrefetchRsc = false;
+            }
+            break;
+        case 3:
+        case 4:
+            // Drop all dynamic data.
+            shouldRefreshDynamicData = true;
+            shouldDropSiblingCaches = true;
+            dropPrefetchRsc = false;
+            break;
+        default:
+            freshness;
+            break;
+    }
+    const newParallelRoutes = new Map(shouldDropSiblingCaches ? undefined : oldParallelRoutes);
+    const isLeafSegment = Object.keys(newRouterStateChildren).length === 0;
     if (isLeafSegment) {
         // The segment path of every leaf segment (i.e. page) is collected into
         // a result array. This is used by the LayoutRouter to scroll to ensure that
         // new pages are visible after a navigation.
+        //
+        // This only happens for new pages, not for refreshed pages.
+        //
         // TODO: We should use a string to represent the segment path instead of
         // an array. We already use a string representation for the path when
         // accessing the Segment Cache, so we can use the same one.
-        scrollableSegmentsResult.push(segmentPath);
+        if (accumulation.scrollableSegments === null) {
+            accumulation.scrollableSegments = [];
+        }
+        accumulation.scrollableSegments.push(segmentPath);
+    }
+    let newCacheNode;
+    let needsDynamicRequest;
+    if (!shouldRefreshDynamicData && oldCacheNode !== undefined) {
+        // Reuse the existing CacheNode
+        newCacheNode = reuseDynamicCacheNode(dropPrefetchRsc, oldCacheNode, newParallelRoutes);
+        needsDynamicRequest = false;
+    } else if (seedData !== null && seedData[0] !== null) {
+        // If this navigation was the result of an action, then check if the
+        // server sent back data in the action response. We should favor using
+        // that, rather than performing a separate request. This is both better
+        // for performance and it's more likely to be consistent with any
+        // writes that were just performed by the action, compared to a
+        // separate request.
+        const seedRsc = seedData[0];
+        const seedLoading = seedData[2];
+        const isSeedRscPartial = false;
+        const isSeedHeadPartial = seedHead === null && freshness !== 1;
+        newCacheNode = readCacheNodeFromSeedData(seedRsc, seedLoading, isSeedRscPartial, seedHead, isSeedHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
+        needsDynamicRequest = isLeafSegment && isSeedHeadPartial;
+    } else if (freshness === 1 && isLeafSegment && seedHead !== null) {
+        // This is another weird case related to "not found" pages and hydration.
+        // There will be a head sent by the server, but no page seed data.
+        // TODO: We really should get rid of all these "not found" specific quirks
+        // and make sure the tree is always consistent.
+        const seedRsc = null;
+        const seedLoading = null;
+        const isSeedRscPartial = false;
+        const isSeedHeadPartial = false;
+        newCacheNode = readCacheNodeFromSeedData(seedRsc, seedLoading, isSeedRscPartial, seedHead, isSeedHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
+        needsDynamicRequest = false;
+    } else if (freshness !== 1 && prefetchData !== null) {
+        // Consult the prefetch cache.
+        const prefetchRsc = prefetchData[0];
+        const prefetchLoading = prefetchData[2];
+        const isPrefetchRSCPartial = prefetchData[3];
+        newCacheNode = readCacheNodeFromSeedData(prefetchRsc, prefetchLoading, isPrefetchRSCPartial, prefetchHead, isPrefetchHeadPartial, isLeafSegment, newParallelRoutes, navigatedAt);
+        needsDynamicRequest = isPrefetchRSCPartial || isLeafSegment && isPrefetchHeadPartial;
     } else {
-        for(let parallelRouteKey in routerStateChildren){
-            const routerStateChild = routerStateChildren[parallelRouteKey];
-            const prefetchDataChild = prefetchDataChildren !== null ? prefetchDataChildren[parallelRouteKey] : null;
-            const existingSegmentMapChild = existingCacheNodeChildren !== null ? existingCacheNodeChildren.get(parallelRouteKey) : undefined;
-            const segmentChild = routerStateChild[0];
-            const segmentPathChild = segmentPath.concat([
-                parallelRouteKey,
-                segmentChild
-            ]);
-            const segmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(segmentChild);
-            const existingCacheNodeChild = existingSegmentMapChild !== undefined ? existingSegmentMapChild.get(segmentKeyChild) : undefined;
-            const taskChild = createCacheNodeOnNavigation(navigatedAt, routerStateChild, existingCacheNodeChild, prefetchDataChild, possiblyPartialPrefetchHead, isPrefetchHeadPartial, segmentPathChild, scrollableSegmentsResult);
-            taskChildren.set(parallelRouteKey, taskChild);
-            const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
-            if (dynamicRequestTreeChild !== null) {
-                // Something in the child tree is dynamic.
-                needsDynamicRequest = true;
-                dynamicRequestTreeChildren[parallelRouteKey] = dynamicRequestTreeChild;
-            } else {
-                dynamicRequestTreeChildren[parallelRouteKey] = routerStateChild;
-            }
-            const newCacheNodeChild = taskChild.node;
-            if (newCacheNodeChild !== null) {
-                const newSegmentMapChild = new Map();
-                newSegmentMapChild.set(segmentKeyChild, newCacheNodeChild);
-                cacheNodeChildren.set(parallelRouteKey, newSegmentMapChild);
-            }
+        // Spawn a request to fetch new data from the server.
+        newCacheNode = spawnNewCacheNode(newParallelRoutes, isLeafSegment, navigatedAt, freshness);
+        needsDynamicRequest = true;
+    }
+    let patchedRouterStateChildren = {};
+    let taskChildren = null;
+    let childNeedsDynamicRequest = false;
+    let dynamicRequestTreeChildren = {};
+    for(let parallelRouteKey in newRouterStateChildren){
+        const newRouterStateChild = newRouterStateChildren[parallelRouteKey];
+        const oldSegmentMapChild = oldParallelRoutes !== undefined ? oldParallelRoutes.get(parallelRouteKey) : undefined;
+        const seedDataChild = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] : null;
+        const prefetchDataChild = prefetchDataChildren !== null ? prefetchDataChildren[parallelRouteKey] : null;
+        const newSegmentChild = newRouterStateChild[0];
+        const newSegmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(newSegmentChild);
+        const oldCacheNodeChild = oldSegmentMapChild !== undefined ? oldSegmentMapChild.get(newSegmentKeyChild) : undefined;
+        const taskChild = createCacheNodeOnNavigation(navigatedAt, newRouterStateChild, oldCacheNodeChild, freshness, seedDataChild ?? null, seedHead, prefetchDataChild ?? null, prefetchHead, isPrefetchHeadPartial, segmentPath, parallelRouteKey, parentNeedsDynamicRequest || needsDynamicRequest, accumulation);
+        if (taskChildren === null) {
+            taskChildren = new Map();
+        }
+        taskChildren.set(parallelRouteKey, taskChild);
+        const newCacheNodeChild = taskChild.node;
+        if (newCacheNodeChild !== null) {
+            const newSegmentMapChild = new Map(shouldDropSiblingCaches ? undefined : oldSegmentMapChild);
+            newSegmentMapChild.set(newSegmentKeyChild, newCacheNodeChild);
+            newParallelRoutes.set(parallelRouteKey, newSegmentMapChild);
+        }
+        const taskChildRoute = taskChild.route;
+        patchedRouterStateChildren[parallelRouteKey] = taskChildRoute;
+        const dynamicRequestTreeChild = taskChild.dynamicRequestTree;
+        if (dynamicRequestTreeChild !== null) {
+            childNeedsDynamicRequest = true;
+            dynamicRequestTreeChildren[parallelRouteKey] = dynamicRequestTreeChild;
+        } else {
+            dynamicRequestTreeChildren[parallelRouteKey] = taskChildRoute;
         }
     }
     return {
-        // Since we're inside a new route tree, unlike the
-        // `updateCacheNodeOnNavigation` path, the router state on the children
-        // tasks is always the same as the router state we pass in. So we don't need
-        // to clone/modify it.
-        route: routerState,
-        node: {
-            lazyData: null,
-            // Since this segment is already full, we don't need to use the
-            // `prefetchRsc` field.
-            rsc,
-            prefetchRsc: null,
-            head,
-            prefetchHead: null,
-            loading,
-            parallelRoutes: cacheNodeChildren,
-            navigatedAt: cacheNodeNavigatedAt
-        },
-        dynamicRequestTree: needsDynamicRequest ? patchRouterStateWithNewChildren(routerState, dynamicRequestTreeChildren) : null,
+        status: needsDynamicRequest ? 0 : 1,
+        route: patchRouterStateWithNewChildren(newRouterState, patchedRouterStateChildren),
+        node: newCacheNode,
+        dynamicRequestTree: createDynamicRequestTree(newRouterState, dynamicRequestTreeChildren, needsDynamicRequest, childNeedsDynamicRequest, parentNeedsDynamicRequest),
+        // This route is not part of the current tree, so there's no reason to
+        // track the refresh URL.
+        refreshUrl: null,
         children: taskChildren
     };
 }
@@ -406,22 +536,48 @@ function patchRouterStateWithNewChildren(baseRouterState, newChildren) {
     }
     return clone;
 }
-function spawnPendingTask(navigatedAt, routerState, prefetchData, prefetchHead, isPrefetchHeadPartial, segmentPath, scrollableSegmentsResult) {
-    // Create a task that will later be fulfilled by data from the server.
-    // Clone the prefetched route tree and the `refetch` marker to it. We'll send
-    // this to the server so it knows where to start rendering.
-    const dynamicRequestTree = patchRouterStateWithNewChildren(routerState, routerState[1]);
-    dynamicRequestTree[3] = 'refetch';
-    const newTask = {
-        route: routerState,
-        // Corresponds to the part of the route that will be rendered on the server.
-        node: createPendingCacheNode(navigatedAt, routerState, prefetchData, prefetchHead, isPrefetchHeadPartial, segmentPath, scrollableSegmentsResult),
-        // Because this is non-null, and it gets propagated up through the parent
-        // tasks, the root task will know that it needs to perform a server request.
-        dynamicRequestTree,
-        children: null
-    };
-    return newTask;
+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, refreshUrl) {
+    // 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 separateRefreshUrls = accumulation.separateRefreshUrls;
+    if (separateRefreshUrls === null) {
+        accumulation.separateRefreshUrls = new Set([
+            refreshUrl
+        ]);
+    } else {
+        separateRefreshUrls.add(refreshUrl);
+    }
 }
 function reuseActiveSegmentInDefaultSlot(oldUrl, oldRouterState) {
     // This is a "default" segment. These are never sent by the server during a
@@ -446,166 +602,349 @@ function reuseActiveSegmentInDefaultSlot(oldUrl, oldRouterState) {
         reusedRouterState[2] = (0, _createhreffromurl.createHrefFromUrl)(oldUrl);
         reusedRouterState[3] = 'refresh';
     }
-    return {
-        route: reusedRouterState,
-        node: null,
-        dynamicRequestTree: null,
-        children: null
+    return reusedRouterState;
+}
+function reuseDynamicCacheNode(dropPrefetchRsc, existingCacheNode, parallelRoutes) {
+    // Clone an existing CacheNode's data, with (possibly) new children.
+    const cacheNode = {
+        rsc: existingCacheNode.rsc,
+        prefetchRsc: dropPrefetchRsc ? null : existingCacheNode.prefetchRsc,
+        head: existingCacheNode.head,
+        prefetchHead: dropPrefetchRsc ? null : existingCacheNode.prefetchHead,
+        loading: existingCacheNode.loading,
+        parallelRoutes,
+        // Don't update the navigatedAt timestamp, since we're reusing
+        // existing data.
+        navigatedAt: existingCacheNode.navigatedAt
     };
+    return cacheNode;
 }
-function listenForDynamicRequest(task, responsePromise) {
-    responsePromise.then((result)=>{
-        if (typeof result === 'string') {
-            // Happens when navigating to page in `pages` from `app`. We shouldn't
-            // get here because should have already handled this during
-            // the prefetch.
-            return;
+function readCacheNodeFromSeedData(seedRsc, seedLoading, isSeedRscPartial, seedHead, isSeedHeadPartial, isPageSegment, parallelRoutes, navigatedAt) {
+    // TODO: Currently this is threaded through the navigation logic using the
+    // CacheNodeSeedData type, but in the future this will read directly from
+    // the Segment Cache. See readRenderSnapshotFromCache.
+    let rsc;
+    let prefetchRsc;
+    if (isSeedRscPartial) {
+        // The prefetched data contains dynamic holes. Create a pending promise that
+        // will be fulfilled when the dynamic data is received from the server.
+        prefetchRsc = seedRsc;
+        rsc = createDeferredRsc();
+    } else {
+        // The prefetched data is complete. Use it directly.
+        prefetchRsc = null;
+        rsc = seedRsc;
+    }
+    // If this is a page segment, also read the head.
+    let prefetchHead;
+    let head;
+    if (isPageSegment) {
+        if (isSeedHeadPartial) {
+            prefetchHead = seedHead;
+            head = createDeferredRsc();
+        } else {
+            prefetchHead = null;
+            head = seedHead;
         }
-        const { flightData, debugInfo } = result;
-        for (const normalizedFlightData of flightData){
-            const { segmentPath, tree: serverRouterState, seedData: dynamicData, head: dynamicHead } = normalizedFlightData;
-            if (!dynamicData) {
+    } else {
+        prefetchHead = null;
+        head = null;
+    }
+    const cacheNode = {
+        rsc,
+        prefetchRsc,
+        head,
+        prefetchHead,
+        // TODO: Technically, a loading boundary could contain dynamic data. We
+        // should have separate `loading` and `prefetchLoading` fields to handle
+        // this, like we do for the segment data and head.
+        loading: seedLoading,
+        parallelRoutes,
+        navigatedAt
+    };
+    return cacheNode;
+}
+function spawnNewCacheNode(parallelRoutes, isLeafSegment, navigatedAt, freshness) {
+    // We should never spawn network requests during hydration. We must treat the
+    // initial payload as authoritative, because the initial page load is used
+    // as a last-ditch mechanism for recovering the app.
+    //
+    // This is also an important safety check because if this leaks into the
+    // server rendering path (which theoretically it never should because
+    // the server payload should be consistent), the server would hang because
+    // these promises would never resolve.
+    //
+    // TODO: There is an existing case where the global "not found" boundary
+    // triggers this path. But it does render correctly despite that. That's an
+    // unusual render path so it's not surprising, but we should look into
+    // modeling it in a more consistent way. See also the /_notFound special
+    // case in updateCacheNodeOnNavigation.
+    const isHydration = freshness === 1;
+    const cacheNode = {
+        rsc: !isHydration ? createDeferredRsc() : null,
+        prefetchRsc: null,
+        head: !isHydration && isLeafSegment ? createDeferredRsc() : null,
+        prefetchHead: null,
+        loading: !isHydration ? createDeferredRsc() : null,
+        parallelRoutes,
+        navigatedAt
+    };
+    return cacheNode;
+}
+// Represents whether the previuos navigation resulted in a route tree mismatch.
+// A mismatch results in a refresh of the page. If there are two successive
+// mismatches, we will fall back to an MPA navigation, to prevent a retry loop.
+let previousNavigationDidMismatch = false;
+function spawnDynamicRequests(task, primaryUrl, nextUrl, freshnessPolicy, accumulation) {
+    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);
+    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;
             }
-            writeDynamicDataIntoPendingTask(task, segmentPath, serverRouterState, dynamicData, dynamicHead, debugInfo);
+            // 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));
+            }
         }
-        // Now that we've exhausted all the data we received from the server, if
-        // there are any remaining pending tasks in the tree, abort them now.
-        // If there's any missing data, it will trigger a lazy fetch.
-        abortTask(task, null, debugInfo);
-    }, (error)=>{
-        // This will trigger an error during render
-        abortTask(task, error, null);
-    });
+    }
+    // Further async operations are moved into this separate function to
+    // discourage sequential network requests.
+    const voidPromise = finishNavigationTask(task, nextUrl, primaryRequestPromise, refreshRequestPromises);
+    // `finishNavigationTask` is responsible for error handling, so we can attach
+    // noop callbacks to this promise.
+    voidPromise.then(noop, noop);
 }
-function writeDynamicDataIntoPendingTask(rootTask, segmentPath, serverRouterState, dynamicData, dynamicHead, debugInfo) {
-    // The data sent by the server represents only a subtree of the app. We need
-    // to find the part of the task tree that matches the server response, and
-    // fulfill it using the dynamic data.
-    //
-    // segmentPath represents the parent path of subtree. It's a repeating pattern
-    // of parallel route key and segment:
+async function finishNavigationTask(task, nextUrl, primaryRequestPromise, refreshRequestPromises) {
+    // 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 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.
+                // 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);
+                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);
+                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.
     //
-    //   [string, Segment, string, Segment, string, Segment, ...]
+    // 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.
     //
-    // Iterate through the path and finish any tasks that match this payload.
-    let task = rootTask;
-    for(let i = 0; i < segmentPath.length; i += 2){
-        const parallelRouteKey = segmentPath[i];
-        const segment = segmentPath[i + 1];
-        const taskChildren = task.children;
-        if (taskChildren !== null) {
-            const taskChild = taskChildren.get(parallelRouteKey);
-            if (taskChild !== undefined) {
-                const taskSegment = taskChild.route[0];
-                if ((0, _matchsegments.matchSegment)(segment, taskSegment)) {
-                    // Found a match for this task. Keep traversing down the task tree.
-                    task = taskChild;
-                    continue;
+    // 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));
         }
-        // We didn't find a child task that matches the server data. Exit. We won't
-        // abort the task, though, because a different FlightDataPath may be able to
-        // fulfill it (see loop in listenForDynamicRequest). We only abort tasks
-        // once we've run out of data.
-        return;
+    });
+}
+function dispatchRetryDueToTreeMismatch(isHardRetry, retryUrl, retryNextUrl, seed, 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;
+    const retryAction = {
+        type: _routerreducertypes.ACTION_SERVER_PATCH,
+        previousTree: baseTree,
+        url: retryUrl,
+        nextUrl: retryNextUrl,
+        seed,
+        mpa: isHardRetry
+    };
+    (0, _useactionqueue.dispatchAppRouterAction)(retryAction);
+}
+async function fetchMissingDynamicData(task, dynamicRequestTree, url, nextUrl, freshnessPolicy) {
+    try {
+        const result = await (0, _fetchserverresponse.fetchServerResponse)(url, {
+            flightRouterState: dynamicRequestTree,
+            nextUrl,
+            isHmrRefresh: freshnessPolicy === 4
+        });
+        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 seed = (0, _navigation.convertServerPatchToFullTree)(task.route, result.flightData, result.renderedSearch);
+        const didReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(task, seed.tree, seed.data, seed.head, result.debugInfo);
+        return {
+            exitStatus: didReceiveUnknownParallelRoute ? 1 : 0,
+            url: new URL(result.canonicalUrl, location.origin),
+            seed
+        };
+    } catch  {
+        // 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
+        };
     }
-    finishTaskUsingDynamicDataPayload(task, serverRouterState, dynamicData, dynamicHead, debugInfo);
 }
-function finishTaskUsingDynamicDataPayload(task, serverRouterState, dynamicData, dynamicHead, debugInfo) {
-    if (task.dynamicRequestTree === null) {
-        // Everything in this subtree is already complete. Bail out.
-        return;
+function writeDynamicDataIntoNavigationTask(task, serverRouterState, dynamicData, dynamicHead, debugInfo) {
+    if (task.status === 0 && dynamicData !== null) {
+        task.status = 1;
+        finishPendingCacheNode(task.node, dynamicData, dynamicHead, debugInfo);
     }
-    // dynamicData may represent a larger subtree than the task. Before we can
-    // finish the task, we need to line them up.
     const taskChildren = task.children;
-    const taskNode = task.node;
-    if (taskChildren === null) {
-        // We've reached the leaf node of the pending task. The server data tree
-        // lines up the pending Cache Node tree. We can now switch to the
-        // normal algorithm.
-        if (taskNode !== null) {
-            finishPendingCacheNode(taskNode, task.route, serverRouterState, dynamicData, dynamicHead, debugInfo);
-            // Set this to null to indicate that this task is now complete.
-            task.dynamicRequestTree = null;
-        }
-        return;
-    }
-    // The server returned more data than we need to finish the task. Skip over
-    // the extra segments until we reach the leaf task node.
     const serverChildren = serverRouterState[1];
-    const dynamicDataChildren = dynamicData[1];
-    for(const parallelRouteKey in serverRouterState){
-        const serverRouterStateChild = serverChildren[parallelRouteKey];
-        const dynamicDataChild = dynamicDataChildren[parallelRouteKey];
-        const taskChild = taskChildren.get(parallelRouteKey);
-        if (taskChild !== undefined) {
-            const taskSegment = taskChild.route[0];
-            if ((0, _matchsegments.matchSegment)(serverRouterStateChild[0], taskSegment) && dynamicDataChild !== null && dynamicDataChild !== undefined) {
-                // Found a match for this task. Keep traversing down the task tree.
-                return finishTaskUsingDynamicDataPayload(taskChild, serverRouterStateChild, dynamicDataChild, dynamicHead, debugInfo);
+    const dynamicDataChildren = dynamicData !== null ? dynamicData[1] : null;
+    // Detect whether the server sends a parallel route slot that the client
+    // doesn't know about.
+    let didReceiveUnknownParallelRoute = false;
+    if (taskChildren !== null) {
+        for(const parallelRouteKey in serverChildren){
+            const serverRouterStateChild = serverChildren[parallelRouteKey];
+            const dynamicDataChild = dynamicDataChildren !== null ? dynamicDataChildren[parallelRouteKey] : null;
+            const taskChild = taskChildren.get(parallelRouteKey);
+            if (taskChild === undefined) {
+                // The server sent a child segment that the client doesn't know about.
+                //
+                // When we receive an unknown parallel route, we must consider it a
+                // mismatch. This is unlike the case where the segment itself
+                // mismatches, because multiple routes can be active simultaneously.
+                // But a given layout should never have a mismatching set of
+                // child slots.
+                //
+                // Theoretically, this should only happen in development during an HMR
+                // refresh, because the set of parallel routes for a layout does not
+                // change over the lifetime of a build/deployment. In production, we
+                // should have already mismatched on either the build id or the segment
+                // path. But as an extra precaution, we validate in prod, too.
+                didReceiveUnknownParallelRoute = true;
+            } else {
+                const taskSegment = taskChild.route[0];
+                if ((0, _matchsegments.matchSegment)(serverRouterStateChild[0], taskSegment) && dynamicDataChild !== null && dynamicDataChild !== undefined) {
+                    // Found a match for this task. Keep traversing down the task tree.
+                    const childDidReceiveUnknownParallelRoute = writeDynamicDataIntoNavigationTask(taskChild, serverRouterStateChild, dynamicDataChild, dynamicHead, debugInfo);
+                    if (childDidReceiveUnknownParallelRoute) {
+                        didReceiveUnknownParallelRoute = true;
+                    }
+                }
             }
         }
-    // We didn't find a child task that matches the server data. We won't abort
-    // the task, though, because a different FlightDataPath may be able to
-    // fulfill it (see loop in listenForDynamicRequest). We only abort tasks
-    // once we've run out of data.
-    }
-}
-function createPendingCacheNode(navigatedAt, routerState, prefetchData, prefetchHead, isPrefetchHeadPartial, segmentPath, scrollableSegmentsResult) {
-    const routerStateChildren = routerState[1];
-    const prefetchDataChildren = prefetchData !== null ? prefetchData[1] : null;
-    const parallelRoutes = new Map();
-    for(let parallelRouteKey in routerStateChildren){
-        const routerStateChild = routerStateChildren[parallelRouteKey];
-        const prefetchDataChild = prefetchDataChildren !== null ? prefetchDataChildren[parallelRouteKey] : null;
-        const segmentChild = routerStateChild[0];
-        const segmentPathChild = segmentPath.concat([
-            parallelRouteKey,
-            segmentChild
-        ]);
-        const segmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(segmentChild);
-        const newCacheNodeChild = createPendingCacheNode(navigatedAt, routerStateChild, prefetchDataChild === undefined ? null : prefetchDataChild, prefetchHead, isPrefetchHeadPartial, segmentPathChild, scrollableSegmentsResult);
-        const newSegmentMapChild = new Map();
-        newSegmentMapChild.set(segmentKeyChild, newCacheNodeChild);
-        parallelRoutes.set(parallelRouteKey, newSegmentMapChild);
-    }
-    // The head is assigned to every leaf segment delivered by the server. Based
-    // on corresponding logic in fill-lazy-items-till-leaf-with-head.ts
-    const isLeafSegment = parallelRoutes.size === 0;
-    if (isLeafSegment) {
-        // The segment path of every leaf segment (i.e. page) is collected into
-        // a result array. This is used by the LayoutRouter to scroll to ensure that
-        // new pages are visible after a navigation.
-        // TODO: We should use a string to represent the segment path instead of
-        // an array. We already use a string representation for the path when
-        // accessing the Segment Cache, so we can use the same one.
-        scrollableSegmentsResult.push(segmentPath);
     }
-    const maybePrefetchRsc = prefetchData !== null ? prefetchData[0] : null;
-    return {
-        lazyData: null,
-        parallelRoutes: parallelRoutes,
-        prefetchRsc: maybePrefetchRsc !== undefined ? maybePrefetchRsc : null,
-        prefetchHead: isLeafSegment ? prefetchHead : [
-            null,
-            null
-        ],
-        // Create a deferred promise. This will be fulfilled once the dynamic
-        // response is received from the server.
-        rsc: createDeferredRsc(),
-        head: isLeafSegment ? createDeferredRsc() : null,
-        // TODO: Technically, a loading boundary could contain dynamic data. We must
-        // have separate `loading` and `prefetchLoading` fields to handle this, like
-        // we do for the segment data and head.
-        loading: prefetchData !== null ? prefetchData[2] ?? null : // We'll fulfill it based on the dynamic response, just like `rsc` and `head`.
-        createDeferredRsc(),
-        navigatedAt
-    };
+    return didReceiveUnknownParallelRoute;
 }
-function finishPendingCacheNode(cacheNode, taskState, serverState, dynamicData, dynamicHead, debugInfo) {
+function finishPendingCacheNode(cacheNode, dynamicData, dynamicHead, debugInfo) {
     // 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
@@ -616,49 +955,16 @@ function finishPendingCacheNode(cacheNode, taskState, serverState, dynamicData,
     // 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.
-    const taskStateChildren = taskState[1];
-    const serverStateChildren = serverState[1];
-    const dataChildren = dynamicData[1];
-    // The router state that we traverse the tree with (taskState) is the same one
-    // that we used to construct the pending Cache Node tree. That way we're sure
-    // to resolve all the pending promises.
-    const parallelRoutes = cacheNode.parallelRoutes;
-    for(let parallelRouteKey in taskStateChildren){
-        const taskStateChild = taskStateChildren[parallelRouteKey];
-        const serverStateChild = serverStateChildren[parallelRouteKey];
-        const dataChild = dataChildren[parallelRouteKey];
-        const segmentMapChild = parallelRoutes.get(parallelRouteKey);
-        const taskSegmentChild = taskStateChild[0];
-        const taskSegmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(taskSegmentChild);
-        const cacheNodeChild = segmentMapChild !== undefined ? segmentMapChild.get(taskSegmentKeyChild) : undefined;
-        if (cacheNodeChild !== undefined) {
-            if (serverStateChild !== undefined && (0, _matchsegments.matchSegment)(taskSegmentChild, serverStateChild[0])) {
-                if (dataChild !== undefined && dataChild !== null) {
-                    // This is the happy path. Recursively update all the children.
-                    finishPendingCacheNode(cacheNodeChild, taskStateChild, serverStateChild, dataChild, dynamicHead, debugInfo);
-                } else {
-                    // The server never returned data for this segment. Trigger a lazy
-                    // fetch during render. This shouldn't happen because the Route Tree
-                    // and the Seed Data tree sent by the server should always be the same
-                    // shape when part of the same server response.
-                    abortPendingCacheNode(taskStateChild, cacheNodeChild, null, debugInfo);
-                }
-            } else {
-                // The server never returned data for this segment. Trigger a lazy
-                // fetch during render.
-                abortPendingCacheNode(taskStateChild, cacheNodeChild, null, debugInfo);
-            }
-        } else {
-        // The server response matches what was expected to receive, but there's
-        // no matching Cache Node in the task tree. This is a bug in the
-        // implementation because we should have created a node for every
-        // segment in the tree that's associated with this task.
-        }
-    }
     // 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`.
@@ -687,51 +993,56 @@ function finishPendingCacheNode(cacheNode, taskState, serverState, dynamicData,
         head.resolve(dynamicHead, debugInfo);
     }
 }
-function abortTask(task, error, debugInfo) {
-    const cacheNode = task.node;
-    if (cacheNode === null) {
-        // This indicates the task is already complete.
-        return;
+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.refreshUrl === 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) {
-        // Reached the leaf task node. This is the root of a pending cache
-        // node tree.
-        abortPendingCacheNode(task.route, cacheNode, error, debugInfo);
-    } else {
-        // This is an intermediate task node. Keep traversing until we reach a
-        // task node with no children. That will be the root of the cache node tree
-        // that needs to be resolved.
-        for (const taskChild of taskChildren.values()){
-            abortTask(taskChild, error, debugInfo);
+    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;
+            }
         }
     }
-    // Set this to null to indicate that this task is now complete.
-    task.dynamicRequestTree = null;
+    return exitStatus;
 }
-function abortPendingCacheNode(routerState, cacheNode, error, debugInfo) {
-    // For every pending segment in the tree, resolve its `rsc` promise to `null`
-    // to trigger a lazy fetch during render.
-    //
-    // Or, if an error object is provided, it will error instead.
-    const routerStateChildren = routerState[1];
-    const parallelRoutes = cacheNode.parallelRoutes;
-    for(let parallelRouteKey in routerStateChildren){
-        const routerStateChild = routerStateChildren[parallelRouteKey];
-        const segmentMapChild = parallelRoutes.get(parallelRouteKey);
-        if (segmentMapChild === undefined) {
-            continue;
-        }
-        const segmentChild = routerStateChild[0];
-        const segmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(segmentChild);
-        const cacheNodeChild = segmentMapChild.get(segmentKeyChild);
-        if (cacheNodeChild !== undefined) {
-            abortPendingCacheNode(routerStateChild, cacheNodeChild, error, debugInfo);
-        } else {
-        // This shouldn't happen because we're traversing the same tree that was
-        // used to construct the cache nodes in the first place.
-        }
-    }
+function abortPendingCacheNode(cacheNode, error, debugInfo) {
     const rsc = cacheNode.rsc;
     if (isDeferredRsc(rsc)) {
         if (error === null) {
@@ -755,64 +1066,7 @@ function abortPendingCacheNode(routerState, cacheNode, error, debugInfo) {
         head.resolve(null, debugInfo);
     }
 }
-function updateCacheNodeOnPopstateRestoration(oldCacheNode, routerState) {
-    // A popstate navigation reads data from the local cache. It does not issue
-    // new network requests (unless the cache entries have been evicted). So, we
-    // update the cache to drop the prefetch data for any segment whose dynamic
-    // data was already received. This prevents an unnecessary flash back to PPR
-    // state during a back/forward navigation.
-    //
-    // This function clones the entire cache node tree and sets the `prefetchRsc`
-    // field to `null` to prevent it from being rendered. We can't mutate the node
-    // in place because this is a concurrent data structure.
-    const routerStateChildren = routerState[1];
-    const oldParallelRoutes = oldCacheNode.parallelRoutes;
-    const newParallelRoutes = new Map(oldParallelRoutes);
-    for(let parallelRouteKey in routerStateChildren){
-        const routerStateChild = routerStateChildren[parallelRouteKey];
-        const segmentChild = routerStateChild[0];
-        const segmentKeyChild = (0, _createroutercachekey.createRouterCacheKey)(segmentChild);
-        const oldSegmentMapChild = oldParallelRoutes.get(parallelRouteKey);
-        if (oldSegmentMapChild !== undefined) {
-            const oldCacheNodeChild = oldSegmentMapChild.get(segmentKeyChild);
-            if (oldCacheNodeChild !== undefined) {
-                const newCacheNodeChild = updateCacheNodeOnPopstateRestoration(oldCacheNodeChild, routerStateChild);
-                const newSegmentMapChild = new Map(oldSegmentMapChild);
-                newSegmentMapChild.set(segmentKeyChild, newCacheNodeChild);
-                newParallelRoutes.set(parallelRouteKey, newSegmentMapChild);
-            }
-        }
-    }
-    // Only show prefetched data if the dynamic data is still pending.
-    //
-    // 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 rsc = oldCacheNode.rsc;
-    const shouldUsePrefetch = isDeferredRsc(rsc) && rsc.status === 'pending';
-    return {
-        lazyData: null,
-        rsc,
-        head: oldCacheNode.head,
-        prefetchHead: shouldUsePrefetch ? oldCacheNode.prefetchHead : [
-            null,
-            null
-        ],
-        prefetchRsc: shouldUsePrefetch ? oldCacheNode.prefetchRsc : null,
-        loading: oldCacheNode.loading,
-        // These are the cloned children we computed above
-        parallelRoutes: newParallelRoutes,
-        navigatedAt: oldCacheNode.navigatedAt
-    };
-}
 const DEFERRED = Symbol();
-// This type exists to distinguish a DeferredRsc from a Flight promise. It's a
-// compromise to avoid adding an extra field on every Cache Node, which would be
-// awkward because the pre-PPR parts of codebase would need to account for it,
-// too. We can remove it once type Cache Node type is more settled.
 function isDeferredRsc(value) {
     return value && typeof value === 'object' && value.tag === DEFERRED;
 }