failproofai 1.0.11-beta.1 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/client/components/segment-cache/cache.js

@@ -7,42 +7,44 @@ Object.defineProperty(exports, "__esModule", {
     MetadataOnlyRequestTree: null,
     attemptToFulfillDynamicSegmentFromBFCache: null,
     attemptToUpgradeSegmentFromBFCache: null,
+    bufferPrefetchResponseBody: null,
     canNewFetchStrategyProvideMoreContent: null,
-    convertReusedFlightRouterStateToRouteTree: null,
+    convertFlightRouterStateToRouteTree: null,
     convertRootFlightRouterStateToRouteTree: null,
     convertRouteTreeToFlightRouterState: null,
     createDetachedSegmentCacheEntry: null,
     createMetadataRouteTree: null,
-    createNonTaskyPrefetchResponseStream: null,
+    createRootRouteTree: null,
     deprecated_requestOptimisticRouteCacheEntry: null,
+    doesRouteStructureMatch: null,
     fetchRouteOnCacheMiss: null,
-    fetchSegmentPrefetchesUsingDynamicRequest: null,
-    fetchSegmentsOnCacheMiss: null,
+    fetchSegmentPrefetchesUsingRuntimeRequest: null,
+    fetchSegmentPrefetchesUsingStaticRequest: null,
     fulfillRouteCacheEntry: null,
     getCurrentRouteCacheVersion: null,
     getCurrentSegmentCacheVersion: null,
+    getHeadRequestKey: null,
     getStaleTimeMs: null,
     invalidateEntirePrefetchCache: null,
     invalidateRouteCacheEntries: null,
     invalidateSegmentCacheEntries: null,
-    markRouteEntryAsDynamicRewrite: null,
     overwriteRevalidatingSegmentCacheEntry: null,
     pingInvalidationListeners: null,
-    processRuntimePrefetchStream: null,
     readOrCreateRevalidatingSegmentEntry: null,
     readOrCreateRouteCacheEntry: null,
     readOrCreateSegmentCacheEntry: null,
     readRouteCacheEntry: null,
     readSegmentCacheEntryForNavigation: null,
+    rebaseInactiveRouteTree: null,
     resolveStaleAt: null,
     segmentCacheMap: null,
+    spawnStaticStageCacheWrite: null,
     stripIsPartialByte: null,
     upgradeToPendingSegment: null,
     upsertSegmentEntry: null,
     waitForSegmentCacheEntry: null,
-    writeDynamicRenderResponseIntoCache: null,
-    writePrerenderResponseIntoCache: null,
-    writeRouteIntoCache: null
+    writeRouteIntoCache: null,
+    writeRuntimePrefetchStreamIntoCache: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -63,11 +65,14 @@ _export(exports, {
     attemptToUpgradeSegmentFromBFCache: function() {
         return attemptToUpgradeSegmentFromBFCache;
     },
+    bufferPrefetchResponseBody: function() {
+        return bufferPrefetchResponseBody;
+    },
     canNewFetchStrategyProvideMoreContent: function() {
         return canNewFetchStrategyProvideMoreContent;
     },
-    convertReusedFlightRouterStateToRouteTree: function() {
-        return convertReusedFlightRouterStateToRouteTree;
+    convertFlightRouterStateToRouteTree: function() {
+        return convertFlightRouterStateToRouteTree;
     },
     convertRootFlightRouterStateToRouteTree: function() {
         return convertRootFlightRouterStateToRouteTree;
@@ -81,20 +86,23 @@ _export(exports, {
     createMetadataRouteTree: function() {
         return createMetadataRouteTree;
     },
-    createNonTaskyPrefetchResponseStream: function() {
-        return createNonTaskyPrefetchResponseStream;
+    createRootRouteTree: function() {
+        return createRootRouteTree;
     },
     deprecated_requestOptimisticRouteCacheEntry: function() {
         return deprecated_requestOptimisticRouteCacheEntry;
     },
+    doesRouteStructureMatch: function() {
+        return doesRouteStructureMatch;
+    },
     fetchRouteOnCacheMiss: function() {
         return fetchRouteOnCacheMiss;
     },
-    fetchSegmentPrefetchesUsingDynamicRequest: function() {
-        return fetchSegmentPrefetchesUsingDynamicRequest;
+    fetchSegmentPrefetchesUsingRuntimeRequest: function() {
+        return fetchSegmentPrefetchesUsingRuntimeRequest;
     },
-    fetchSegmentsOnCacheMiss: function() {
-        return fetchSegmentsOnCacheMiss;
+    fetchSegmentPrefetchesUsingStaticRequest: function() {
+        return fetchSegmentPrefetchesUsingStaticRequest;
     },
     fulfillRouteCacheEntry: function() {
         return fulfillRouteCacheEntry;
@@ -105,6 +113,9 @@ _export(exports, {
     getCurrentSegmentCacheVersion: function() {
         return getCurrentSegmentCacheVersion;
     },
+    getHeadRequestKey: function() {
+        return getHeadRequestKey;
+    },
     getStaleTimeMs: function() {
         return getStaleTimeMs;
     },
@@ -117,18 +128,12 @@ _export(exports, {
     invalidateSegmentCacheEntries: function() {
         return invalidateSegmentCacheEntries;
     },
-    markRouteEntryAsDynamicRewrite: function() {
-        return markRouteEntryAsDynamicRewrite;
-    },
     overwriteRevalidatingSegmentCacheEntry: function() {
         return overwriteRevalidatingSegmentCacheEntry;
     },
     pingInvalidationListeners: function() {
         return pingInvalidationListeners;
     },
-    processRuntimePrefetchStream: function() {
-        return processRuntimePrefetchStream;
-    },
     readOrCreateRevalidatingSegmentEntry: function() {
         return readOrCreateRevalidatingSegmentEntry;
     },
@@ -144,12 +149,18 @@ _export(exports, {
     readSegmentCacheEntryForNavigation: function() {
         return readSegmentCacheEntryForNavigation;
     },
+    rebaseInactiveRouteTree: function() {
+        return rebaseInactiveRouteTree;
+    },
     resolveStaleAt: function() {
         return resolveStaleAt;
     },
     segmentCacheMap: function() {
         return segmentCacheMap;
     },
+    spawnStaticStageCacheWrite: function() {
+        return spawnStaticStageCacheWrite;
+    },
     stripIsPartialByte: function() {
         return stripIsPartialByte;
     },
@@ -162,18 +173,16 @@ _export(exports, {
     waitForSegmentCacheEntry: function() {
         return waitForSegmentCacheEntry;
     },
-    writeDynamicRenderResponseIntoCache: function() {
-        return writeDynamicRenderResponseIntoCache;
-    },
-    writePrerenderResponseIntoCache: function() {
-        return writePrerenderResponseIntoCache;
-    },
     writeRouteIntoCache: function() {
         return writeRouteIntoCache;
+    },
+    writeRuntimePrefetchStreamIntoCache: function() {
+        return writeRuntimePrefetchStreamIntoCache;
     }
 });
 const _approutertypes = require("../../../shared/lib/app-router-types");
 const _varyparamsdecoding = require("../../../shared/lib/segment-cache/vary-params-decoding");
+const _rsctransport = require("../../../shared/lib/rsc-transport");
 const _approuterheaders = require("../app-router-headers");
 const _fetchserverresponse = require("../router-reducer/fetch-server-response");
 const _fetch = require("./fetch");
@@ -187,17 +196,49 @@ const _segmentvalueencoding = require("../../../shared/lib/segment-cache/segment
 const _flightdatahelpers = require("../../flight-data-helpers");
 const _navigatereducer = require("../router-reducer/reducers/navigate-reducer");
 const _links = require("../links");
-const _segment = require("../../../shared/lib/segment");
 const _types = require("./types");
 const _promisewithresolvers = require("../../../shared/lib/promise-with-resolvers");
 const _bfcache = require("./bfcache");
 const _optimisticroutes = require("./optimistic-routes");
-const _navigation = require("./navigation");
+const _decodeserverresponse = require("./decode-server-response");
 const _navigationbuildid = require("../../navigation-build-id");
 const _constants = require("../../../lib/constants");
 function getStaleTimeMs(staleTimeSeconds) {
     return Math.max(staleTimeSeconds, 30) * 1000;
 }
+// How long a rejected cache entry blocks re-fetching before it may be
+// retried (its staleAt is set this far in the future).
+const REJECTION_BACKOFF_MS = 10 * 1000;
+/**
+ * The staleAt to reject entries with when a prefetch fails: if we're
+ * offline, expire immediately (-1) so the entry is re-fetched once the
+ * scheduler is re-pinged after connectivity is restored; otherwise apply a
+ * short backoff. (Unlike navigations and server actions, prefetches don't
+ * await `waitForConnection`.)
+ */ function getPrefetchErrorStaleAt(error) {
+    if (process.env.__NEXT_USE_OFFLINE) {
+        const { checkOfflineError } = require('../offline');
+        if (checkOfflineError(error)) {
+            return -1;
+        }
+    }
+    return Date.now() + REJECTION_BACKOFF_MS;
+}
+function createRootRouteTree(tree, head) {
+    return {
+        tree,
+        head
+    };
+}
+function doesRouteStructureMatch(currentTree, nextTree) {
+    // The request key includes the param names and types, but not the values.
+    if (currentTree.requestKey !== nextTree.requestKey) {
+        return false;
+    }
+    // The root request key is always empty (even for global Not Found), so we
+    // have to compare the root segment directly.
+    return nextTree.requestKey !== _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY || currentTree.segment === nextTree.segment;
+}
 const isOutputExportMode = process.env.NODE_ENV === 'production' && process.env.__NEXT_CONFIG_OUTPUT === 'export';
 const MetadataOnlyRequestTree = [
     '',
@@ -226,21 +267,21 @@ function getCurrentRouteCacheVersion() {
 function getCurrentSegmentCacheVersion() {
     return currentSegmentCacheVersion;
 }
-function invalidateEntirePrefetchCache(nextUrl, tree) {
+function invalidateEntirePrefetchCache(nextUrl, root) {
     currentRouteCacheVersion++;
     currentSegmentCacheVersion++;
-    (0, _links.pingVisibleLinks)(nextUrl, tree);
-    pingInvalidationListeners(nextUrl, tree);
+    (0, _links.pingVisibleLinks)(nextUrl, root);
+    pingInvalidationListeners(nextUrl, root);
 }
-function invalidateRouteCacheEntries(nextUrl, tree) {
+function invalidateRouteCacheEntries(nextUrl, root) {
     currentRouteCacheVersion++;
-    (0, _links.pingVisibleLinks)(nextUrl, tree);
-    pingInvalidationListeners(nextUrl, tree);
+    (0, _links.pingVisibleLinks)(nextUrl, root);
+    pingInvalidationListeners(nextUrl, root);
 }
-function invalidateSegmentCacheEntries(nextUrl, tree) {
+function invalidateSegmentCacheEntries(nextUrl, root) {
     currentSegmentCacheVersion++;
-    (0, _links.pingVisibleLinks)(nextUrl, tree);
-    pingInvalidationListeners(nextUrl, tree);
+    (0, _links.pingVisibleLinks)(nextUrl, root);
+    pingInvalidationListeners(nextUrl, root);
 }
 function attachInvalidationListener(task) {
     // This function is called whenever a prefetch task reads a cache entry. If
@@ -276,7 +317,7 @@ function notifyInvalidationListener(task) {
         }
     }
 }
-function pingInvalidationListeners(nextUrl, tree) {
+function pingInvalidationListeners(nextUrl, root) {
     // The rough equivalent of pingVisibleLinks, but for onInvalidate callbacks.
     // This is called when the Next-Url or the base tree changes, since those
     // may affect the result of a prefetch task. It's also called after a
@@ -285,7 +326,7 @@ function pingInvalidationListeners(nextUrl, tree) {
         const tasks = invalidationListeners;
         invalidationListeners = null;
         for (const task of tasks){
-            if ((0, _scheduler.isPrefetchTaskDirty)(task, nextUrl, tree)) {
+            if ((0, _scheduler.isPrefetchTaskDirty)(task, nextUrl, root)) {
                 notifyInvalidationListener(task);
             }
         }
@@ -346,15 +387,14 @@ function createDetachedRouteCacheEntry() {
         canonicalUrl: null,
         status: _cachemap.EntryStatus.Empty,
         blockedTasks: null,
-        tree: null,
-        metadata: null,
+        root: null,
         // This is initialized to true because we don't know yet whether the route
         // could be intercepted. It's only set to false once we receive a response
         // from the server.
         couldBeIntercepted: true,
         // Similarly, we don't yet know if the route supports PPR.
         supportsPerSegmentPrefetching: false,
-        hasDynamicRewrite: false,
+        predictedFrom: null,
         renderedSearch: null,
         // Map-related fields
         ref: null,
@@ -428,12 +468,13 @@ function deprecated_requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl)
     // route was rewritten to a different search string, then the optimistic
     // route should be rewritten to the same search string. Otherwise, we use
     // the requested search string.
-    const optimisticRenderedSearch = routeWithNoSearchParams.renderedSearch !== '' ? routeWithNoSearchParams.renderedSearch : requestedSearch;
+    const optimisticRenderedSearch = routeWithNoSearchParams.renderedSearch !== '' ? routeWithNoSearchParams.renderedSearch : (0, _routeparams.normalizeRenderedSearch)(requestedSearch);
     const optimisticUrl = new URL(routeWithNoSearchParams.canonicalUrl, location.origin);
     optimisticUrl.search = optimisticCanonicalSearch;
     const optimisticCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(optimisticUrl);
-    const optimisticRouteTree = deprecated_createOptimisticRouteTree(routeWithNoSearchParams.tree, optimisticRenderedSearch);
-    const optimisticMetadataTree = deprecated_createOptimisticRouteTree(routeWithNoSearchParams.metadata, optimisticRenderedSearch);
+    const optimisticRouteTree = deprecated_createOptimisticRouteTree(routeWithNoSearchParams.root.tree, optimisticRenderedSearch);
+    const baseMetadataTree = routeWithNoSearchParams.root.head;
+    const optimisticMetadataTree = createMetadataRouteTree((0, _varypath.cloneVaryPathWithNewSearchParams)(baseMetadataTree.varyPath, optimisticRenderedSearch), baseMetadataTree.prefetchHints, null);
     // Clone the base route tree, and override the relevant fields with our
     // optimistic values.
     const optimisticEntry = {
@@ -441,11 +482,10 @@ function deprecated_requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl)
         status: _cachemap.EntryStatus.Fulfilled,
         // This isn't cloned because it's instance-specific
         blockedTasks: null,
-        tree: optimisticRouteTree,
-        metadata: optimisticMetadataTree,
+        root: createRootRouteTree(optimisticRouteTree, optimisticMetadataTree),
         couldBeIntercepted: routeWithNoSearchParams.couldBeIntercepted,
         supportsPerSegmentPrefetching: routeWithNoSearchParams.supportsPerSegmentPrefetching,
-        hasDynamicRewrite: routeWithNoSearchParams.hasDynamicRewrite,
+        predictedFrom: null,
         // Override the rendered search with the optimistic value.
         renderedSearch: optimisticRenderedSearch,
         // Map-related fields
@@ -469,28 +509,17 @@ function deprecated_createOptimisticRouteTree(tree, newRenderedSearch) {
             clonedSlots.set(parallelRouteKey, deprecated_createOptimisticRouteTree(childTree, newRenderedSearch));
         }
     }
-    // We only need to clone the vary path if the route is a page.
-    if (tree.isPage) {
-        // The shell vary path Fallbacks search params, so it's unaffected by the
-        // new rendered search and can be reused as-is.
-        return {
-            requestKey: tree.requestKey,
-            segment: tree.segment,
-            shellVaryPath: tree.shellVaryPath,
-            refreshState: tree.refreshState,
-            varyPath: (0, _varypath.clonePageVaryPathWithNewSearchParams)(tree.varyPath, newRenderedSearch),
-            isPage: true,
-            slots: clonedSlots,
-            prefetchHints: tree.prefetchHints
-        };
-    }
+    // The shell vary path Fallbacks search params, so it's unaffected by the
+    // new rendered search and can be reused as-is.
     return {
         requestKey: tree.requestKey,
         segment: tree.segment,
         shellVaryPath: tree.shellVaryPath,
         refreshState: tree.refreshState,
-        varyPath: tree.varyPath,
-        isPage: false,
+        // Optimistic trees are structure-only. (The input tree comes from the
+        // route cache, which never carries render output.)
+        data: null,
+        varyPath: (0, _varypath.cloneVaryPathWithNewSearchParams)(tree.varyPath, newRenderedSearch),
         slots: clonedSlots,
         prefetchHints: tree.prefetchHints
     };
@@ -583,6 +612,14 @@ map, fetchStrategy, tree) {
  * strategy content tiers (how much content a strategy can produce), not the
  * vary-path specificity the eviction docs are concerned with.
  */ function isExistingSegmentEntryPreferred(existingEntry, candidateEntry) {
+    if (existingEntry.status === _cachemap.EntryStatus.Empty) {
+        // An Empty entry is a placeholder that carries no data, and its
+        // fetchStrategy is a spawn-time default, not a fact about any content —
+        // it must never win a precedence comparison. (Without this, a candidate
+        // fetched at a tier below the placeholder's default would be discarded
+        // in favor of an entry with nothing in it.)
+        return false;
+    }
     return(// We fetched the new segment using a different, less specific fetch
     // strategy than the segment we already have in the cache, so it can't
     // have more content.
@@ -692,9 +729,10 @@ lookupVaryPath) {
  * upsert applies at its own keypath — we know we never want to match against
  * it again, so delete it, making the candidate reachable.
  *
- * Non-settled entries are never evicted here: a Pending entry is owned by an
- * in-flight request that will settle it, and an Empty entry is a placeholder
- * that a scheduler pass may still claim and upgrade.
+ * Pending entries are never evicted here: they're owned by an in-flight
+ * request that will settle them. Empty entries ARE evictable — they're
+ * unclaimed placeholders with nothing in them, so they must not shadow real
+ * data; their blocked tasks are pinged so they re-run against the candidate.
  */ function evictShadowingSegmentEntries(now, map, lookupVaryPath, candidateEntry) {
     // There can in principle be multiple shadowing entries at successively less
     // specific keypaths, so loop until the read returns the candidate (or an
@@ -712,9 +750,13 @@ lookupVaryPath) {
             // entirely, e.g. because the candidate expired). Done.
             return;
         }
-        if (shadowEntry.status !== _cachemap.EntryStatus.Fulfilled && shadowEntry.status !== _cachemap.EntryStatus.Rejected) {
-            // Only settled entries may be evicted. A Pending entry is held by an
-            // in-flight request and will settle on its own.
+        if (shadowEntry.status === _cachemap.EntryStatus.Pending) {
+            // A Pending entry may not be evicted: it's held by an in-flight
+            // request and will settle on its own. (An Empty shadow entry, by
+            // contrast, is an unclaimed placeholder with nothing in it — never
+            // preferred over the candidate, per isExistingSegmentEntryPreferred —
+            // so it falls through to the eviction below, waking any tasks blocked
+            // on it so they re-run and find the candidate.)
             return;
         }
         if (isExistingSegmentEntryPreferred(shadowEntry, candidateEntry)) {
@@ -725,8 +767,9 @@ lookupVaryPath) {
         }
         // The candidate supersedes the shadowing entry. Evict it. Settled entries
         // shouldn't have blocked tasks (Fulfilled always has `blockedTasks:
-        // null`, and Rejected entries were pinged at rejection), but ping
-        // defensively before deleting, matching the upsert-evict pattern above.
+        // null`, and Rejected entries were pinged at rejection), but an Empty
+        // entry may have them — ping before deleting, matching the upsert-evict
+        // pattern above.
         pingBlockedTasks(shadowEntry);
         (0, _cachemap.deleteFromCacheMap)(shadowEntry);
     }
@@ -758,9 +801,14 @@ function upgradeToPendingSegment(emptyEntry, fetchStrategy) {
     pendingEntry.status = _cachemap.EntryStatus.Pending;
     pendingEntry.fetchStrategy = fetchStrategy;
     if (fetchStrategy === _types.FetchStrategy.Full) {
-        // We can assume the response will contain the full segment data. Set this
-        // to false so we know it's OK to omit this segment from any navigation
-        // requests that may happen while the data is still pending.
+        // The Pending-Full convention: pre-set isPartial to false before any
+        // data exists. Normally partiality is absolute — anything unresolved in
+        // the entry's output makes it true, and a pending entry has no output at
+        // all — but a Full response is a complete navigation payload, so this
+        // segment may already be omitted from navigation requests that happen
+        // while the data is still in flight. That "may be omitted" signal is
+        // exactly what isPartial: false means to a navigation, so this
+        // deliberately breaks the absolute definition for the pending window.
         pendingEntry.isPartial = false;
     }
     // Set the version here, since this is right before the request is initiated.
@@ -795,7 +843,7 @@ function attemptToFulfillDynamicSegmentFromBFCache(now, segment, tree) {
         }
         const pendingSegment = upgradeToPendingSegment(segment, _types.FetchStrategy.Full);
         const isPartial = false;
-        return fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial, // bfcache data is concrete, never an ISR fallback.
+        return fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial, bfcacheEntry.varyParams, // bfcache data is concrete, never an ISR fallback.
         false, _types.FetchStrategy.Full);
     }
     return null;
@@ -811,7 +859,7 @@ map, tree) {
         }
         const pendingSegment = upgradeToPendingSegment(createDetachedSegmentCacheEntry(now), _types.FetchStrategy.Full);
         const isPartial = false;
-        const newEntry = fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial, // bfcache data is concrete, never an ISR fallback.
+        const newEntry = fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial, bfcacheEntry.varyParams, // bfcache data is concrete, never an ISR fallback.
         false, _types.FetchStrategy.Full);
         const segmentVaryPath = (0, _varypath.getSegmentVaryPathForRequest)(_types.FetchStrategy.Full, tree);
         const upserted = upsertSegmentEntry(now, map, segmentVaryPath, newEntry, // The concrete lookup path this BFCache upgrade applies to. (In
@@ -833,33 +881,87 @@ function pingBlockedTasks(entry) {
         entry.blockedTasks = null;
     }
 }
-function createMetadataRouteTree(metadataVaryPath) {
-    // The Head is not actually part of the route tree, but other than that, it's
-    // fetched and cached like a segment. Some functions expect a RouteTree
-    // object, so rather than fork the logic in all those places, we use this
-    // "fake" one.
+function getHeadRequestKey(pageRequestKey) {
+    return pageRequestKey + _segmentvalueencoding.HEAD_REQUEST_KEY;
+}
+function createMetadataRouteTree(metadataVaryPath, // The route root's prefetch hints. The head has no node of its own on the
+// wire, so the route-level hint that applies to it is copied from the root.
+rootPrefetchHints, // The head's payload, with the same lifetimes as a segment node's `data`
+// (see RouteTree): null in the route cache, the response's decoded
+// head on a navigation seed, a CacheNode on the router state.
+data) {
+    // The head is a one-node tree beside the route tree (see RootRouteTree). It
+    // has no position in the route tree, but it's fetched, cached, compared, and
+    // rendered like a segment, so it is a RouteTree node like any other.
     const metadata = {
-        requestKey: _segmentvalueencoding.HEAD_REQUEST_KEY,
+        // The first entry of the head's vary path (see getHeadRequestKey). The
+        // server knows nothing of this key; it is always asked for
+        // HEAD_REQUEST_KEY, which is why the segment stays the bare marker.
+        requestKey: metadataVaryPath.value,
         segment: _segmentvalueencoding.HEAD_REQUEST_KEY,
         shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(metadataVaryPath),
         refreshState: null,
+        data,
         varyPath: metadataVaryPath,
-        // The metadata isn't really a "page" (though it isn't really a "segment"
-        // either) but for the purposes of how this field is used, it behaves like
-        // one. If this logic ever gets more complex we can change this to an enum.
-        isPage: true,
         slots: null,
-        prefetchHints: 0
+        // Only the static-attempt bits apply to the head: it's a route-level
+        // fact ("static per-segment responses may exist for this route"), and
+        // it's what lets a shell-tier cached head attempt a static head fetch
+        // before deopting to a runtime request (see the shell-tier eligibility
+        // check in pingSegmentBundle). The other bits describe tree structure
+        // the head doesn't participate in.
+        prefetchHints: rootPrefetchHints & _approutertypes.StaticAttemptHints
     };
     return metadata;
 }
-function fulfillRouteCacheEntry(now, entry, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching) {
-    // Get the rendered search from the vary path
-    const renderedSearch = (0, _varypath.getRenderedSearchFromVaryPath)(metadataVaryPath) ?? '';
+/**
+ * Returns an equivalent tree with `data: null` at every node, cloning only
+ * the subtrees that carry data. Called when a tree is stored in the route
+ * cache: route cache entries live indefinitely, so retaining render output
+ * there would pin RSC payloads in memory outside the segment cache's eviction
+ * control. See the lifecycle note on RouteTree.
+ */ function stripDataFromRouteTree(tree) {
+    let clonedSlots = null;
+    const slots = tree.slots;
+    if (slots !== null) {
+        for (const [parallelRouteKey, childTree] of slots){
+            const strippedChild = stripDataFromRouteTree(childTree);
+            if (strippedChild !== childTree && clonedSlots === null) {
+                // Sound cast: any copied value that isn't overwritten below is one
+                // where stripDataFromRouteTree returned the child unchanged, which
+                // means that subtree carries no data.
+                clonedSlots = new Map(slots);
+            }
+            if (clonedSlots !== null) {
+                clonedSlots.set(parallelRouteKey, strippedChild);
+            }
+        }
+    }
+    if (tree.data === null && clonedSlots === null) {
+        // Neither this node nor any descendant carries data. Reuse it as-is.
+        // This is the common case for trees that never carried render output
+        // (e.g. route tree prefetch responses). Sound cast for the same reason.
+        return tree;
+    }
+    // Sound cast: clonedSlots is null here only if every child subtree was
+    // verified data-free by the loop above.
+    const strippedSlots = clonedSlots ?? slots;
+    return {
+        requestKey: tree.requestKey,
+        segment: tree.segment,
+        shellVaryPath: tree.shellVaryPath,
+        refreshState: tree.refreshState,
+        data: null,
+        varyPath: tree.varyPath,
+        slots: strippedSlots,
+        prefetchHints: tree.prefetchHints
+    };
+}
+function fulfillRouteCacheEntry(now, entry, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching) {
+    const tree = root.tree;
     const fulfilledEntry = entry;
     fulfilledEntry.status = _cachemap.EntryStatus.Fulfilled;
-    fulfilledEntry.tree = tree;
-    fulfilledEntry.metadata = createMetadataRouteTree(metadataVaryPath);
+    fulfilledEntry.root = createRootRouteTree(stripDataFromRouteTree(tree), stripDataFromRouteTree(root.head));
     // Route structure is essentially static — it only changes on deploy.
     // Always use the static stale time.
     // NOTE: An exception is rewrites/redirects in middleware or proxy, which can
@@ -879,25 +981,18 @@ function fulfillRouteCacheEntry(now, entry, tree, metadataVaryPath, couldBeInter
     fulfilledEntry.canonicalUrl = canonicalUrl;
     fulfilledEntry.renderedSearch = renderedSearch;
     fulfilledEntry.supportsPerSegmentPrefetching = supportsPerSegmentPrefetching;
-    fulfilledEntry.hasDynamicRewrite = false;
     pingBlockedTasks(entry);
     return fulfilledEntry;
 }
-function writeRouteIntoCache(now, pathname, search, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching) {
+function writeRouteIntoCache(now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching) {
     const pendingEntry = createDetachedRouteCacheEntry();
-    const fulfilledEntry = fulfillRouteCacheEntry(now, pendingEntry, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+    const fulfilledEntry = fulfillRouteCacheEntry(now, pendingEntry, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
     const varyPath = (0, _varypath.getFulfilledRouteVaryPath)(pathname, search, nextUrl, couldBeIntercepted);
     const isRevalidation = false;
     (0, _cachemap.setInCacheMap)(routeCacheMap, varyPath, fulfilledEntry, isRevalidation);
     return fulfilledEntry;
 }
-function markRouteEntryAsDynamicRewrite(entry) {
-    entry.hasDynamicRewrite = true;
-// Note: The caller is responsible for also calling invalidateRouteCacheEntries
-// to invalidate other entries that may have been derived from this template
-// before we knew it had a dynamic rewrite.
-}
-function fulfillSegmentCacheEntry(segmentCacheEntry, rsc, staleAt, isPartial, // Only static (per-segment PPR) responses can be ISR fallbacks; all other
+function fulfillSegmentCacheEntry(segmentCacheEntry, rsc, staleAt, isPartial, varyParams, // Only static (per-segment PPR) responses can be ISR fallbacks; all other
 // callers pass false. Always assigned (even when false) so that re-fulfilling
 // a previously-fallback entry with a concrete response clears the flag and
 // ends the retry loop.
@@ -906,7 +1001,7 @@ isUpgradeableISRFallback, // The strategy tier describing the CONTENT this entry
 // Usually the two agree, but when a response's shell payload IS the full
 // response (no shell/full split), shell-spawned entries are fulfilled with
 // full-tier content and recorded as such (see the promotion in
-// writeSegmentBundleResponse). Always assigned, replacing
+// writeSegmentDataIntoCache). Always assigned, replacing
 // the spawn-time strategy set by upgradeToPendingSegment; the write walks'
 // matching and keying decisions all happen against the spawn-time
 // strategy, before fulfillment, so they are unaffected. See
@@ -917,6 +1012,7 @@ fetchStrategy) {
     fulfilledEntry.rsc = rsc;
     fulfilledEntry.staleAt = staleAt;
     fulfilledEntry.isPartial = isPartial;
+    fulfilledEntry.varyParams = varyParams;
     fulfilledEntry.isUpgradeableISRFallback = isUpgradeableISRFallback;
     fulfilledEntry.fetchStrategy = fetchStrategy;
     // Resolve any listeners that were waiting for this data.
@@ -946,127 +1042,33 @@ function rejectSegmentCacheEntry(entry, staleAt) {
     }
     pingBlockedTasks(entry);
 }
-function convertRootTreePrefetchToRouteTree(rootTree, renderedPathname, renderedSearch, acc) {
-    // Remove trailing and leading slashes
-    const pathnameParts = (0, _cachekey.splitPathnameIntoParts)(renderedPathname);
-    const index = 0;
-    const rootSegment = _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY;
-    return convertTreePrefetchToRouteTree(rootTree.tree, rootSegment, null, _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY, pathnameParts, index, renderedSearch, acc);
-}
-function convertTreePrefetchToRouteTree(prefetch, segment, partialVaryPath, requestKey, pathnameParts, pathnamePartsIndex, renderedSearch, acc) {
-    // Converts the route tree sent by the server into the format used by the
-    // cache. The cached version of the tree includes additional fields, such as a
-    // cache key for each segment. Since this is frequently accessed, we compute
-    // it once instead of on every access. This same cache key is also used to
-    // request the segment from the server.
+function convertRootFlightRouterStateToRouteTree(flightRouterState, renderedSearch, acc) {
+    return convertFlightRouterStateToRouteTree(flightRouterState, _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY, null, renderedSearch, acc);
+}
+function rebaseInactiveRouteTree(treeToRebase) {
+    // A parallel route slot that the target route doesn't provide keeps the
+    // slot already active on the current route, under the new parent. The slot
+    // sits at the same route position, so its request keys and vary paths are
+    // unchanged: copy the structure and drop the payloads, which belong to the
+    // previous render and are reused separately by render-tree.
     let slots = null;
-    let isPage;
-    let varyPath;
-    const prefetchSlots = prefetch.slots;
-    if (prefetchSlots !== null) {
-        isPage = false;
-        varyPath = (0, _varypath.finalizeLayoutVaryPath)(requestKey, partialVaryPath);
+    if (treeToRebase.slots !== null) {
         slots = new Map();
-        for(let parallelRouteKey in prefetchSlots){
-            const childPrefetch = prefetchSlots[parallelRouteKey];
-            const childSegmentName = childPrefetch.name;
-            const childParam = childPrefetch.param;
-            let childDoesAppearInURL;
-            let childSegment;
-            let childPartialVaryPath;
-            if (childParam !== null) {
-                // This segment is parameterized. Get the param from the pathname.
-                const childParamValue = (0, _routeparams.parseDynamicParamFromURLPart)(childParam.type, pathnameParts, pathnamePartsIndex);
-                // Assign a cache key to the segment, based on the param value. In the
-                // pre-Segment Cache implementation, the server computes this and sends
-                // it in the body of the response. In the Segment Cache implementation,
-                // the server sends an empty string and we fill it in here.
-                // TODO: We're intentionally not adding the search param to page
-                // segments here; it's tracked separately and added back during a read.
-                // This would clearer if we waited to construct the segment until it's
-                // read from the cache, since that's effectively what we're
-                // doing anyway.
-                const childParamKey = // The server omits this field from the prefetch response when
-                // cacheComponents is enabled.
-                childParam.key !== null ? childParam.key : (0, _routeparams.getCacheKeyForDynamicParam)(childParamValue, '');
-                childPartialVaryPath = (0, _varypath.appendLayoutVaryPath)(partialVaryPath, childParamKey, childSegmentName, // The child's param is a root param iff the child segment is at or
-                // above the root layout, which the server marks directly.
-                (childPrefetch.prefetchHints & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0);
-                childSegment = [
-                    childSegmentName,
-                    childParamKey,
-                    childParam.type,
-                    childParam.siblings
-                ];
-                childDoesAppearInURL = true;
-            } else {
-                // This segment does not have a param. Inherit the partial vary path of
-                // the parent.
-                childPartialVaryPath = partialVaryPath;
-                childSegment = childSegmentName;
-                childDoesAppearInURL = (0, _routeparams.doesStaticSegmentAppearInURL)(childSegmentName);
-            }
-            // Only increment the index if the segment appears in the URL. If it's a
-            // "virtual" segment, like a route group, it remains the same.
-            const childPathnamePartsIndex = childDoesAppearInURL ? pathnamePartsIndex + 1 : pathnamePartsIndex;
-            const childRequestKeyPart = (0, _segmentvalueencoding.createSegmentRequestKeyPart)(childSegment);
-            const childRequestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(requestKey, parallelRouteKey, childRequestKeyPart);
-            slots.set(parallelRouteKey, convertTreePrefetchToRouteTree(childPrefetch, childSegment, childPartialVaryPath, childRequestKey, pathnameParts, childPathnamePartsIndex, renderedSearch, acc));
-        }
-    } else {
-        if (requestKey.endsWith(_segment.PAGE_SEGMENT_KEY)) {
-            // This is a page segment.
-            isPage = true;
-            varyPath = (0, _varypath.finalizePageVaryPath)(requestKey, renderedSearch, partialVaryPath);
-            // The metadata "segment" is not part the route tree, but it has the same
-            // conceptual params as a page segment. Write the vary path into the
-            // accumulator object. If there are multiple parallel pages, we use the
-            // first one. Which page we choose is arbitrary as long as it's
-            // consistently the same one every time every time. See
-            // finalizeMetadataVaryPath for more details.
-            if (acc.metadataVaryPath === null) {
-                acc.metadataVaryPath = (0, _varypath.finalizeMetadataVaryPath)(requestKey, renderedSearch, partialVaryPath);
-            }
-        } else {
-            // This is a layout segment.
-            isPage = false;
-            varyPath = (0, _varypath.finalizeLayoutVaryPath)(requestKey, partialVaryPath);
+        for (const [parallelRouteKey, child] of treeToRebase.slots){
+            slots.set(parallelRouteKey, rebaseInactiveRouteTree(child));
         }
     }
     return {
-        requestKey,
-        segment,
-        shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(varyPath),
-        refreshState: null,
-        // TODO: Cheating the type system here a bit because TypeScript can't tell
-        // that the type of isPage and varyPath are consistent. The fix would be to
-        // create separate constructors and call the appropriate one from each of
-        // the branches above. Just seems a bit overkill only for one field so I'll
-        // leave it as-is for now. If isPage were wrong it would break the behavior
-        // and we'd catch it quickly, anyway.
-        varyPath: varyPath,
-        isPage: isPage,
+        requestKey: treeToRebase.requestKey,
+        segment: treeToRebase.segment,
+        varyPath: treeToRebase.varyPath,
+        shellVaryPath: treeToRebase.shellVaryPath,
+        refreshState: treeToRebase.refreshState,
+        data: null,
         slots,
-        prefetchHints: prefetch.prefetchHints
+        prefetchHints: treeToRebase.prefetchHints
     };
 }
-function convertRootFlightRouterStateToRouteTree(flightRouterState, renderedSearch, acc) {
-    return convertFlightRouterStateToRouteTree(flightRouterState, _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY, null, renderedSearch, acc);
-}
-function convertReusedFlightRouterStateToRouteTree(parentRouteTree, parallelRouteKey, flightRouterState, renderedSearch, acc) {
-    // Create a RouteTree for a FlightRouterState that was reused from an older
-    // route. This happens during a navigation when a parallel route slot does not
-    // match the target route; we reuse whatever slot was already active.
-    // Unlike a FlightRouterState, the RouteTree type contains backreferences to
-    // the parent segments. Append the vary path to the parent's vary path.
-    const parentPartialVaryPath = parentRouteTree.isPage ? (0, _varypath.getPartialPageVaryPath)(parentRouteTree.varyPath) : (0, _varypath.getPartialLayoutVaryPath)(parentRouteTree.varyPath);
-    const segment = flightRouterState[0];
-    // And the request key.
-    const parentRequestKey = parentRouteTree.requestKey;
-    const requestKeyPart = (0, _segmentvalueencoding.createSegmentRequestKeyPart)(segment);
-    const requestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(parentRequestKey, parallelRouteKey, requestKeyPart);
-    return convertFlightRouterStateToRouteTree(flightRouterState, requestKey, parentPartialVaryPath, renderedSearch, acc);
-}
 function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, parentPartialVaryPath, parentRenderedSearch, acc) {
     const originalSegment = flightRouterState[0];
     // This segment's param (if any) is a root param iff the segment is at or
@@ -1081,52 +1083,12 @@ function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, pare
         canonicalUrl: compressedRefreshState[0],
         renderedSearch: compressedRefreshState[1]
     } : null;
+    // Use the incoming search params, even if the response has no new data for
+    // this segment. The base tree may still have the previous URL's. History
+    // restores pass in their saved search params instead.
     const renderedSearch = refreshState !== null ? refreshState.renderedSearch : parentRenderedSearch;
-    let segment;
-    let partialVaryPath;
-    let isPage;
-    let varyPath;
-    if (Array.isArray(originalSegment)) {
-        isPage = false;
-        const paramCacheKey = originalSegment[1];
-        const paramName = originalSegment[0];
-        partialVaryPath = (0, _varypath.appendLayoutVaryPath)(parentPartialVaryPath, paramCacheKey, paramName, isRootParam);
-        varyPath = (0, _varypath.finalizeLayoutVaryPath)(requestKey, partialVaryPath);
-        segment = originalSegment;
-    } else {
-        // This segment does not have a param. Inherit the partial vary path of
-        // the parent.
-        partialVaryPath = parentPartialVaryPath;
-        if (requestKey.endsWith(_segment.PAGE_SEGMENT_KEY)) {
-            // This is a page segment.
-            isPage = true;
-            // The navigation implementation expects the search params to be included
-            // in the segment. However, in the case of a static response, the search
-            // params are omitted. So the client needs to add them back in when reading
-            // from the Segment Cache.
-            //
-            // For consistency, we'll do this for dynamic responses, too.
-            //
-            // TODO: We should move search params out of FlightRouterState and handle
-            // them entirely on the client, similar to our plan for dynamic params.
-            segment = _segment.PAGE_SEGMENT_KEY;
-            varyPath = (0, _varypath.finalizePageVaryPath)(requestKey, renderedSearch, partialVaryPath);
-            // The metadata "segment" is not part the route tree, but it has the same
-            // conceptual params as a page segment. Write the vary path into the
-            // accumulator object. If there are multiple parallel pages, we use the
-            // first one. Which page we choose is arbitrary as long as it's
-            // consistently the same one every time every time. See
-            // finalizeMetadataVaryPath for more details.
-            if (acc.metadataVaryPath === null) {
-                acc.metadataVaryPath = (0, _varypath.finalizeMetadataVaryPath)(requestKey, renderedSearch, partialVaryPath);
-            }
-        } else {
-            // This is a layout segment.
-            isPage = false;
-            segment = originalSegment;
-            varyPath = (0, _varypath.finalizeLayoutVaryPath)(requestKey, partialVaryPath);
-        }
-    }
+    const tree = (0, _decodeserverresponse.createRouteTreeNode)(originalSegment, isRootParam, requestKey, parentPartialVaryPath, renderedSearch, refreshState, acc);
+    const partialVaryPath = (0, _varypath.getPartialVaryPath)(tree.varyPath);
     let slots = null;
     const parallelRoutes = flightRouterState[1];
     for(let parallelRouteKey in parallelRoutes){
@@ -1143,22 +1105,9 @@ function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, pare
         }
         slots.set(parallelRouteKey, childTree);
     }
-    return {
-        requestKey,
-        segment,
-        shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(varyPath),
-        refreshState,
-        // TODO: Cheating the type system here a bit because TypeScript can't tell
-        // that the type of isPage and varyPath are consistent. The fix would be to
-        // create separate constructors and call the appropriate one from each of
-        // the branches above. Just seems a bit overkill only for one field so I'll
-        // leave it as-is for now. If isPage were wrong it would break the behavior
-        // and we'd catch it quickly, anyway.
-        varyPath: varyPath,
-        isPage: isPage,
-        slots,
-        prefetchHints: flightRouterState[4] ?? 0
-    };
+    tree.slots = slots;
+    tree.prefetchHints = flightRouterState[4] ?? 0;
+    return tree;
 }
 function convertRouteTreeToFlightRouterState(routeTree) {
     const parallelRoutes = {};
@@ -1179,9 +1128,7 @@ function convertRouteTreeToFlightRouterState(routeTree) {
     }
     return flightRouterState;
 }
-async function fetchRouteOnCacheMiss(entry, key, // The spawning task's `PrefetchTask.segmentCacheMap`, for the legacy
-// branch that writes segment data included in the tree response.
-map) {
+async function fetchRouteOnCacheMiss(entry, key) {
     // This function is allowed to use async/await because it contains the actual
     // fetch that gets issued on a cache miss. Notice it writes the result to the
     // cache entry directly, rather than return data that is then written by
@@ -1247,7 +1194,7 @@ map) {
                 //
                 // Note that we can't use headResponse.ok here, because
                 // Response#ok returns `false` with 3xx responses.
-                rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
+                rejectRouteCacheEntry(entry, Date.now() + REJECTION_BACKOFF_MS);
                 return null;
             }
             urlAfterRedirects = headResponse.redirected ? new URL(headResponse.url) : url;
@@ -1263,7 +1210,7 @@ map) {
         if (!response || !response.ok || !response.body) {
             // Server responded with an error, or with a miss. We should still cache
             // the response, but we can try again after 10 seconds.
-            rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
+            rejectRouteCacheEntry(entry, Date.now() + REJECTION_BACKOFF_MS);
             return null;
         }
         // TODO: The canonical URL is the href without the origin. I think
@@ -1291,77 +1238,66 @@ map) {
         // prefetches, which use incremental streaming. Consider removing the
         // `closed` plumbing for buffered prefetch paths.
         const closed = (0, _promisewithresolvers.createPromiseWithResolvers)();
-        // This checks whether the response was served from the per-segment cache,
-        // rather than the old prefetching flow. If it fails, it implies that PPR
-        // is disabled on this route.
-        const routeIsPPREnabled = response.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER) === '2' || // In output: "export" mode, we can't rely on response headers. But if we
-        // receive a well-formed response, we can assume it's a static response,
-        // because all data is static in this mode.
-        isOutputExportMode;
-        if (routeIsPPREnabled) {
-            const { stream: prefetchStream, size: responseSize } = await createNonTaskyPrefetchResponseStream(response.body);
-            closed.resolve();
-            (0, _cachemap.setSizeInCacheMap)(entry, responseSize);
-            const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
-                allowPartialStream: true
-            });
-            if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.buildId) !== (0, _navigationbuildid.getNavigationBuildId)()) {
-                // The server build does not match the client. Treat as a 404. During
-                // an actual navigation, the router will trigger an MPA navigation.
-                // TODO: We should cache the fact that this is an MPA navigation.
-                rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
-                return null;
-            }
-            // Get the params that were used to render the target page. These may
-            // be different from the params in the request URL, if the page
-            // was rewritten.
-            const renderedPathname = (0, _routeparams.getRenderedPathname)(response);
-            const renderedSearch = (0, _routeparams.getRenderedSearch)(response);
-            // Convert the server-sent data into the RouteTree format used by the
-            // client cache.
-            //
-            // During this traversal, we accumulate additional data into this
-            // "accumulator" object.
-            const acc = {
-                metadataVaryPath: null,
-                treeDivergedFromBase: false
-            };
-            const routeTree = convertRootTreePrefetchToRouteTree(serverData, renderedPathname, renderedSearch, acc);
-            const metadataVaryPath = acc.metadataVaryPath;
-            if (metadataVaryPath === null) {
-                rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
-                return null;
-            }
-            (0, _optimisticroutes.discoverKnownRoute)(Date.now(), pathname, search, nextUrl, entry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, false // hasDynamicRewrite
-            );
-        } else {
-            // PPR is not enabled for this route. The server responds with a
-            // different format (FlightRouterState) that we need to convert.
-            // TODO: We will unify the responses eventually. I'm keeping the types
-            // separate for now because FlightRouterState has so many
-            // overloaded concerns.
-            const { stream: prefetchStream, size: responseSize } = await createNonTaskyPrefetchResponseStream(response.body);
-            closed.resolve();
-            (0, _cachemap.setSizeInCacheMap)(entry, responseSize);
-            const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
-                allowPartialStream: true
-            });
-            if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.b) !== (0, _navigationbuildid.getNavigationBuildId)()) {
-                // The server build does not match the client. Treat as a 404. During
-                // an actual navigation, the router will trigger an MPA navigation.
-                // TODO: We should cache the fact that this is an MPA navigation.
-                rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
-                return null;
-            }
-            // Read head vary params synchronously (unioning in the response-level
-            // root params). Individual segments carry their own iterables in
-            // CacheNodeSeedData; the root iterable is threaded down so each segment
-            // unions it too.
-            const headVaryParams = (0, _varyparamsdecoding.readVaryParams)(serverData.h, serverData.r);
-            writeDynamicTreeResponseIntoCache(Date.now(), // The non-PPR response format is what we'd get if we prefetched these segments
-            // using the LoadingBoundary fetch strategy, so mark their cache entries accordingly.
-            _types.FetchStrategy.LoadingBoundary, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, headVaryParams, serverData.r ?? null, pathname, search, nextUrl, map);
+        // Note this doesn't imply PPR is enabled for the route: fully static
+        // routes serve from the per-segment cache too. What it does tell us is
+        // that per-segment prefetching is supported, which is what the route
+        // entry records below.
+        const supportsPerSegmentPrefetching = wasServedFromPerSegmentCache(response);
+        // Decode the response. Routes that support per-segment prefetching
+        // respond from static storage; other routes respond with a live render
+        // (see the isRouteTreePrefetchRequest branch in
+        // walk-tree-with-flight-router-state). Both are
+        // NavigationFlightResponses carrying a buildId and a structure-only
+        // transport tree — which is all this flow reads — so one decode path
+        // serves both.
+        const buffer = await bufferPrefetchResponseBody(response.body);
+        closed.resolve();
+        (0, _cachemap.setSizeInCacheMap)(entry, buffer.byteLength);
+        const serverData = await (0, _fetchserverresponse.decodeBufferedStage)(buffer, headers);
+        if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.b) !== (0, _navigationbuildid.getNavigationBuildId)()) {
+            // The server build does not match the client. Treat as a 404. During
+            // an actual navigation, the router will trigger an MPA navigation.
+            // TODO: We should cache the fact that this is an MPA navigation.
+            rejectRouteCacheEntry(entry, Date.now() + REJECTION_BACKOFF_MS);
+            return null;
+        }
+        const transportData = serverData.t;
+        if (transportData === undefined || serverData.n !== undefined) {
+            // The response carries no route tree (e.g. it's an MPA navigation), so
+            // there's nothing to cache.
+            rejectRouteCacheEntry(entry, Date.now() + REJECTION_BACKOFF_MS);
+            return null;
+        }
+        // Get the params that were used to render the target page. These may
+        // be different from the params in the request URL, if the page
+        // was rewritten. The rendered pathname is also used to fill in the param
+        // values the server omitted from the response (omitting them keeps the
+        // response cacheable across param values).
+        const renderedPathname = (0, _routeparams.getRenderedPathname)(response);
+        const renderedSearch = (0, _routeparams.getRenderedSearch)(response);
+        // Decode the server-sent tree into the RouteTree format used by the
+        // client cache.
+        //
+        // During this traversal, we accumulate additional data into this
+        // "accumulator" object.
+        const acc = {
+            metadataVaryPath: null,
+            treeDivergedFromBase: false
+        };
+        const routeTree = (0, _decodeserverresponse.decodeTransportTreeIntoRouteTree)(transportData.t, null, // The tree is structure-only (no data nodes), so there are no vary
+        // params to decode...
+        null, // ...and no partiality either; the conservative value is never read.
+        true, renderedPathname, renderedSearch, acc);
+        const metadataVaryPath = acc.metadataVaryPath;
+        if (metadataVaryPath === null) {
+            rejectRouteCacheEntry(entry, Date.now() + REJECTION_BACKOFF_MS);
+            return null;
         }
+        (0, _optimisticroutes.discoverKnownRoute)(Date.now(), pathname, search, nextUrl, entry, {
+            tree: routeTree,
+            head: createMetadataRouteTree(metadataVaryPath, routeTree.prefetchHints, null)
+        }, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching, false // hasDynamicRewrite
+        );
         if (!couldBeIntercepted) {
             // This route will never be intercepted. So we can use this entry for all
             // requests to this route, regardless of the Next-Url header. This works
@@ -1385,33 +1321,11 @@ map) {
         };
     } catch (error) {
         // Either the connection itself failed, or something bad happened while
-        // decoding the response. If we're offline, reject with staleAt=-1 so the
-        // entry immediately expires and gets retried once the scheduler is
-        // re-pinged after connectivity is restored.
-        if (process.env.__NEXT_USE_OFFLINE) {
-            const { checkOfflineError } = require('../offline');
-            if (checkOfflineError(error)) {
-                // Unlike navigations and server actions, prefetches don't await
-                // waitForConnection — they just reject the cache entry with an
-                // immediate expiration so it gets retried once the scheduler is
-                // re-pinged after connectivity is restored.
-                rejectRouteCacheEntry(entry, -1);
-                return null;
-            }
-        }
-        rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
+        // decoding the response.
+        rejectRouteCacheEntry(entry, getPrefetchErrorStaleAt(error));
         return null;
     }
 }
-function rejectRemainingSegmentsInBundle(entries, staleAt) {
-    let node = entries;
-    while(node !== null){
-        if (node.entry !== null && node.entry.status === _cachemap.EntryStatus.Pending) {
-            rejectSegmentCacheEntry(node.entry, staleAt);
-        }
-        node = node.parent;
-    }
-}
 // When a static (per-segment PPR) prefetch receives an upgradeable fallback
 // shell, the localized retry loop re-issues the same fetch after this delay to
 // pick up the concrete version once the server's background regeneration
@@ -1420,7 +1334,9 @@ const FALLBACK_RETRY_DELAY_MS = 2000;
 // Maximum number of fallback retries per task, to avoid looping indefinitely
 // if the server keeps returning a fallback (e.g. misconfiguration).
 const MAX_FALLBACK_RETRIES = 3;
-async function fetchSegmentsOnCacheMiss(task, route, routeKey, tree, segments, segmentCount, // Which walk spawned the bundle's entries. The request on the wire is
+async function fetchSegmentPrefetchesUsingStaticRequest(task, route, routeKey, tree, // The pending cache entries this task spawned for the bundle, keyed by
+// segment request key. The response fulfills them when it arrives.
+spawnedEntries, // Which walk spawned the bundle's entries. The request on the wire is
 // identical either way; this only decides which payload of the response
 // fulfills the entries.
 fetchStrategy) {
@@ -1431,81 +1347,90 @@ fetchStrategy) {
     //
     // Segment fetches are non-blocking so we don't need to ping the scheduler
     // on completion.
-    let result;
+    let isUpgradeableISRFallback;
     try {
-        result = await fetchSegmentsOnCacheMissImpl(route, routeKey, tree);
+        isUpgradeableISRFallback = await fetchAndWritePerSegmentPrefetchResponse(task, route, routeKey, tree, spawnedEntries, fetchStrategy, // Write the response even if it's an upgradeable fallback shell — the
+        // fallback content is better than nothing while the retry loop waits
+        // for the concrete version.
+        false);
     } catch (error) {
         // The connection failed, or the response couldn't be decoded. Reject the
-        // pending entries so they don't stay Pending forever, and get retried once
-        // the entry expires. If we're offline, expire immediately (-1) so the entry
-        // is re-fetched once the scheduler is re-pinged on reconnect; otherwise
-        // apply a 10s backoff. (Unlike navigations and server actions, prefetches
-        // don't await `waitForConnection`.)
-        let staleAt = Date.now() + 10 * 1000;
-        if (process.env.__NEXT_USE_OFFLINE) {
-            const { checkOfflineError } = require('../offline');
-            if (checkOfflineError(error)) {
-                staleAt = -1;
-            }
-        }
-        rejectRemainingSegmentsInBundle(segments, staleAt);
+        // pending entries so they don't stay Pending forever, and get retried
+        // once the entry expires.
+        rejectSegmentEntriesIfStillPending(spawnedEntries, getPrefetchErrorStaleAt(error));
         return null;
     }
-    if (result === null) {
+    if (isUpgradeableISRFallback === null) {
         // The response was fetched but isn't usable yet (server error/miss, empty
         // data, or a build-id mismatch — the server may be transiently unready).
         // Reject with a short backoff so the entries are retried soon.
-        rejectRemainingSegmentsInBundle(segments, Date.now() + 10 * 1000);
+        rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + REJECTION_BACKOFF_MS);
         return null;
     }
-    const { serverResponse, shellResponse, responseSize, closed } = result;
-    const now = Date.now();
-    writeSegmentBundleResponseVariants(task.segmentCacheMap, serverResponse, shellResponse, responseSize, segments, segmentCount, now, fetchStrategy);
-    // If the server served an upgradeable fallback shell, drive a localized
-    // retry loop to pick up the concrete version once the server's background
-    // regeneration finishes. Only the first such response per task starts a loop
-    // (`fallbackRetryStatus === Empty`); once it leaves Empty, no second loop is
-    // started — sibling bundle responses that also got a fallback don't, and
-    // neither does a re-hover.
-    if (serverResponse.isUpgradeableISRFallback && task.fallbackRetryStatus === _cachemap.EntryStatus.Empty && !task.isCanceled) {
-        task.fallbackRetryStatus = _cachemap.EntryStatus.Pending;
-        // Fire-and-forget: the loop drives itself via timers and pings the task
-        // on success.
-        void retryUpgradeableFallbackPrefetch(task, route, routeKey, tree, segments, segmentCount, fetchStrategy);
-    }
     return {
         value: null,
-        closed
+        // The response is fully buffered before it's decoded, so the network
+        // connection is already closed by the time the fetch returns. See TODO
+        // in fetchRouteOnCacheMiss about removing `closed` for buffered
+        // prefetch paths.
+        closed: Promise.resolve()
     };
 }
 /**
- * Issues a single segment-bundle prefetch request, validates it, and decodes
- * the response. Returns the decoded response (see the return type below)
- * on success, or `null` if the response was fetched but isn't usable yet
- * (server error/miss, empty data, or a build-id mismatch — the server may be
- * transiently unready, so it's worth retrying). THROWS if the connection failed
- * or the response couldn't be decoded; re-issuing the identical request won't
- * fix that, so callers should give up rather than retry.
+ * Issues a single segment-bundle prefetch request, validates and decodes the
+ * response, and writes every payload of it into the cache — the full
+ * payload, and, when the response carries a shell byte boundary, a second
+ * decode of the same bytes truncated at that boundary, the segments'
+ * shell-stage variant — through the shared payload-write orchestration
+ * (writeResponsePayloadsIntoCache), which owns which payload fulfills the
+ * spawned entries and the tier each payload is written at.
+ *
+ * Returns whether the response was an upgradeable ISR fallback shell (the
+ * page hadn't been prerendered with concrete params yet), or `null` if the
+ * response was fetched but isn't usable yet (server error/miss, empty data,
+ * or a build-id mismatch — the server may be transiently unready, so it's
+ * worth retrying; nothing is written and no entries are rejected). THROWS if
+ * the connection failed or the response couldn't be decoded; re-issuing the
+ * identical request won't fix that, so callers should give up rather
+ * than retry.
+ *
+ * When the response is an upgradeable fallback shell, this also starts the
+ * task's localized fallback-retry loop (at most one per task, ever), BEFORE
+ * writing the fallback content — see the comment on the transition below.
  *
- * This deliberately does NOT touch the cache — it neither writes the decoded
- * segments nor rejects entries. The caller decides what to do with the result:
- * write it (`fetchSegmentsOnCacheMiss`) or ignore it and try again (the retry
- * loop). Calling this again with the same arguments reproduces the exact same
- * request.
- */ async function fetchSegmentsOnCacheMissImpl(route, routeKey, tree) {
+ * Calling this again with the same arguments reproduces the exact same
+ * request. The retry loop uses that to re-issue the request until the server
+ * has the concrete version, passing `discardFallbackResponse` so a response
+ * that is STILL a fallback isn't pointlessly re-written over the identical
+ * fallback content the initial fetch already cached. (The retry's entries
+ * are already settled, so its writes are all detached upserts.)
+ */ async function fetchAndWritePerSegmentPrefetchResponse(task, route, routeKey, tree, spawnedEntries, fetchStrategy, // When true, a response that is still an upgradeable fallback shell is
+// discarded instead of written (the fallback-retry loop's re-issued
+// requests).
+discardFallbackResponse) {
     // Use the canonical URL to request the segment, not the original URL. These
     // are usually the same, but the canonical URL will be different if the route
     // tree response was redirected. To avoid an extra waterfall on every segment
     // request, we pass the redirected URL instead of the original one.
     const url = new URL(route.canonicalUrl, location.origin);
     const nextUrl = routeKey.nextUrl;
-    const requestKey = tree.requestKey;
-    const normalizedRequestKey = requestKey === _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY ? // handling of these requests, we encode the root segment path as
-    // `_index` instead of as an empty string. This should be treated as
-    // an implementation detail and not as a stable part of the protocol.
-    // It just needs to match the equivalent logic that happens when
-    // prerendering the responses. It should not leak outside of Next.js.
-    '/_index' : requestKey;
+    let normalizedRequestKey;
+    if (tree.segment === _segmentvalueencoding.HEAD_REQUEST_KEY) {
+        // The head's request key is its client cache identity; the server only
+        // knows the head by its bare marker, which is also the head node's
+        // segment (see createMetadataRouteTree).
+        normalizedRequestKey = _segmentvalueencoding.HEAD_REQUEST_KEY;
+    } else if (tree.requestKey === _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY) {
+        // The root segment is a special case. To simplify the server-side
+        // handling of these requests, we encode the root segment path as
+        // `_index` instead of as an empty string. This should be treated as
+        // an implementation detail and not as a stable part of the protocol.
+        // It just needs to match the equivalent logic that happens when
+        // prerendering the responses. It should not leak outside of Next.js.
+        normalizedRequestKey = '/_index';
+    } else {
+        normalizedRequestKey = tree.requestKey;
+    }
     const headers = {
         [_approuterheaders.RSC_HEADER]: '1',
         [_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER]: '1',
@@ -1516,37 +1441,59 @@ fetchStrategy) {
     }
     const requestUrl = isOutputExportMode ? addSegmentPathToUrlInOutputExportMode(url, normalizedRequestKey) : url;
     const response = await fetchPrefetchResponse(requestUrl, headers);
-    if (!response || !response.ok || // This checks whether the response was served from the per-segment cache,
-    // rather than the old prefetching flow. If it fails, it implies that PPR
-    // is disabled on this route. Theoretically this should never happen
-    // because we only issue requests for segments once we've verified that
-    // the route supports PPR.
-    response.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER) !== '2' && // In output: "export" mode, we can't rely on response headers. But if
-    // we receive a well-formed response, we can assume it's a static
-    // response, because all data is static in this mode.
-    !isOutputExportMode || !response.body) {
+    if (!response || !response.ok || // Theoretically this check should never fail, because we only issue
+    // requests for segments once we've verified that the route supports PPR.
+    !wasServedFromPerSegmentCache(response) || !response.body) {
         // Server responded with an error or a miss — fetched but not usable.
         return null;
     }
-    // See TODO in fetchRouteOnCacheMiss about removing `closed` for
-    // buffered prefetch paths.
-    const closed = (0, _promisewithresolvers.createPromiseWithResolvers)();
-    const { stream: prefetchStream, size: responseSize, buffer } = await createNonTaskyPrefetchResponseStream(response.body);
-    closed.resolve();
-    // Parse the response. Always a SegmentPrefetchResponse with a build ID and a
-    // data array. A connection drop or malformed stream throws here, which
-    // propagates to the caller as a non-retryable failure.
-    const serverResponse = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
-        allowPartialStream: true
-    });
-    if (serverResponse.data.length === 0) {
+    const buffer = await bufferPrefetchResponseBody(response.body);
+    // Parse the response. Always a PrefetchFlightResponse. A connection drop
+    // or malformed stream throws here, which propagates to the caller as a
+    // non-retryable failure.
+    const serverResponse = await (0, _fetchserverresponse.decodeBufferedStage)(buffer, headers);
+    if (serverResponse.t === undefined) {
+        // The response carries no segment data at all — not usable.
+        // writeServerResponseIntoCache checks this again, but this fetch-layer
+        // copy is deliberate: it must run before the fallback-retry loop is
+        // started and before the payload writes below, neither of which should
+        // happen for an empty response.
         return null;
     }
-    if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverResponse.buildId) !== (0, _navigationbuildid.getNavigationBuildId)()) {
+    if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverResponse.b) !== (0, _navigationbuildid.getNavigationBuildId)()) {
         // The server build does not match the client. Treat as a 404. During
         // an actual navigation, the router will trigger an MPA navigation.
         return null;
     }
+    // True if the server served an upgradeable fallback shell (the page hadn't
+    // been prerendered with concrete params yet, but the route can be
+    // upgraded once the server's background regeneration finishes).
+    const isUpgradeableISRFallback = serverResponse.f === true;
+    if (isUpgradeableISRFallback) {
+        if (discardFallbackResponse) {
+            // Still a fallback — the server hasn't finished regenerating. Don't
+            // write it; the retry loop will re-issue the request.
+            return true;
+        }
+        // Drive a localized retry loop to pick up the concrete version once the
+        // server's background regeneration finishes. Only the first fallback
+        // response per task starts a loop (`fallbackRetryStatus === Empty`);
+        // once it leaves Empty, no second loop is started — sibling bundle
+        // responses that also got a fallback don't, and neither does a re-hover.
+        //
+        // The transition to Pending must happen BEFORE the fallback content is
+        // written below: fulfilling an entry pings the tasks blocked on it, and
+        // a scheduler pass that ran before the transition would observe a
+        // fulfilled fallback entry with the retry gate still Empty and spawn a
+        // duplicate revalidation request (see isUpgradeableISRFallbackRetry in
+        // pingSegmentBundle in scheduler.ts).
+        if (task.fallbackRetryStatus === _cachemap.EntryStatus.Empty && !task.isCanceled) {
+            task.fallbackRetryStatus = _cachemap.EntryStatus.Pending;
+            // Fire-and-forget: the loop drives itself via timers and pings the
+            // task on success.
+            void retryUpgradeableFallbackPrefetch(task, route, routeKey, tree, spawnedEntries, fetchStrategy);
+        }
+    }
     // Extract the shell payload, if the response carries a distinct one
     // (positive shell byte offset): decode the buffered bytes a SECOND time,
     // truncated at the boundary. The truncation is what produces the shell
@@ -1556,16 +1503,18 @@ fetchStrategy) {
     // fulfillments past the boundary read as pending in this decode, so a
     // post-shell runtime-data access doesn't mark the shell variant itself as
     // needing a runtime request.
-    // (The offset is never legitimately pending or 0 in this decode: the full
-    // buffer is present, and the server only ever emits a positive offset or
-    // null. Reading 0 — the default for an unfulfilled `a` — therefore means a
-    // bug in Next.js itself, and is handled like an error: the response is
-    // treated as carrying no shell, and the scheduler skips the affected
-    // segments rather than falling back to a runtime request — see the
-    // `shellResponse === null` handling in writeSegmentBundleResponseVariants.
-    // Failing in that direction costs a shell prefetch but never leaks
-    // post-shell content into shell positions.)
-    const shellOffset = readFulfilledValue(serverResponse.a, 0);
+    // (A 0 offset means the response carries no shell: the server emits a
+    // fulfilled 0 when the page wasn't staged at all — see the `a` resolution
+    // in collect-segment-data — and 0 is also the default read of an
+    // unfulfilled `a`, which would be a Next.js bug since the full buffer is
+    // present. Both read the same here: no shell, and the scheduler skips the
+    // affected segments rather than falling back to a runtime request — see
+    // the no-shell handling in writeResponsePayloadsIntoCache. Failing in that
+    // direction costs a shell prefetch but never leaks post-shell content into
+    // shell positions. 0 can double as "none" on the wire precisely because
+    // it's never a valid offset — see the `a` field doc on
+    // NavigationFlightResponse.)
+    const shellOffset = serverResponse.a !== undefined ? (0, _rsctransport.readFulfilledValue)(serverResponse.a, 0) : 0;
     let shellResponse;
     if (shellOffset === null) {
         shellResponse = serverResponse;
@@ -1579,273 +1528,55 @@ fetchStrategy) {
             // exists; the full payload is still usable. (For a StaticShell-spawned
             // bundle this means the spawned entries are rejected — the scheduler
             // then skips them rather than issuing a runtime substitute; see the
-            // no-shell branch in fetchSegmentsOnCacheMiss.)
+            // no-shell handling in writeResponsePayloadsIntoCache.)
             shellResponse = null;
         }
     }
-    return {
-        serverResponse,
-        responseSize,
-        shellResponse,
-        closed: closed.promise
-    };
-}
-/**
- * Writes every payload of a parsed segment-bundle response into the cache.
- * The bundle's entries are fulfilled by the payload matching the walk that
- * spawned them; the other payload, when distinct, is written with a detached
- * copy of the bundle. The full payload is written first so the shell write's
- * shadow eviction sees the fresh concrete entry.
- *
- * Shared by the initial fetch (`fetchSegmentsOnCacheMiss`) and the localized
- * fallback-retry loop. The retry's bundle entries are already settled, so
- * for that caller every write is a detached upsert and the rejection below
- * is a no-op (it only touches Pending entries).
- */ function writeSegmentBundleResponseVariants(// The map the bundle's entries live in (pinned when the request was
-// spawned).
-map, serverResponse, shellResponse, responseSize, segments, segmentCount, now, // Which walk spawned the bundle's entries; decides which payload fulfills
-// them. See fetchSegmentsOnCacheMiss.
-fetchStrategy) {
-    if (fetchStrategy === _types.FetchStrategy.StaticShell) {
-        if (shellResponse !== serverResponse) {
-            writeSegmentBundleResponse(map, serverResponse, responseSize, detachEntriesFromSegmentBundle(segments), segmentCount, now, _types.FetchStrategy.PPR, _types.FetchStrategy.PPR);
-        }
-        if (shellResponse === null) {
-            // No shell exists. Reject the spawned entries so the task isn't
-            // stranded blocking on them. Note the scheduler does NOT fall back to
-            // a runtime request for rejected segments — it skips them outright (see
-            // the Rejected case in pingSegmentBundle in scheduler.ts), so these
-            // segments get no shell prefetch and no runtime substitute until the
-            // rejection's backoff expires.
-            rejectRemainingSegmentsInBundle(segments, now + 10 * 1000);
-        } else {
-            writeSegmentBundleResponse(map, shellResponse, responseSize, segments, segmentCount, now, _types.FetchStrategy.StaticShell, // When the shell IS the full response (no shell/full split), the
-            // entries this write fulfills carry full-tier content, so PPR is the
-            // strategy that describes it.
-            shellResponse === serverResponse ? _types.FetchStrategy.PPR : _types.FetchStrategy.StaticShell);
-        }
-    } else {
-        writeSegmentBundleResponse(map, serverResponse, responseSize, segments, segmentCount, now, _types.FetchStrategy.PPR, _types.FetchStrategy.PPR);
-        if (shellResponse !== null && shellResponse !== serverResponse) {
-            writeSegmentBundleResponse(map, shellResponse, responseSize, detachEntriesFromSegmentBundle(segments), segmentCount, now, _types.FetchStrategy.StaticShell, _types.FetchStrategy.StaticShell);
-        }
-    }
-}
-/**
- * Writes one payload of a parsed segment-bundle response into the cache:
- * distributes the response size across the bundle, then walks the segments
- * list and the response's `data` array in parallel, fulfilling/upserting
- * each entry. Any segments the server didn't return are rejected so they
- * don't stay Pending forever.
- *
- * `fetchStrategy` says which of the response's payloads this call is
- * writing — StaticShell for the shell payload, PPR for the full payload —
- * which determines the vary paths the entries are keyed at.
- *
- * The walk fulfills any Pending entry in `segments`, so the caller must
- * pass the bundle only to the walk matching the entries' own strategy, and
- * a detached copy to the other. In particular, fulfilling a spawned
- * StaticShell entry with the concrete payload would leak param-dependent
- * content into shell positions: during a navigation, a pending entry can be
- * rendered as a promise that resolves to its eventual value.
- *
- * Shared by the initial fetch and the localized fallback-retry loop (which
- * re-issues the same request and upserts the upgraded result here).
- */ function writeSegmentBundleResponse(map, serverResponse, responseSize, segments, segmentCount, now, fetchStrategy, // The strategy tier that describes this payload's CONTENT, recorded on
-// the entries it fulfills. Differs from `fetchStrategy` (which drives
-// matching and keying) in one case: a StaticShell write whose payload IS
-// the full response (no shell/full split) records PPR — see
-// writeSegmentBundleResponseVariants.
-payloadFetchStrategy) {
-    // Distribute the response size evenly across all segments in the bundle.
-    // (When a response produces two payload writes, each write distributes the
-    // full response size — intentionally double-charging the LRU for one wire
-    // response, since it produced two live entries per segment.)
-    const averageSize = responseSize / segmentCount;
-    let sizeNode = segments;
-    while(sizeNode !== null){
-        if (sizeNode.entry !== null) {
-            (0, _cachemap.setSizeInCacheMap)(sizeNode.entry, averageSize);
-        }
-        sizeNode = sizeNode.parent;
-    }
-    const serverDataArray = serverResponse.data;
-    // True if the server served an upgradeable fallback shell (page not yet
-    // prerendered with concrete params, but the route can be upgraded). Applies
-    // to the whole response and is recorded on each fulfilled entry.
-    const responseIsUpgradeableISRFallback = serverResponse.isUpgradeableISRFallback;
-    // Whether the render that produced this payload accessed runtime data
-    // (page-global; combined with each segment's `isPartial` below to decide
-    // the tier each entry records). Read from THIS decode's thenable status,
-    // which scopes it to the payload being written — see
-    // `SegmentPrefetchResponse['needsRuntimeRequest']` for the encoding.
-    //
-    // Reading it from the same decode that produced the entry's data is what
-    // makes the answer rewindable: a truncated shell decode reads a post-shell
-    // runtime access as pending, i.e. `false`, because the shell variant itself
-    // doesn't need that data.
-    //
-    // It is load-bearing in one direction only. A false `true` costs a wasted
-    // runtime request; a false `false` would record too high a tier and skip a
-    // runtime request that had more content.
-    const responseNeedsRuntimeRequest = readFulfilledValue(serverResponse.needsRuntimeRequest, false);
-    let node = segments;
-    let dataIndex = 0;
-    while(node !== null && dataIndex < serverDataArray.length){
-        const data = serverDataArray[dataIndex];
-        // Null data means this segment has prefetching disabled
-        // (prefetch: 'force-disabled' — Partial Prefetching segments have static
-        // data, so the server emits a real slot for them). Skip it without
-        // creating a cache entry.
-        if (data === null || node.tree === null) {
-            // The server's and the client's prefetch-disabled hints normally agree,
-            // so there shouldn't be a spawned entry for a segment the server
-            // skipped. But if they disagree, a Pending entry that a task blocked on
-            // would otherwise never settle, stranding the task forever. Settle
-            // it defensively.
-            if (node.entry !== null && node.entry.status === _cachemap.EntryStatus.Pending) {
-                rejectSegmentCacheEntry(node.entry, now + 10 * 1000);
-            }
-            node = node.parent;
-            dataIndex++;
-            continue;
-        }
-        // The segment's late-resolving metadata can be read synchronously
-        // because the payload was fully buffered before it was decoded (and, for
-        // a truncated shell decode, delivered as a single chunk).
-        const entryStaleAt = readFulfilledStaleAt(now, data.staleTime);
-        // Root params are emitted once at the top level of the response and
-        // unioned into each segment's set here, same as for a route-level
-        // response.
-        const varyParams = (0, _varyparamsdecoding.readVaryParams)(data.varyParams, serverResponse.rootVaryParams);
-        const isPartial = readFulfilledIsPartial(data.isPartial);
-        // A runtime prefetch can only provide more content than this entry if the
-        // render accessed runtime data AND this particular segment has holes — a
-        // fully static segment gains nothing from a runtime request no matter
-        // what the page accessed.
-        const needsRuntimeRequest = responseNeedsRuntimeRequest && isPartial;
-        // An entry records the tier of the content that actually satisfied it,
-        // which spans both axes: shell-vs-concrete AND static-vs-runtime.
-        //
-        // When this payload fully satisfied the segment — no runtime request
-        // needed — the content is as complete as a RUNTIME response of the same
-        // variant would have been, so it records that runtime tier. That's what
-        // lets the scheduler decide "would a runtime request return more?" by
-        // comparing tiers alone, with no separate signal to consult.
-        //
-        // Otherwise the content is only as complete as the static tier it was
-        // requested at, so a follow-up runtime request can still supersede it.
-        const recordedFetchStrategy = !needsRuntimeRequest ? payloadFetchStrategy === _types.FetchStrategy.StaticShell ? _types.FetchStrategy.RuntimeShell : _types.FetchStrategy.PPRRuntime : fetchStrategy;
-        // Key the entry by which params the server said this segment depends on.
-        // Reusing one copy across param values is the point of the shell, but it
-        // requires knowing the content doesn't depend on those params, and the
-        // server's report is the direct evidence of that.
-        //
-        // Without that report, assume every param varies. The exception is a
-        // shell variant, which reduces param-dependent content to param
-        // fallbacks, so it really is good for any value of them.
-        const payloadVaryPath = process.env.__NEXT_VARY_PARAMS && varyParams !== null ? (0, _varypath.getFulfilledSegmentVaryPath)(node.tree.varyPath, varyParams) : (0, _varypath.getSegmentVaryPathForRequest)(payloadFetchStrategy, node.tree);
-        const nodeEntry = node.entry;
-        if (nodeEntry !== null && nodeEntry.status === _cachemap.EntryStatus.Pending) {
-            // We own this entry — fulfill it directly.
-            const fulfilledEntry = fulfillSegmentCacheEntry(nodeEntry, data.rsc, entryStaleAt, isPartial, responseIsUpgradeableISRFallback, recordedFetchStrategy);
-            // Move the entry to that key. This is load-bearing rather than a no-op:
-            // a task spawns its entries before it knows what the response will
-            // contain, so the key it guessed can be more reusable than the response
-            // turned out to deserve.
-            //
-            // Pass the concrete lookup path — the most specific path a read for
-            // this segment position would use — so that if the entry lands at a
-            // more generic key, a stale entry at a more specific one can't shadow
-            // it. See evictShadowingSegmentEntries. The upsert (rather than a bare
-            // set) applies the usual precedence rules, so a concurrent task's more
-            // complete response already in this slot isn't downgraded.
-            upsertSegmentEntry(now, map, payloadVaryPath, fulfilledEntry, node.tree.varyPath);
-        } else {
-            // We don't own this entry. Create a detached entry and attempt to
-            // upsert it into this payload's slot.
-            const detachedEntry = createDetachedSegmentCacheEntry(now);
-            const fulfilledEntry = fulfillSegmentCacheEntry(upgradeToPendingSegment(detachedEntry, fetchStrategy), data.rsc, entryStaleAt, isPartial, responseIsUpgradeableISRFallback, recordedFetchStrategy);
-            upsertSegmentEntry(now, map, payloadVaryPath, fulfilledEntry, node.tree.varyPath);
-        }
-        node = node.parent;
-        dataIndex++;
-    }
-    // If the server returned fewer segments than expected, reject any
-    // remaining pending entries so they don't stay Pending forever.
-    if (node !== null) {
-        rejectRemainingSegmentsInBundle(node, now + 10 * 1000);
-    }
-}
-/**
- * Clones a SegmentBundle chain with every `entry` removed, so a write walk
- * over it is pure detached upserts. Used for the payload that does NOT
- * match the bundle's spawned entries (see writeSegmentBundleResponse).
- */ function detachEntriesFromSegmentBundle(segments) {
-    const head = {
-        tree: segments.tree,
-        entry: null,
-        parent: null
-    };
-    let clonedTail = head;
-    let node = segments.parent;
-    while(node !== null){
-        const clonedNode = {
-            tree: node.tree,
-            entry: null,
-            parent: null
-        };
-        clonedTail.parent = clonedNode;
-        clonedTail = clonedNode;
-        node = node.parent;
-    }
-    return head;
-}
-// TODO: Consolidate the read* helpers below with the ones in
-// vary-params-decoding — they all perform a version of the same synchronous
-// read of a buffered decode's late-resolving values.
-/**
- * Reads a segment's partialness from its `isPartial` promise. (Unlike the
- * values read via `readFulfilledValue` below, the fulfillment value here is
- * void — partialness is encoded as the ABSENCE of a fulfillment.) The server
- * fulfills it only for a fully-static segment and leaves it pending for a
- * partial one (see `SegmentPrefetch['isPartial']`), so partial == not
- * fulfilled. The read is synchronous because the response is fully buffered
- * before it's decoded, so a fulfillment is already visible on the thenable's
- * status — the same trick `readVaryParams` uses for the vary params iterables.
- */ function readFulfilledIsPartial(isPartial) {
-    const thenable = isPartial;
-    // Force Flight to unwrap a received-but-not-yet-settled row. A pending row,
-    // or a truncated shell decode whose fulfillment landed past the boundary,
-    // stays non-fulfilled — read as partial, which is correct either way.
-    thenable.then(noop, noop);
-    return thenable.status !== 'fulfilled';
-}
-/**
- * Reads a late-resolving value off a fully-buffered decode's thenable status,
- * using the same trick as above. Returns `valueIfUnresolved` for a row that
- * is pending or absent in this decode — e.g. one whose fulfillment landed
- * past a truncated shell decode's boundary. That's what scopes a response's
- * late-resolving signals to the payload being decoded.
- */ function readFulfilledValue(valueFromServer, valueIfUnresolved) {
-    const thenable = valueFromServer;
-    // Force Flight to unwrap a received-but-not-yet-settled row.
-    thenable.then(noop, noop);
-    if (thenable.status === 'fulfilled' && thenable.value !== undefined) {
-        return thenable.value;
-    }
-    return valueIfUnresolved;
+    // The pathname the page was rendered for, derived the same way the route
+    // tree fetch derives it (the rewritten-path header when the request was
+    // rewritten, the request URL otherwise) so the vary paths computed from
+    // this response's decoded tree agree with the ones on the route entry's
+    // tree. In output: "export" mode the response URL has the segment filename
+    // appended to the pathname, so derive it from the page URL instead
+    // (rewrites don't exist on a static host).
+    const renderedPathname = isOutputExportMode ? (0, _routeparams.getPathnameFromRequestURL)(url) : (0, _routeparams.getRenderedPathname)(response);
+    // Write the payloads into the cache. Each payload is decoded like any
+    // other server response — a root-anchored tree plus an optional head, with
+    // no base overlay (the response covers its own spine) — and written
+    // through the same path as a live-render response. Notes on the
+    // arguments:
+    // - Dynamic segments the server sent without a param value (`k: null`) are
+    //   parsed from the rendered pathname, and the rendered search is the one
+    //   the route tree was built with, so the decoded tree's vary paths agree
+    //   with the ones on the route entry's tree.
+    // - The build id was already verified above, so none is passed.
+    // - The response-level staleness is only a fallback, for segments that
+    //   don't carry their own staleTime (per-segment responses normally
+    //   always do).
+    // - Response-level partiality is unused for per-segment writes — each
+    //   segment (and the head) carries its own partiality via the staged
+    //   promise encoding, which the decode reads in preference to the
+    //   response-level value — so the conservative value (true) is passed.
+    // - The head is keyed at the route's own metadata vary path: the head has
+    //   no tree position, so the decode could only derive a vary path for it
+    //   from a page node in the payload's own tree. A per-segment response
+    //   carries only the spine from the root to the requested segment, so any
+    //   response whose terminal isn't a page has no page node to key the head
+    //   from; the standalone head response is one such case.
+    const now = Date.now();
+    const metadataVaryPath = route.root.head.varyPath;
+    writeResponsePayloadsIntoCache(now, fetchStrategy, serverResponse, shellResponse, null, // The payloads are root-anchored (no base tree), so there's no
+    // prediction to diverge from.
+    null, renderedPathname, route.renderedSearch, undefined, now + _navigatereducer.STATIC_STALETIME_MS, true, metadataVaryPath, spawnedEntries, buffer.byteLength, task.segmentCacheMap);
+    return isUpgradeableISRFallback;
 }
 /**
  * Reads a stale-at time from the staleTime async iterable of a fully-buffered
- * response — segment bundles and stage decodes, which go through
- * `createNonTaskyPrefetchResponseStream`. Because the bytes are all present,
- * each yielded value is already visible on its chunk's thenable status (the
- * same trick `readVaryParams` uses), so this drains synchronously and takes
- * the last value (the final staleTime, as `resolveStaleAt` does for the
- * async case). A missing iterable, or a truncated shell decode whose value
- * landed past the boundary, reads as absent and falls back to the static
- * stale time.
+ * response — stage decodes, which go through
+ * `bufferPrefetchResponseBody`. Drains synchronously via
+ * `readFulfilledStaleTimeSeconds` (see decode-server-response). A missing
+ * iterable, or a truncated shell decode whose value landed past the
+ * boundary, reads as absent and falls back to the static stale time.
  *
  * For the one response kind that isn't buffered when read — a dynamic `Full`
  * response (fetchStrategy.Full with Partial Prefetching disabled) — use
@@ -1854,76 +1585,60 @@ payloadFetchStrategy) {
     if (staleTime === undefined) {
         return now + _navigatereducer.STATIC_STALETIME_MS;
     }
-    const iterator = staleTime[Symbol.asyncIterator]();
-    let staleTimeSeconds;
-    while(true){
-        const chunk = iterator.next();
-        chunk.then(noop, noop);
-        if (chunk.status !== 'fulfilled' || chunk.value === undefined) {
-            break;
-        }
-        if (chunk.value.done) {
-            break;
-        }
-        staleTimeSeconds = chunk.value.value;
-    }
-    if (staleTimeSeconds === undefined || isNaN(staleTimeSeconds)) {
+    const staleTimeSeconds = (0, _decodeserverresponse.readFulfilledStaleTimeSeconds)(staleTime);
+    if (staleTimeSeconds === null) {
         return now + _navigatereducer.STATIC_STALETIME_MS;
     }
     return now + getStaleTimeMs(staleTimeSeconds);
 }
-const noop = ()=>{};
 /**
  * The localized retry loop for an upgradeable fallback shell. Re-issues the
- * exact same segment-bundle request (via `fetchSegmentsOnCacheMissImpl`) up to
- * MAX_FALLBACK_RETRIES times, FALLBACK_RETRY_DELAY_MS apart, until the server
- * returns the concrete (upgraded) version. On success it upserts the upgraded
- * segments (so they aren't re-fetched) and pings the task, so the task's
- * *other* fallback segments get re-attempted. If every attempt is still a
- * fallback (or fails), it gives up.
+ * exact same segment-bundle request up to MAX_FALLBACK_RETRIES times,
+ * FALLBACK_RETRY_DELAY_MS apart, until the server returns the concrete
+ * (upgraded) version. The fetch writes the upgraded response through the
+ * same payload writes as the initial fetch, so every slot the initial fetch
+ * wrote — including the shell paths, even when the upgraded response is
+ * fully static (shell === full) — is upgraded; the spawned entries were
+ * already settled by the initial fetch, so every write is a detached upsert
+ * that replaces the fallback. On success the loop pings the task, so the
+ * task's *other* fallback segments get re-attempted. If every attempt is
+ * still a fallback (or fails), it gives up.
  *
- * A loop runs at most once per task, ever (the caller gates on
- * `fallbackRetryStatus === Empty`, set to `Pending` before this runs and never
- * reset to `Empty`). The sleep timer is never `clearTimeout`-ed, so the awaited
- * sleep always settles; the loop simply checks `isCanceled` after waking and
- * bails if the task was canceled in the meantime. On success the status becomes
- * `Fulfilled`; on any non-success exit (exhausted retries, fetch error, or
- * cancel) it becomes `Rejected`.
- */ async function retryUpgradeableFallbackPrefetch(task, route, routeKey, tree, segments, segmentCount, // The strategy the initial fetch wrote its payloads with; the upgraded
-// result is written through the same payload fork so the same cache slots
-// (including the shell paths) are upgraded.
+ * A loop runs at most once per task, ever (fetchAndWritePerSegmentPrefetchResponse
+ * gates on `fallbackRetryStatus === Empty`, set to `Pending` before this runs
+ * and never reset to `Empty`). The sleep timer is never `clearTimeout`-ed, so
+ * the awaited sleep always settles; the loop simply checks `isCanceled` after
+ * waking and bails if the task was canceled in the meantime. On success the
+ * status becomes `Fulfilled`; on any non-success exit (exhausted retries,
+ * fetch error, or cancel) it becomes `Rejected`.
+ */ async function retryUpgradeableFallbackPrefetch(task, route, routeKey, tree, spawnedEntries, // The strategy the initial fetch wrote its payloads with.
 fetchStrategy) {
     for(let attempt = 0; attempt < MAX_FALLBACK_RETRIES; attempt++){
         await new Promise((resolve)=>setTimeout(resolve, FALLBACK_RETRY_DELAY_MS));
         if (task.isCanceled) {
             break;
         }
-        let result;
+        let isUpgradeableISRFallback;
         try {
-            result = await fetchSegmentsOnCacheMissImpl(route, routeKey, tree);
+            isUpgradeableISRFallback = await fetchAndWritePerSegmentPrefetchResponse(task, route, routeKey, tree, spawnedEntries, fetchStrategy, // A response that is still a fallback shell is discarded rather than
+            // pointlessly re-written over the identical fallback content the
+            // initial fetch already cached.
+            true);
         } catch  {
             break;
         }
         if (task.isCanceled) {
             break;
         }
-        if (result === null) {
+        if (isUpgradeableISRFallback === null) {
             continue;
         }
-        if (result.serverResponse.isUpgradeableISRFallback) {
+        if (isUpgradeableISRFallback) {
             continue;
         }
-        // Success: the server returned the concrete (upgraded) version. Write it
-        // back through the same payload fork as the initial fetch, so every slot
-        // the initial fetch wrote — including the shell paths, even when the
-        // upgraded response is fully static (shell === full) — is upgraded. The
-        // bundle's entries were already settled by the initial fetch, so every
-        // write is a detached upsert that replaces the fallback. Mark the loop
-        // fulfilled and ping the task; its other fallback segments are now
-        // allowed to revalidate.
-        const { serverResponse, shellResponse, responseSize } = result;
-        const now = Date.now();
-        writeSegmentBundleResponseVariants(task.segmentCacheMap, serverResponse, shellResponse, responseSize, segments, segmentCount, now, fetchStrategy);
+        // Success: the server returned the concrete (upgraded) version, and the
+        // fetch wrote it into the cache. The task's other fallback segments are
+        // now allowed to revalidate.
         task.fallbackRetryStatus = _cachemap.EntryStatus.Fulfilled;
         (0, _scheduler.pingPrefetchTask)(task);
         return;
@@ -1932,17 +1647,27 @@ fetchStrategy) {
     // fetch error, or the task was canceled). It won't run again for this task.
     task.fallbackRetryStatus = _cachemap.EntryStatus.Rejected;
 }
-async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrategy, dynamicRequestTree, spawnedEntries) {
+async function fetchSegmentPrefetchesUsingRuntimeRequest(task, route, fetchStrategy, requestTree, spawnedEntries) {
     const key = task.key;
     const url = new URL(route.canonicalUrl, location.origin);
     const nextUrl = key.nextUrl;
-    if (spawnedEntries.size === 1 && spawnedEntries.has(route.metadata.requestKey)) {
-        // The only thing pending is the head. Instruct the server to
-        // skip over everything else.
-        // TODO: Lift this logic into the caller. Or perhaps unify the
-        // "request tree" and the spawnedEntries into the same type so they are
-        // guaranteed to always been in sync.
+    // When the request tree was derived from a predicted route entry, pass the
+    // node it was predicted from to the write path so the prediction can be
+    // disabled if the server's rendered tree diverges from it. For an entry
+    // the server resolved this is null: a divergence from it says nothing
+    // about route prediction, and its unfulfilled entries take the usual
+    // backoff.
+    let dynamicRequestTree;
+    let predictedFrom;
+    if (spawnedEntries.size === 1 && spawnedEntries.has(route.root.head.requestKey)) {
+        // Only the head is pending, so ask the server for metadata only: it skips
+        // the segments and renders just the head. The stub is not derived from
+        // the route entry, so divergence from it carries no signal.
         dynamicRequestTree = MetadataOnlyRequestTree;
+        predictedFrom = null;
+    } else {
+        dynamicRequestTree = requestTree;
+        predictedFrom = route.predictedFrom;
     }
     const headers = {
         [_approuterheaders.RSC_HEADER]: '1',
@@ -1981,7 +1706,7 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
         if (!response || !response.ok || !response.body) {
             // Server responded with an error, or with a miss. We should still cache
             // the response, but we can try again after 10 seconds.
-            rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
+            rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + REJECTION_BACKOFF_MS);
             return null;
         }
         const renderedSearch = (0, _routeparams.getRenderedSearch)(response);
@@ -1993,7 +1718,7 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
             // TODO: For now, since this is an edge case, we reject the prefetch, but
             // the proper way to handle this is to evict the stale route tree entry
             // then fill the cache with the new response.
-            rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
+            rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + REJECTION_BACKOFF_MS);
             return null;
         }
         // Track when the network connection closes. Only meaningful for Full
@@ -2001,14 +1726,14 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
         // paths, this is resolved immediately — see TODO in fetchRouteOnCacheMiss.
         const closed = (0, _promisewithresolvers.createPromiseWithResolvers)();
         let fulfilledEntries = null;
-        let prefetchStream;
         let bufferedResponseSize = null;
+        let serverDataPromise;
         if (fetchStrategy === _types.FetchStrategy.Full) {
             // Full prefetches are dynamic responses stored in the prefetch cache.
             // They don't carry vary params or other cache metadata, so there's no
             // need to buffer them. Use the incremental version to allow data to be
             // processed as it arrives.
-            prefetchStream = createIncrementalPrefetchResponseStream(response.body, closed.resolve, function onResponseSizeUpdate(totalBytesReceivedSoFar) {
+            const prefetchStream = createIncrementalPrefetchResponseStream(response.body, closed.resolve, function onResponseSizeUpdate(totalBytesReceivedSoFar) {
                 // When processing a dynamic response, we don't know how large each
                 // individual segment is, so approximate by assigning each segment
                 // the average of the total response size.
@@ -2022,145 +1747,39 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
                     (0, _cachemap.setSizeInCacheMap)(entry, averageSize);
                 }
             });
+            serverDataPromise = (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
+                allowPartialStream: true
+            });
         } else {
-            const { stream, size } = await createNonTaskyPrefetchResponseStream(response.body);
+            const buffer = await bufferPrefetchResponseBody(response.body);
             closed.resolve();
-            prefetchStream = stream;
-            bufferedResponseSize = size;
+            bufferedResponseSize = buffer.byteLength;
+            serverDataPromise = (0, _fetchserverresponse.decodeBufferedStage)(buffer, headers);
         }
         const [serverData, cacheData] = await Promise.all([
-            (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
-                allowPartialStream: true
-            }),
+            serverDataPromise,
             response.cacheData
         ]);
         const now = Date.now();
         const staleAt = await resolveStaleAt(now, serverData.s, response);
         const buildId = response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.b;
-        // Check if a reusable App Shell can be extracted from the main response.
-        let serverDataThatSatisfiesSpawnedEntries;
-        // The shell and full response have independent stale times. Track the
-        // staleAt that corresponds to whatever payload the spawned entries get
-        // filled with below.
-        let staleAtForSpawnedEntries = staleAt;
-        if (cacheData === null) {
-            // No shell can be extracted without cache metadata (only present when
-            // Cached Navigations is enabled). For routes without a distinct App Shell
-            // the extraction below is a no-op anyway (`resolveShellStageData` returns
-            // null), so this just short-circuits that case.
-            serverDataThatSatisfiesSpawnedEntries = serverData;
-        } else {
-            const shellStageData = await (0, _fetchserverresponse.resolveShellStageData)(cacheData, serverData, headers);
-            if (shellStageData === null) {
-                // No App Shell can be extracted. This usually means the entire response
-                // _is_ the App Shell. The other possibility (for now, until the feature
-                // is fully stabilized) is that App Shells are not yet enabled. Either
-                // way, there's nothing extra for us to do: fulfill the pending entries
-                // using the response from the server.
-                serverDataThatSatisfiesSpawnedEntries = serverData;
-            } else {
-                // Successfully extracted an App Shell that is a subset of the main
-                // response. Depending on the type of prefetch this is, we need to
-                // decide whether to fulfill the pending entries with the shell or with
-                // the entire response. In either scenario, we'll be inserting _both_
-                // versions of the response into the cache; the extra logic is only
-                // here so that we don't fulfill pending shell entries with something
-                // that's more concrete than what they expect.
-                // TODO: The only reason this matters is because during a navigation,
-                // if a segment is still pending, we render a promise that resolves to
-                // the eventual value of that segment. But that means we cannot
-                // eventually resolve that segment to something more concrete than what
-                // was already requested. Hence the extra logic here. A cleaner way to
-                // model this, though, is whenever we render a promise that resolves to
-                // the result of a pending entry, do one additional cache look-up right
-                // after the promise resolves, to ensure we never get a mismatching
-                // entry. Leaving this for a follow up.
-                // shellStageData is a fully-buffered stage decode, so read staleTime
-                // synchronously off the thenable status.
-                const shellStaleAt = readFulfilledStaleAt(now, shellStageData.s);
-                if (fetchStrategy === _types.FetchStrategy.RuntimeShell) {
-                    // This is a Shell prefetch, so the pending entries must be fulfilled
-                    // with the shell.
-                    serverDataThatSatisfiesSpawnedEntries = shellStageData;
-                    staleAtForSpawnedEntries = shellStaleAt;
-                    // Separately, we'll also cache the entire response, by upserting it
-                    // into the cache.
-                    writePrerenderResponseIntoCache(now, _types.FetchStrategy.PPR, serverData.f, buildId, serverData.h, serverData.r ?? null, staleAt, dynamicRequestTree, renderedSearch, cacheData.isResponsePartial, task.segmentCacheMap);
-                } else {
-                    // This is _not_ a Shell prefetch, so the pending entries should be
-                    // fulfilled with the entire response.
-                    serverDataThatSatisfiesSpawnedEntries = serverData;
-                    // Additionally, we might as well upsert the extracted Shell into the
-                    // cache, too.
-                    // `shellStageData` is only provided in cases where the shell is
-                    // different from the main response. If they are equivalent, this
-                    // branch is skipped. So it follows that any shell data reaches
-                    // this path must be partial -- it does not represent the entire
-                    // UI of the target page.
-                    const isShellStagePartial = true;
-                    writePrerenderResponseIntoCache(now, _types.FetchStrategy.RuntimeShell, shellStageData.f, buildId, shellStageData.h, shellStageData.r ?? null, shellStaleAt, dynamicRequestTree, renderedSearch, isShellStagePartial, task.segmentCacheMap);
-                }
-            }
-        }
-        // Read head vary params synchronously (unioning in the response-level root
-        // params). Individual segments carry their own iterables in
-        // CacheNodeSeedData; the root iterable is threaded down so each segment
-        // unions it too.
-        const rootVaryParamsIterable = serverDataThatSatisfiesSpawnedEntries.r ?? null;
-        const headVaryParams = (0, _varyparamsdecoding.readVaryParams)(serverDataThatSatisfiesSpawnedEntries.h, rootVaryParamsIterable);
-        // PPRRuntime and RuntimeShell prefetches are partial when the server
-        // marks the response as '~' (Partial). RuntimeShell additionally omits
-        // every dynamic suspense boundary below the App Shell, so its segments
-        // are always partial regardless of what the server marker says.
-        // Full/LoadingBoundary prefetches are always complete.
-        const isResponsePartial = fetchStrategy === _types.FetchStrategy.RuntimeShell || fetchStrategy === _types.FetchStrategy.PPRRuntime && (cacheData?.isResponsePartial ?? false);
-        const flightDatas = (0, _flightdatahelpers.normalizeFlightData)(serverDataThatSatisfiesSpawnedEntries.f);
-        if (typeof flightDatas === 'string') {
-            rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
-            return null;
-        }
-        const navigationSeed = (0, _navigation.convertServerPatchToFullTree)(now, dynamicRequestTree, flightDatas, renderedSearch, // Not needed for prefetch responses; pass unknown to use the default.
-        _bfcache.UnknownDynamicStaleTime);
-        if (navigationSeed.treeDivergedFromBase && // A head-only request uses the MetadataOnlyRequestTree stub rather than
-        // a tree derived from the route entry, so divergence from it carries
-        // no signal.
-        // TODO: This special case goes away once convertServerPatchToFullTree
-        // diffs against the base RouteTree (route.tree) instead of the
-        // request tree.
-        dynamicRequestTree !== MetadataOnlyRequestTree) {
-            // The server rendered a different route tree than the one we requested:
-            // the URL has a rewrite that behaves dynamically, so the params baked
-            // into the request are wrong and the server can never fulfill it. Mark
-            // the route entry — which doubles as the stored prediction pattern, so
-            // this also disables a bad prediction (see matchKnownRoute) that would
-            // otherwise be re-derived on every retry — and invalidate entries that
-            // were derived from it. This mirrors dispatchRetryDueToTreeMismatch on
-            // the navigation path. It can't loop: the refetched route entry is
-            // built from the server's response, so it only mismatches again if the
-            // rewrite's behavior changes again.
-            markRouteEntryAsDynamicRewrite(route);
-            invalidateRouteCacheEntries(key.nextUrl, task.treeAtTimeOfPrefetch);
-            // Reject with an immediate expiration instead of the usual backoff: the
-            // invalidation above triggers a re-prefetch, which per the above does
-            // not loop.
-            // TODO: Consider also bounding retries with a counter on the task
-            // object, so a prefetch that repeatedly fails to settle backs off
-            // regardless of the reason.
-            rejectSegmentEntriesIfStillPending(spawnedEntries, -1);
-            return null;
-        }
-        // Aside from writing the data into the cache, this function also returns
-        // the entries that were fulfilled, so we can streamingly update their sizes
-        // in the LRU as more data comes in.
-        fulfilledEntries = writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, rootVaryParamsIterable, staleAtForSpawnedEntries, navigationSeed, spawnedEntries, task.segmentCacheMap);
-        // For buffered responses, update LRU sizes now that we know which
-        // entries were fulfilled.
-        if (bufferedResponseSize !== null && fulfilledEntries !== null && fulfilledEntries.length > 0) {
-            const averageSize = bufferedResponseSize / fulfilledEntries.length;
-            for (const entry of fulfilledEntries){
-                (0, _cachemap.setSizeInCacheMap)(entry, averageSize);
-            }
-        }
+        // Extract the response's shell-stage payload, when it carries one. No
+        // shell can be extracted without cache metadata (only present when
+        // Cached Navigations is enabled); for responses without a distinct
+        // shell stage the extraction is a no-op anyway
+        // (`resolveShellStageResponse` returns null), so the null check just
+        // short-circuits that case.
+        const shellResponse = cacheData !== null ? await (0, _fetchserverresponse.resolveShellStageResponse)(cacheData, serverData, headers) : null;
+        // Runtime prefetch responses (PPRRuntime and RuntimeShell requests) are
+        // partial when the server marks the response as '~' (Partial).
+        // Full/LoadingBoundary prefetch responses are always complete.
+        const isFullResponsePartial = (fetchStrategy === _types.FetchStrategy.PPRRuntime || fetchStrategy === _types.FetchStrategy.RuntimeShell) && (cacheData?.isResponsePartial ?? false);
+        // Aside from writing the data into the cache, this also returns the
+        // entries that were fulfilled, so we can streamingly update their sizes
+        // in the LRU as more data comes in (Full responses, which stream).
+        fulfilledEntries = writeResponsePayloadsIntoCache(now, fetchStrategy, serverData, shellResponse, dynamicRequestTree, predictedFrom, // Navigation responses always include the param values in the tree, so
+        // there's no pathname to parse them from (nor a need to).
+        null, renderedSearch, buildId, staleAt, isFullResponsePartial, null, spawnedEntries, bufferedResponseSize, task.segmentCacheMap);
         // Return a promise that resolves when the network connection closes, so
         // the scheduler can track the number of concurrent network connections.
         return {
@@ -2168,143 +1787,349 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
             closed: closed.promise
         };
     } catch (error) {
-        if (process.env.__NEXT_USE_OFFLINE) {
-            const { checkOfflineError } = require('../offline');
-            if (checkOfflineError(error)) {
-                // Unlike navigations and server actions, prefetches don't await
-                // waitForConnection — they just reject the cache entry with an
-                // immediate expiration so it gets retried once the scheduler is
-                // re-pinged after connectivity is restored.
-                rejectSegmentEntriesIfStillPending(spawnedEntries, -1);
-                return null;
-            }
-        }
-        rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
+        rejectSegmentEntriesIfStillPending(spawnedEntries, getPrefetchErrorStaleAt(error));
         return null;
     }
 }
-function writeDynamicTreeResponseIntoCache(now, fetchStrategy, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, headVaryParams, rootVaryParamsIterable, originalPathname, originalSearch, nextUrl, // The spawning task's `PrefetchTask.segmentCacheMap`.
-map) {
-    const renderedSearch = (0, _routeparams.getRenderedSearch)(response);
-    const normalizedFlightDataResult = (0, _flightdatahelpers.normalizeFlightData)(serverData.f);
-    if (// A string result means navigating to this route will result in an
-    // MPA navigation.
-    typeof normalizedFlightDataResult === 'string' || normalizedFlightDataResult.length !== 1) {
-        rejectRouteCacheEntry(entry, now + 10 * 1000);
-        return;
-    }
-    const flightData = normalizedFlightDataResult[0];
-    if (!flightData.isRootRender) {
-        // Unexpected response format.
-        rejectRouteCacheEntry(entry, now + 10 * 1000);
-        return;
-    }
-    const flightRouterState = flightData.tree;
-    // If the response was postponed, segments may contain dynamic holes.
-    // The head has its own partiality flag (flightDataEntry.isHeadPartial)
-    // which is handled separately in writeDynamicRenderResponseIntoCache.
-    const isResponsePartial = response.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER) === '1';
-    // Convert the server-sent data into the RouteTree format used by the
-    // client cache.
-    //
-    // During this traversal, we accumulate additional data into this
-    // "accumulator" object.
-    const acc = {
-        metadataVaryPath: null,
-        treeDivergedFromBase: false
-    };
-    const routeTree = convertRootFlightRouterStateToRouteTree(flightRouterState, renderedSearch, acc);
-    const metadataVaryPath = acc.metadataVaryPath;
-    if (metadataVaryPath === null) {
-        rejectRouteCacheEntry(entry, now + 10 * 1000);
-        return;
-    }
-    (0, _optimisticroutes.discoverKnownRoute)(now, originalPathname, originalSearch, nextUrl, entry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, false // hasDynamicRewrite
-    );
-    // If the server sent segment data as part of the response, we should write
-    // it into the cache to prevent a second, redundant prefetch request.
-    // TODO: This is a leftover branch from before Client Segment Cache was
-    // enabled everywhere. Tree prefetches should never include segment data.  We
-    // can delete it. Leaving for a subsequent PR.
-    const navigationSeed = (0, _navigation.convertServerPatchToFullTree)(now, flightRouterState, normalizedFlightDataResult, renderedSearch, _bfcache.UnknownDynamicStaleTime);
-    const buildId = response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.b;
-    writeDynamicRenderResponseIntoCache(now, fetchStrategy, normalizedFlightDataResult, buildId, isResponsePartial, headVaryParams, rootVaryParamsIterable, getStaleAtFromHeader(now, response), navigationSeed, null, map);
-}
 function rejectSegmentEntriesIfStillPending(entries, staleAt) {
-    const fulfilledEntries = [];
     for (const entry of entries.values()){
         if (entry.status === _cachemap.EntryStatus.Pending) {
             rejectSegmentCacheEntry(entry, staleAt);
-        } else if (entry.status === _cachemap.EntryStatus.Fulfilled) {
-            fulfilledEntries.push(entry);
+        }
+    }
+}
+/**
+ * Writes a prefetch response's payloads into the cache: the full payload,
+ * plus its shell payload when the response carries one. This is the write
+ * orchestration shared by the prefetch response kinds — per-segment
+ * static responses (fetchAndWritePerSegmentPrefetchResponse) and
+ * live-render responses (fetchSegmentPrefetchesUsingRuntimeRequest, and the
+ * embedded runtime prefetch stream via writeRuntimePrefetchStreamIntoCache)
+ * — which differ in how they obtain their payloads but not in what must
+ * happen to them.
+ *
+ * Returns the entries the fulfilling payload's write produced content into
+ * (so the streaming caller can keep updating their LRU sizes as bytes
+ * arrive), or null if nothing entered the cache.
+ */ function writeResponsePayloadsIntoCache(now, // The strategy of the request that produced the response. Decides which
+// payload fulfills the spawned entries and their keying, and identifies
+// the response family: PPR/StaticShell are per-segment static responses,
+// everything else a live-render response.
+fetchStrategy, fullPayload, // The response's shell payload: null (the response carries no shell),
+// `fullPayload` itself (the shell IS the full response), or a distinct
+// stage decode truncated at the shell byte boundary.
+shellPayload, // The next five are threaded through to every write; see
+// writeServerResponseIntoCache for their meaning.
+baseTree, predictedFrom, renderedPathname, renderedSearch, buildId, // Response-level staleness of the full payload. The shell payload's own
+// staleness is read off the shell decode below (a shell payload is always
+// fully buffered).
+staleAt, // Whether anything in the full payload is not fully resolved (dynamic or runtime holes, anything suspended). Shell-tier
+// writes don't consume it: a shell payload is partial by construction.
+// (Per-segment payloads encode partiality per node and ignore the
+// response-level value entirely.)
+isFullResponsePartial, metadataVaryPath, // The pending entries this response fulfills. Null when the caller owns
+// none (the embedded runtime prefetch stream), in which case every write
+// is a detached upsert.
+spawnedEntries, // The response's size in bytes, distributed across the entries the
+// fulfilling payload's write produced; null when unknown (streamed Full
+// responses — the caller sizes those incrementally as bytes
+// arrive instead).
+responseByteLength, // The map the work that spawned this response's request is bound to. See
+// writeServerResponseIntoCache.
+map) {
+    let fulfilledEntries;
+    if (shellPayload === null || // `FetchStrategy.LoadingBoundary` is not used in Cache Components,
+    // and we only recover shells in Cache Components.
+    fetchStrategy === _types.FetchStrategy.LoadingBoundary) {
+        if (fetchStrategy === _types.FetchStrategy.StaticShell) {
+            // A static shell was requested but the response carries no shell (its
+            // shell byte offset read as 0 — a bug in Next.js itself — or the
+            // shell prefix couldn't be decoded). The full payload is still
+            // usable, so it's written detached at the concrete tier; the spawned
+            // entries are rejected so the task isn't stranded blocking on them.
+            // Note the scheduler does NOT fall back to a runtime request for
+            // rejected segments — it skips them outright (see the Rejected case
+            // in pingSegmentBundle in scheduler.ts), so these segments get no
+            // shell prefetch and no runtime substitute until the rejection's
+            // backoff expires.
+            writeServerResponseIntoCache(now, _types.FetchStrategy.PPR, fullPayload, baseTree, predictedFrom, renderedPathname, renderedSearch, buildId, staleAt, isFullResponsePartial, metadataVaryPath, null, null, map);
+            if (spawnedEntries !== null) {
+                rejectSegmentEntriesIfStillPending(spawnedEntries, now + REJECTION_BACKOFF_MS);
+            }
+            return null;
+        }
+        // This request either:
+        // - didn't allow recovering a shell (no staged rendering),
+        // - or was a (runtime) shell request (that was NOT served by a fully static prerender)
+        //   so we already have a shell without recovering anything.
+        // In either case, we don't have anything to consider other than the request itself,
+        // so the payload simply fulfills the spawned entries at the request's own keying.
+        fulfilledEntries = writeServerResponseIntoCache(now, fetchStrategy, fullPayload, baseTree, predictedFrom, renderedPathname, renderedSearch, buildId, staleAt, isFullResponsePartial, metadataVaryPath, spawnedEntries, null, map);
+    } else if (shellPayload === fullPayload) {
+        // The shell IS the full response (reference-equal — a page with nothing
+        // below its shell). One payload fulfills the spawned entries, recording
+        // the strategy that describes the CONTENT — the full payload's tier.
+        // The content tier also drives the entries' keying: content that isn't
+        // shell-grade is param-independent only on the server's vary-params
+        // evidence, so it must not be parked in the shell slot on the strength
+        // of the missing split alone (see the keying derivation in
+        // writeSegmentDataIntoCache).
+        let contentFetchStrategy;
+        switch(fetchStrategy){
+            case _types.FetchStrategy.StaticShell:
+                {
+                    // a StaticShell always uses a PPR-tier request, so we need to fulfill
+                    // the spawned shell entries at the PPR tier.
+                    contentFetchStrategy = _types.FetchStrategy.PPR;
+                    break;
+                }
+            case _types.FetchStrategy.RuntimeShell:
+                {
+                    // a runtime shell request is not normally rewindable, but fully static pages
+                    // the server will return a static prerender result, which *is* rewindable.
+                    contentFetchStrategy = _types.FetchStrategy.PPRRuntime;
+                    break;
+                }
+            case _types.FetchStrategy.PPR:
+            case _types.FetchStrategy.PPRRuntime:
+            case _types.FetchStrategy.Full:
+                {
+                    // No shell was requested, so we don't need to override the fetch strategy.
+                    contentFetchStrategy = null;
+                }
+        }
+        fulfilledEntries = writeServerResponseIntoCache(now, fetchStrategy, fullPayload, baseTree, predictedFrom, renderedPathname, renderedSearch, buildId, staleAt, isFullResponsePartial, metadataVaryPath, spawnedEntries, contentFetchStrategy, map);
+    } else {
+        // The shell is a strict prefix of the response. Write both payloads.
+        // The payload matching the tier the spawned entries were requested at
+        // fulfills them; the other is written detached (no owned entries —
+        // every write is an upsert). Fulfilling a spawned shell entry with the
+        // concrete payload would store content that doesn't match the entry's
+        // shell vary path — wrong for every later read at that key, and
+        // immediately observable during a navigation, where a pending entry can
+        // be rendered as a promise that resolves to its eventual value.
+        //
+        // The full payload is written first. The order is not observable: the
+        // two writes key at different tiers, upsert precedence between a full
+        // payload and its own shell payload is order-independent (the full
+        // payload always wins the comparison — a shell segment is never
+        // complete where its full counterpart is partial, see
+        // readFulfilledIsPartial), and fulfillment pings only enqueue scheduler
+        // work that runs after this synchronous block. Full-first is preferred
+        // so the shell write's precedence checks and shadow eviction compare
+        // against the fresh concrete entry rather than whatever stale entry
+        // preceded it.
+        let responseFetchStrategy;
+        let shellFetchStrategy;
+        switch(fetchStrategy){
+            case _types.FetchStrategy.StaticShell:
+            case _types.FetchStrategy.PPR:
+                {
+                    // Static request.
+                    // a StaticShell fetch strategy performs a request that returns
+                    // a PPR-tier response that can be rewound to a StaticShell response,
+                    // So we upgrade the full response's strategy to `PPR`.
+                    // (A static response's tier may be raised if we know that a static request
+                    // would satisfy a runtime request -- see `recordedFetchStrategy` in
+                    // `writeSegmentDataIntoCache`)
+                    responseFetchStrategy = _types.FetchStrategy.PPR;
+                    shellFetchStrategy = _types.FetchStrategy.StaticShell;
+                    break;
+                }
+            case _types.FetchStrategy.RuntimeShell:
+                {
+                    // A runtime shell request is normally not rewindable -- it only produces
+                    // the shell itself. However, if a page is fully static, a runtime shell
+                    // will return a static prerender, i.e. the static content with an embedded shell.
+                    // The page is static, so we can treat the content as runtime-complete.
+                    responseFetchStrategy = _types.FetchStrategy.PPRRuntime;
+                    shellFetchStrategy = _types.FetchStrategy.RuntimeShell;
+                    break;
+                }
+            case _types.FetchStrategy.PPRRuntime:
+                {
+                    // A runtime prefetch response can be rewound into a runtime shell.
+                    // (This may also be a fully static response, same as RuntimeShell above,
+                    // in which case we also know that the shell is equivalent to a runtime shell)
+                    responseFetchStrategy = _types.FetchStrategy.PPRRuntime;
+                    shellFetchStrategy = _types.FetchStrategy.RuntimeShell;
+                    break;
+                }
+            case _types.FetchStrategy.Full:
+                {
+                    // Navigation responses can be rewound into a *static* app shell.
+                    // On PPF routes they also contain a runtime prefetch stream which will give us
+                    // a runtime shell/prefetch, but that's handled separately from the main response.
+                    // (see `writeRuntimePrefetchStreamIntoCache`)
+                    responseFetchStrategy = _types.FetchStrategy.Full;
+                    shellFetchStrategy = _types.FetchStrategy.StaticShell;
+                    break;
+                }
+        }
+        // We have to fulfill the correct pending entries depending on what was requested:
+        // - If we originally needed a shell but and got more content, the spawned entries
+        //   should be fulfilled using the shell.
+        // - If we needed a speculative or full request but rewound it into a shell,
+        //   the spawned entries should be fulfilled using the full response.
+        const wasShellRequested = fetchStrategy === _types.FetchStrategy.StaticShell || fetchStrategy === _types.FetchStrategy.RuntimeShell;
+        const fullFulfilledEntries = writeServerResponseIntoCache(now, responseFetchStrategy, fullPayload, baseTree, predictedFrom, renderedPathname, renderedSearch, buildId, staleAt, isFullResponsePartial, metadataVaryPath, wasShellRequested ? null : spawnedEntries, null, map);
+        const shellFulfilledEntries = writeServerResponseIntoCache(now, shellFetchStrategy, shellPayload, baseTree, predictedFrom, renderedPathname, renderedSearch, buildId, // The shell payload carries its own staleness, independent of the
+        // full payload's. Shell decodes are fully buffered, so it's read
+        // synchronously; when absent (per-segment responses carry staleTime
+        // per node instead) this falls back to the same static stale time the
+        // per-segment writes use as their response-level fallback.
+        readFulfilledStaleAt(now, shellPayload.s), // A shell payload is a strict subset of the full response, so it does
+        // not represent the entire UI of the target page — it's partial
+        // by construction.
+        true, metadataVaryPath, wasShellRequested ? spawnedEntries : null, null, map);
+        fulfilledEntries = wasShellRequested ? shellFulfilledEntries : fullFulfilledEntries;
+    }
+    // Entries created by a detached write aren't sized: one wire response is
+    // only charged to the LRU once, to the entries it fulfilled.
+    if (responseByteLength !== null && fulfilledEntries !== null && fulfilledEntries.length > 0) {
+        const averageSize = responseByteLength / fulfilledEntries.length;
+        for (const entry of fulfilledEntries){
+            (0, _cachemap.setSizeInCacheMap)(entry, averageSize);
         }
     }
     return fulfilledEntries;
 }
-function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, rootVaryParamsIterable, staleAt, navigationSeed, spawnedEntries, // The map the work that spawned this response's request is bound to: the
+/**
+ * Writes a decoded server response into the segment cache: decodes the
+ * response's transport tree into a RouteTree — overlaid on `baseTree` when
+ * the response is an overlay over existing client state, root-anchored when
+ * it covers its own spine (per-segment prefetch payloads) — then writes
+ * every rendered segment, plus the head, into the cache. Fulfills the
+ * entries in `spawnedEntries` that the response covers; rejects the rest, so
+ * a task blocked on them isn't stranded. Returns the entries the write
+ * produced content into — fulfilled spawned entries plus installed detached
+ * upserts — for LRU size accounting, or null if nothing entered the cache.
+ *
+ * Serves every response kind: live-render prefetch responses (runtime
+ * prefetches, and Full/LoadingBoundary prefetches in the
+ * non-Partial-Prefetching regime), prerender stage decodes (shell-stage
+ * extraction, cached navigations, the initial payload), embedded runtime
+ * prefetch streams, and the payloads of per-segment prefetch responses.
+ */ function writeServerResponseIntoCache(now, fetchStrategy, // The decoded response payload to write. For a per-segment prefetch
+// response this is one of its payloads: the full response, or the
+// truncated shell decode.
+response, // The base router state the response overlays. Null when the response's
+// tree is root-anchored (per-segment prefetch payloads).
+baseTree, // Non-null when `baseTree` was predicted: the node in the known route tree
+// whose pattern it was predicted from (see matchKnownRoute). The
+// prediction assumes the URL's rewrite (if any) behaves statically; if the
+// server's rendered tree diverges from the base, that prediction failed —
+// the rewrite behaves dynamically, so the params baked into the request
+// are wrong. The node is marked so the shape is never predicted again, and
+// the entries that could not be fulfilled are rejected with immediate
+// expiration so the task retries right away — against the server-resolved
+// route this time. The response data is still written into the cache: it's
+// real data keyed by what the server actually rendered, useful regardless
+// of whether the prediction matched.
+predictedFrom, // The pathname the response was rendered for, used to resolve dynamic
+// segments the server sent without a param value (`k: null`). Null for
+// responses that always carry concrete values (navigation responses).
+renderedPathname, renderedSearch, buildId, // Response-level staleness; a segment (or the head) with its own
+// staleTime overrides it.
+staleAt, // Whether anything in the response is not fully resolved: dynamic holes, runtime holes, anything suspended.
+// Threaded into the decode, where each segment's (and the head's)
+// partiality is resolved from it and the wire form (see
+// createNavigationSeed). Per-segment prefetch responses encode
+// partiality per node, so their writes pass the conservative value
+// (true), which is never read.
+isResponsePartial, // Where to key the head; see createNavigationSeed.
+metadataVaryPath, spawnedEntries, // The strategy tier describing the CONTENT of the payload being written,
+// when it differs from `fetchStrategy` (which drives matching and
+// keying); null when they agree. See the param docs on
+// writeSegmentDataIntoCache.
+contentFetchStrategy, // The map the work that spawned this response's request is bound to: the
 // spawning task's `PrefetchTask.segmentCacheMap` for prefetches, the
 // navigation's map for navigation-side writes. Binding the write to the
 // requesting work means a response that lands after a testing-lock scope
 // boundary still writes into the map its entries live in.
 map) {
+    // Which layer owns the buildId check differs by flow. The route and
+    // segment fetch layers check it themselves (see fetchRouteOnCacheMiss and
+    // fetchAndWritePerSegmentPrefetchResponse) because they need the early-out
+    // before side effects this layer can't undo — starting the fallback-retry
+    // loop, writing the second (shell) payload — and then pass no buildId
+    // here. This check owns it for the flows that don't: live-render prefetch
+    // responses and navigation static-stage writes, which pass their
+    // buildId through.
     if (buildId && buildId !== (0, _navigationbuildid.getNavigationBuildId)()) {
         // The server build does not match the client. Treat as a 404. During
         // an actual navigation, the router will trigger an MPA navigation.
         if (spawnedEntries !== null) {
-            rejectSegmentEntriesIfStillPending(spawnedEntries, now + 10 * 1000);
+            rejectSegmentEntriesIfStillPending(spawnedEntries, now + REJECTION_BACKOFF_MS);
         }
         return null;
     }
-    const routeTree = navigationSeed.routeTree;
-    const metadataTree = navigationSeed.metadataVaryPath !== null ? createMetadataRouteTree(navigationSeed.metadataVaryPath) : null;
-    for (const flightDataEntry of flightDatas){
-        const seedData = flightDataEntry.seedData;
-        if (seedData !== null) {
-            // 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 response.
-            //
-            // segmentPath represents the parent path of subtree. It's a repeating
-            // pattern of parallel route key and segment:
-            //
-            //   [string, Segment, string, Segment, string, Segment, ...]
-            const segmentPath = flightDataEntry.segmentPath;
-            let tree = routeTree;
-            for(let i = 0; i < segmentPath.length; i += 2){
-                const parallelRouteKey = segmentPath[i];
-                const childTree = tree?.slots?.get(parallelRouteKey);
-                if (childTree !== undefined) {
-                    tree = childTree;
-                } else {
-                    if (spawnedEntries !== null) {
-                        rejectSegmentEntriesIfStillPending(spawnedEntries, now + 10 * 1000);
-                    }
-                    return null;
-                }
-            }
-            writeSeedDataIntoCache(now, // A response write is bound to the map its entries live in (the
-            // spawning task's `PrefetchTask.segmentCacheMap`).
-            map, fetchStrategy, tree, staleAt, seedData, isResponsePartial, rootVaryParamsIterable, spawnedEntries);
+    const transportData = response.t;
+    if (transportData === undefined) {
+        // The response carries no tree. Settle anything we own so a task blocked
+        // on it isn't stranded.
+        if (spawnedEntries !== null) {
+            rejectSegmentEntriesIfStillPending(spawnedEntries, now + REJECTION_BACKOFF_MS);
         }
-        const head = flightDataEntry.head;
-        if (head !== null && metadataTree !== null) {
-            // When Cache Components is enabled, the server's `isHeadPartial` flag
-            // (isPossiblyPartialHead in app-render.tsx) is unreliable: it's computed
-            // before the head is serialized, so it's conservatively `true` for every
-            // statically-generated PPR page — even pages whose head is actually
-            // complete — and it's `false` for runtime/dynamic responses whose head is
-            // actually partial (e.g. a route with an async `generateMetadata`). So we
-            // ignore it and derive the head's partiality from whether the response
-            // itself was partial, exactly as we do for segments (see
-            // `writeSeedDataIntoCache`). A non-partial response carries a complete
-            // head; a partial (postponed) one does not.
-            //
-            // Without Cache Components, the server sends the correct isHeadPartial.
-            const isHeadPartial = process.env.__NEXT_CACHE_COMPONENTS ? isResponsePartial : flightDataEntry.isHeadPartial;
-            fulfillEntrySpawnedByRuntimePrefetch(now, // A response write is bound to the map its entries live in (the
-            // spawning task's `PrefetchTask.segmentCacheMap`).
-            map, fetchStrategy, head, isHeadPartial, staleAt, // For head entries, use the head-specific vary params passed as
-            // parameter.
-            headVaryParams, metadataTree, spawnedEntries);
+        return null;
+    }
+    const navigationSeed = (0, _decodeserverresponse.createNavigationSeed)(now, baseTree, transportData, // Root params are emitted once at the top level of the response; the
+    // decode unions them into the head's and each segment's own set. For
+    // per-segment prefetch responses this must be read from the payload
+    // being written: a truncated shell decode rewinds the response's
+    // late-resolving values to the shell stage.
+    response.r ?? null, // The decode resolves each segment's partiality from this and the wire:
+    // boolean-form nodes resolve to this response-level value; staged
+    // (promise-form) nodes encode partiality per node and ignore it.
+    isResponsePartial, renderedPathname, renderedSearch, metadataVaryPath, // Only navigations consume the seed's dynamicStaleAt; cache writes pass
+    // unknown to use the default.
+    _bfcache.UnknownDynamicStaleTime);
+    const requiresRuntimeCompleteness = (navigationSeed.root.tree.prefetchHints & _approutertypes.PrefetchHint.SubtreeHasPartialPrefetching) !== 0;
+    const treeDivergedFromPrediction = predictedFrom !== null && navigationSeed.treeDivergedFromBase;
+    if (treeDivergedFromPrediction) {
+        predictedFrom.hasDynamicRewrite = true;
+    }
+    // Only static (per-segment) responses can be ISR fallbacks (`f`). A
+    // present `u` means the response carries a stage-scoped runtime-data
+    // verdict — per-segment prefetch responses always emit one, and so does
+    // any prerendered page payload, which embeds the prerender's runtime-data
+    // probe; live renders emit none. A response without one decodes to a null
+    // verdict, and its entries record their request's own strategy unrefined
+    // (see writeSegmentDataIntoCache).
+    // `u` is deliberately read here, off THIS decode's thenable status, rather
+    // than normalized where the response is fetched: the read scopes it to the
+    // payload being written — a truncated shell decode reads a post-shell
+    // runtime access as pending, i.e. `false`, because the shell variant
+    // itself doesn't need that data. The read is load-bearing in one direction
+    // only: a false `true` costs a wasted runtime request; a false `false`
+    // would record too high a tier and skip a runtime request that had more
+    // content. A rejected row (an aborted prerender errors rows that were
+    // still pending at the abort) must therefore read as `true`, matching the
+    // server's own read of the page payload's flag (see the `u` read in
+    // collect-segment-data.tsx).
+    const isUpgradeableISRFallback = response.f === true;
+    const responseNeedsRuntimeRequest = response.u !== undefined ? (0, _rsctransport.readFulfilledValue)(response.u, false, /* rejectedValue */ true) : null;
+    const routeTree = navigationSeed.root.tree;
+    // The route tree carries the render output of every segment the response
+    // included, so a single traversal from the root writes all of it into
+    // the cache.
+    const writtenEntries = [];
+    writeTreeDataIntoCache(now, map, fetchStrategy, routeTree, staleAt, spawnedEntries, contentFetchStrategy, isUpgradeableISRFallback, requiresRuntimeCompleteness, responseNeedsRuntimeRequest, writtenEntries);
+    const metadataTree = navigationSeed.root.head;
+    const headData = metadataTree.data;
+    if (headData !== null && headData.rsc !== null) {
+        // The head follows the same stale-time rules as a segment.
+        const headStaleAt = headData.staleTimeSeconds !== null ? now + getStaleTimeMs(headData.staleTimeSeconds) : staleAt;
+        // A head has no loading boundary. Match the scheduler, which spawns
+        // LoadingBoundary head entries using the concrete Full strategy (see the
+        // head's runtime fetch in pingRootRouteTree).
+        const headFetchStrategy = fetchStrategy === _types.FetchStrategy.LoadingBoundary ? _types.FetchStrategy.Full : fetchStrategy;
+        const writtenHeadEntry = writeSegmentDataIntoCache(now, map, headFetchStrategy, headData.rsc, // The decode already resolved the head's partiality from the wire
+        // form and the response-level value — see the head read in
+        // createNavigationSeed.
+        headData.isPartial, headStaleAt, headData.varyParams, metadataTree, spawnedEntries, contentFetchStrategy, isUpgradeableISRFallback, requiresRuntimeCompleteness, responseNeedsRuntimeRequest);
+        if (writtenHeadEntry !== null) {
+            writtenEntries.push(writtenHeadEntry);
         }
     }
     // Any entry that's still pending was intentionally not rendered by the
@@ -2316,37 +2141,130 @@ map) {
     // somehow that the reason for the rejection is because of a non-PPR prefetch.
     // That way a per-segment prefetch knows to disregard the rejection.
     if (spawnedEntries !== null) {
-        const fulfilledEntries = rejectSegmentEntriesIfStillPending(spawnedEntries, now + 10 * 1000);
-        return fulfilledEntries;
+        rejectSegmentEntriesIfStillPending(spawnedEntries, // When the response diverged from the prediction, the leftover entries
+        // can never be fulfilled — their keys were derived from the wrong
+        // tree. Reject with an immediate expiration instead of the usual
+        // backoff so the task retries right away. The prediction was disabled
+        // above, so the retry resolves the route on the server instead of
+        // predicting it again.
+        treeDivergedFromPrediction ? -1 : now + REJECTION_BACKOFF_MS);
+    }
+    return writtenEntries.length > 0 ? writtenEntries : null;
+}
+function writeTreeDataIntoCache(now, map, fetchStrategy, tree, staleAt, spawnedEntries, contentFetchStrategy, isUpgradeableISRFallback, requiresRuntimeCompleteness, responseNeedsRuntimeRequest, // Accumulates the entries the walk wrote content into (fulfilled spawned
+// entries and installed detached upserts), for LRU size accounting.
+writtenEntries) {
+    // Writes the render output embedded in the route tree into the
+    // prefetch cache.
+    const data = tree.data;
+    if (data !== null && data.rsc !== null) {
+        // A segment carries its own staleTime only in per-segment prefetch
+        // responses; everywhere else the response-level staleness governs.
+        const entryStaleAt = data.staleTimeSeconds !== null ? now + getStaleTimeMs(data.staleTimeSeconds) : staleAt;
+        const writtenEntry = writeSegmentDataIntoCache(now, map, fetchStrategy, data.rsc, data.isPartial, entryStaleAt, data.varyParams, tree, spawnedEntries, contentFetchStrategy, isUpgradeableISRFallback, requiresRuntimeCompleteness, responseNeedsRuntimeRequest);
+        if (writtenEntry !== null) {
+            writtenEntries.push(writtenEntry);
+        }
+    } else {
+    // Either the response carried no information for this segment (no data
+    // object — e.g. the identity spine of a per-segment prefetch response,
+    // or a slot reused from the base tree), or it acknowledged the position
+    // without rendering it (a data object with a null rsc — an intermediate
+    // position on the path to a rendered subtree). Nothing to write either
+    // way, but the children may have output, so keep descending.
     }
-    return null;
-}
-function writeSeedDataIntoCache(now, map, fetchStrategy, tree, staleAt, seedData, isResponsePartial, rootVaryParamsIterable, entriesOwnedByCurrentTask) {
-    // This function is used to write the result of a runtime server request
-    // (CacheNodeSeedData) into the prefetch cache.
-    const rsc = seedData[0];
-    const isPartial = rsc === null || isResponsePartial;
-    // Each segment carries its own vary params iterable in the seed data, which
-    // drains to the set of params the segment accessed during render. A null
-    // iterable means tracking was not enabled (not a prerender). readVaryParams
-    // unions in the response-level root params.
-    const varyParams = (0, _varyparamsdecoding.readVaryParams)(seedData[4], rootVaryParamsIterable);
-    fulfillEntrySpawnedByRuntimePrefetch(now, // A response write is bound to the map its entries live in (the spawning
-    // task's `PrefetchTask.segmentCacheMap`).
-    map, fetchStrategy, rsc, isPartial, staleAt, varyParams, tree, entriesOwnedByCurrentTask);
     // Recursively write the child data into the cache.
     const slots = tree.slots;
     if (slots !== null) {
-        const seedDataChildren = seedData[1];
-        for (const [parallelRouteKey, childTree] of slots){
-            const childSeedData = seedDataChildren[parallelRouteKey];
-            if (childSeedData !== null && childSeedData !== undefined) {
-                writeSeedDataIntoCache(now, map, fetchStrategy, childTree, staleAt, childSeedData, isResponsePartial, rootVaryParamsIterable, entriesOwnedByCurrentTask);
-            }
+        for (const childTree of slots.values()){
+            writeTreeDataIntoCache(now, map, fetchStrategy, childTree, staleAt, spawnedEntries, contentFetchStrategy, isUpgradeableISRFallback, requiresRuntimeCompleteness, responseNeedsRuntimeRequest, writtenEntries);
         }
     }
 }
-function fulfillEntrySpawnedByRuntimePrefetch(now, map, fetchStrategy, rsc, isPartial, staleAt, segmentVaryParams, tree, entriesOwnedByCurrentTask) {
+/**
+ * Writes one segment's render output into the cache: fulfills the entry at
+ * the same tree position if this task owns one, otherwise creates one (or
+ * upserts a detached one). Shared by every response kind; responses that
+ * carry a runtime-data verdict (per-segment prefetch responses and
+ * prerendered page payloads) additionally refine the tier the entry
+ * records — see `recordedFetchStrategy` below.
+ *
+ * Returns the entry this write produced content into — the fulfilled spawned
+ * entry, or the detached entry the upsert installed — so the caller can
+ * charge the response's size to it. Null when nothing entered the cache (the
+ * upsert declined a detached candidate).
+ */ function writeSegmentDataIntoCache(now, map, fetchStrategy, rsc, isPartial, staleAt, segmentVaryParams, tree, spawnedEntries, // The strategy tier describing the CONTENT of the payload this write came
+// from, when it differs from the write's own `fetchStrategy` (which
+// drives matching and keying); null when they agree. It differs only for
+// the coincident-shell case: a write that fulfills shell-keyed entries
+// with a payload that IS the full response passes the full payload's tier
+// — see writeResponsePayloadsIntoCache.
+contentFetchStrategy, // Whether the response is an upgradeable fallback shell. Always false for
+// live-render responses — they are never ISR fallbacks.
+isUpgradeableISRFallback, // The response's runtime-data verdict: whether the render that produced
+// this payload accessed runtime data (page-global; combined with the
+// segment's own `isPartial` to decide the tier the entry records below).
+// Null when the response carries no verdict (`u`) — live renders emit
+// none; per-segment prefetch responses and prerendered page payloads
+// (including the truncated initial payload) do — in which case the entry
+// records the payload's tier unrefined.
+requiresRuntimeCompleteness, responseNeedsRuntimeRequest) {
+    // The strategy tier recorded on the entry — the tier of the content that
+    // actually satisfied it, which spans both axes: shell-vs-concrete AND
+    // static-vs-runtime. The payload's content tier (`fetchStrategy`, unless
+    // the caller passed a distinct `contentFetchStrategy`), refined by the
+    // response's runtime-data verdict when it carries one:
+    //
+    // A runtime prefetch can only provide more content than this entry if the
+    // render accessed runtime data AND this particular segment has holes — a
+    // fully static segment gains nothing from a runtime request no matter
+    // what the page accessed. When this payload fully satisfied the segment —
+    // no runtime request needed — the content is as complete as a RUNTIME
+    // response of the same variant would have been, so it records that
+    // runtime tier. That's what lets the scheduler decide "would a runtime
+    // request return more?" by comparing tiers alone, with no separate signal
+    // to consult. Otherwise the content is only as complete as the static
+    // tier it was requested at, so a follow-up runtime request can still
+    // supersede it.
+    let recordedFetchStrategy;
+    if (responseNeedsRuntimeRequest === null) {
+        // The response carries no verdict — a live render's, or the synthesized
+        // initial-payload subset's (see create-initial-router-state): record
+        // the payload's tier as-is. A verdict is honored wherever it appears:
+        // prerendered page payloads carry one too (the prerender's runtime-data
+        // probe), and refining on it is correct — a prerendered response whose
+        // verdict is `false` is genuinely runtime-complete content.
+        recordedFetchStrategy = contentFetchStrategy ?? fetchStrategy;
+    } else if (responseNeedsRuntimeRequest && isPartial) {
+        // A runtime request would provide more than this payload, so no runtime
+        // tier is recorded — but the entry must still honor the payload's
+        // CONTENT grade. In the coincident-shell case the payload that satisfied
+        // a shell-keyed entry IS the full response, whose content grades at the
+        // concrete static tier (`contentFetchStrategy`, PPR — the verdict only
+        // rides static-family responses, so no higher grade can appear here).
+        // The verdict is consistent with that grade: it says the runtime tiers
+        // would provide more, which they would over PPR just as over the shell
+        // tier.
+        recordedFetchStrategy = contentFetchStrategy ?? fetchStrategy;
+    } else {
+        const payloadFetchStrategy = contentFetchStrategy ?? fetchStrategy;
+        if (requiresRuntimeCompleteness) {
+            // The verdict says this payload does not need a runtime request.
+            // If we requested it at a static tier, raise the recorded tier up to the
+            // runtime tier of the same variant.
+            // This also makes the verdict a noop for Full payloads, which matters because
+            // the Full flow decodes incrementally, and synchronously reading `response.u`
+            // is only sound for a buffered payload.
+            recordedFetchStrategy = payloadFetchStrategy === _types.FetchStrategy.StaticShell ? _types.FetchStrategy.RuntimeShell : payloadFetchStrategy === _types.FetchStrategy.PPR ? _types.FetchStrategy.PPRRuntime : payloadFetchStrategy;
+        } else {
+            // Only upgrade static segments to their runtime equivalents if the route
+            // can use runtime requests. Otherwise, when re-using a shell segment across
+            // params, `pingSegmentBundle` for a PPR strategy would see a `ShellRuntime`
+            // shell entry and incorrectly decide that a new PPR request would not
+            // provide more content.
+            recordedFetchStrategy = payloadFetchStrategy;
+        }
+    }
     // Decide whether to re-key the entry under a more generic vary path based on
     // which params the segment actually depends on.
     //
@@ -2358,89 +2276,143 @@ function fulfillEntrySpawnedByRuntimePrefetch(now, map, fetchStrategy, rsc, isPa
     // untrustworthy set could replace concrete params with Fallback and let
     // unrelated URLs read each other's content from the cache.
     //
-    // For RuntimeShell prefetches, always re-key to the precomputed shell vary
-    // path. A shell entry is spawned at a concrete param path but is reusable
-    // across all of them; tree.shellVaryPath (root-param values kept, every other
-    // param replaced with Fallback) is exactly the path that shell reads look it
-    // up under.
+    // Key the entry by which params the server said this segment depends on
+    // (judged by the payload's CONTENT: contentFetchStrategy differs from
+    // fetchStrategy exactly when a shell request's response turned out to
+    // carry more — the coincident case). Reusing one copy across param values
+    // is the point of the shell, but it requires knowing the content doesn't
+    // depend on those params, and the server's report is the direct evidence
+    // of that.
+    //
+    // Without that report, assume every param varies — a response without a
+    // shell/full split is also what a page fully prerendered at concrete
+    // params looks like, and keying that at the shell path would serve one
+    // slug's content to every sibling. The exception is a shell variant,
+    // which reduces param-dependent content to param fallbacks, so it really
+    // is good for any value of them (its request path below IS the shell
+    // vary path).
+    const payloadStrategy = contentFetchStrategy ?? fetchStrategy;
     let fulfilledVaryPath = null;
-    if (process.env.__NEXT_VARY_PARAMS) {
-        if (fetchStrategy === _types.FetchStrategy.RuntimeShell) {
-            fulfilledVaryPath = tree.shellVaryPath;
-        } else if (fetchStrategy !== _types.FetchStrategy.Full && segmentVaryParams !== null) {
-            fulfilledVaryPath = (0, _varypath.getFulfilledSegmentVaryPath)(tree.varyPath, segmentVaryParams);
+    // The dependency source the entry records, so a navigation that renders
+    // its content can tell which params that content read. It is the same
+    // evidence the key derivation below trusts, under the same condition, with
+    // the same correction; otherwise null, and consumers assume every param.
+    let recordedVaryParams = null;
+    if (process.env.__NEXT_VARY_PARAMS && payloadStrategy !== _types.FetchStrategy.Full && segmentVaryParams !== null) {
+        // Read the reported set now, when the key is chosen. The payload is fully
+        // buffered by the time it's written, so the source has settled; a read of
+        // null means the report is unavailable and every param varies.
+        let varyParams = (0, _varyparamsdecoding.readVaryParams)(segmentVaryParams);
+        if (varyParams !== null) {
+            if (payloadStrategy === _types.FetchStrategy.RuntimeShell && varyParams.has(_varyparamsdecoding.SEARCH_PARAMS_VARY_ID)) {
+                // SPECIAL CASE: for a RuntimeShell payload, the search params entry
+                // is dropped from the server's vary evidence before deriving the
+                // key, so the search component of the resulting path is marked as
+                // the fallback. This exists ONLY because of a known compromise in
+                // how the server reports search params: accessing `searchParams`
+                // records a dependency on them at access time, even when the render
+                // suspends on that access and cuts the content at the param
+                // fallback. A shell render's page and head segments therefore report
+                // the search params while the emitted bytes contain no
+                // search-dependent content.
+                // Trusting that report would key shell-grade content at a concrete
+                // search value, where shell-restricted reads (which generalize every
+                // non-root param — see getShellSegmentVaryPath) can never find it. A
+                // RuntimeShell payload's search-dependent content is reduced to
+                // fallbacks by construction, so its key must not vary on search
+                // regardless of the over-reported evidence. Every other component of
+                // the evidence is still honored as-is.
+                //
+                // Nothing else should rely on this branch; for every other payload
+                // grade — and every other param — the server's evidence
+                // is authoritative.
+                //
+                // TODO: Reconsider special-casing this on the server instead: don't
+                // report a param access that never resolved past the fallback cut in
+                // the emitted stage. A shell payload's evidence would then be
+                // accurate, and this branch could be deleted.
+                varyParams = new Set(varyParams);
+                varyParams.delete(_varyparamsdecoding.SEARCH_PARAMS_VARY_ID);
+                recordedVaryParams = (0, _varyparamsdecoding.createVaryParams)(varyParams);
+            } else {
+                recordedVaryParams = segmentVaryParams;
+            }
+            fulfilledVaryPath = (0, _varypath.getFulfilledSegmentVaryPath)(tree.varyPath, varyParams);
         }
     }
+    // The canonical path to (re-)key the entry at. When the derivation above
+    // produced a path, use that; otherwise fall back to the payload's own
+    // keying (this is load-bearing for entries spawned as revalidations:
+    // without the re-key they'd stay in their Revalidation slot forever,
+    // invisible to canonical reads, and the partial entry that prompted the
+    // revalidation would keep serving navigations). Full responses are
+    // excluded, matching the varyParams re-key: they're spawned as canonical
+    // entries at their final path, and their vary tracking can't be trusted
+    // for re-keying (see the fulfilledVaryPath derivation above).
+    const canonicalVaryPath = fulfilledVaryPath !== null ? fulfilledVaryPath : payloadStrategy !== _types.FetchStrategy.Full ? (0, _varypath.getSegmentVaryPathForRequest)(payloadStrategy, tree) : null;
     // We should only write into cache entries that are owned by us. Or create
     // a new one and write into that. We must never write over an entry that was
     // created by a different task, because that causes data races.
-    const ownedEntry = entriesOwnedByCurrentTask !== null ? entriesOwnedByCurrentTask.get(tree.requestKey) : undefined;
-    if (ownedEntry !== undefined) {
-        const fulfilledEntry = fulfillSegmentCacheEntry(ownedEntry, rsc, staleAt, isPartial, // Dynamic-request (Full/Runtime) responses are not ISR fallbacks.
-        false, fetchStrategy);
-        // Re-key the entry at its canonical path. When `varyParams` produced a
-        // generalized path above, use that; otherwise fall back to the request's
-        // own keying (this is load-bearing for entries spawned as revalidations:
-        // without the re-key they'd stay in their Revalidation slot forever,
-        // invisible to canonical reads, and the partial entry that prompted the
-        // revalidation would keep serving navigations). Full responses are
-        // excluded, matching the varyParams re-key: they're spawned as canonical
-        // entries at their final path, and their vary tracking can't be trusted
-        // for re-keying (see the fulfilledVaryPath derivation above).
-        const canonicalVaryPath = fulfilledVaryPath !== null ? fulfilledVaryPath : fetchStrategy !== _types.FetchStrategy.Full ? (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree) : null;
-        if (canonicalVaryPath !== null) {
-            const isRevalidation = false;
-            (0, _cachemap.setInCacheMap)(map, canonicalVaryPath, fulfilledEntry, isRevalidation);
-            // The re-key moved the entry to a more generic path (and, for a spawned
-            // revalidation, vacated its Revalidation slot). A stale settled entry
-            // at a more specific path — e.g. the partial entry that prompted the
-            // revalidation — would shadow every read at the concrete lookup path,
-            // causing the scheduler to keep re-reading the stale entry and respawn
-            // the revalidation forever. Evict it so the fulfilled entry is
-            // reachable. See evictShadowingSegmentEntries.
-            evictShadowingSegmentEntries(now, map, tree.varyPath, fulfilledEntry);
-        }
+    //
+    // The status check matters for the fallback-retry loop, which re-writes a
+    // response over entries the initial fetch already settled: those writes
+    // must fall through to the detached path below.
+    const ownedEntry = spawnedEntries !== null ? spawnedEntries.get(tree.requestKey) : undefined;
+    const isOwned = ownedEntry !== undefined && ownedEntry.status === _cachemap.EntryStatus.Pending;
+    let fulfilledEntry;
+    let insertVaryPath;
+    if (isOwned) {
+        // We own this entry — fulfill it directly.
+        fulfilledEntry = fulfillSegmentCacheEntry(ownedEntry, rsc, staleAt, isPartial, recordedVaryParams, isUpgradeableISRFallback, recordedFetchStrategy);
+        // Re-key the fulfilled entry at its canonical path. Owned Full entries
+        // are the exception (canonicalVaryPath is null): they were spawned as
+        // canonical entries at their final path, so no re-key happens.
+        insertVaryPath = canonicalVaryPath;
     } else {
-        // There's no matching entry. Attempt to create a new one.
-        let possiblyNewEntry = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, tree.varyPath, false, false);
-        if (possiblyNewEntry === null) {
-            possiblyNewEntry = insertEmptySegmentCacheEntry(now, map, fetchStrategy, tree);
-        }
-        if (possiblyNewEntry.status === _cachemap.EntryStatus.Empty) {
-            // Confirmed this is a new entry. We can fulfill it.
-            const newEntry = possiblyNewEntry;
-            const fulfilledEntry = fulfillSegmentCacheEntry(upgradeToPendingSegment(newEntry, fetchStrategy), rsc, staleAt, isPartial, // Dynamic-request (Full/Runtime) responses are not ISR fallbacks.
-            false, fetchStrategy);
-            if (fulfilledVaryPath !== null) {
-                const isRevalidation = false;
-                (0, _cachemap.setInCacheMap)(map, fulfilledVaryPath, fulfilledEntry, isRevalidation);
-                // Same as the owned-entry re-key above. Usually the entry really is
-                // new — the read a moment ago returned nothing at the concrete lookup
-                // path, so nothing can shadow it and this is a no-op — but this
-                // branch also claims a pre-existing Empty entry, and re-keying that
-                // away can expose a stale settled entry at an intermediate path.
-                evictShadowingSegmentEntries(now, map, tree.varyPath, fulfilledEntry);
-            }
-        } else {
-            // There was already an entry in the cache. But we may be able to
-            // replace it with the new one from the server.
-            const newEntry = fulfillSegmentCacheEntry(upgradeToPendingSegment(createDetachedSegmentCacheEntry(now), fetchStrategy), rsc, staleAt, isPartial, // Dynamic-request (Full/Runtime) responses are not ISR fallbacks.
-            false, fetchStrategy);
-            const varyPath = fulfilledVaryPath !== null ? fulfilledVaryPath : (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
-            // Pass the concrete lookup path so that if the entry was re-keyed to
-            // a more generic path, any stale settled entry at a more specific path
-            // that would shadow it is evicted (the upsert handles this; the other
-            // branches above call evictShadowingSegmentEntries themselves).
-            upsertSegmentEntry(now, map, varyPath, newEntry, tree.varyPath);
+        // We don't own an entry for this segment. Create a detached one and
+        // attempt to insert it at the canonical path — or, for a Full response
+        // (which has no canonical re-key), at the request's own path.
+        fulfilledEntry = fulfillSegmentCacheEntry(upgradeToPendingSegment(createDetachedSegmentCacheEntry(now), fetchStrategy), rsc, staleAt, isPartial, recordedVaryParams, isUpgradeableISRFallback, recordedFetchStrategy);
+        insertVaryPath = canonicalVaryPath !== null ? canonicalVaryPath : (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
+    }
+    if (insertVaryPath !== null) {
+        // Insert through the upsert so the usual precedence rules apply — an
+        // existing entry with more complete content is never downgraded, and a
+        // shadowed Empty/Pending entry's blocked tasks are pinged. (In the
+        // common case the slot already holds the entry we just fulfilled, which
+        // the upsert replaces in place; but the re-key is load-bearing for
+        // entries whose spawn path differs from the canonical path — e.g.
+        // spawned revalidations, which would otherwise stay in their
+        // Revalidation slot forever, invisible to canonical reads, while the
+        // partial entry that prompted the revalidation kept serving
+        // navigations.)
+        //
+        // The concrete lookup path (tree.varyPath) is passed so that when the
+        // canonical path is more generic, any stale settled entry — or unclaimed
+        // Empty placeholder — at a more specific path that would shadow the
+        // fulfilled entry is evicted. Without this, a shadowed re-keyed entry is
+        // unreachable at the concrete read path: the scheduler would keep
+        // re-reading the stale entry and, for a revalidation, respawn it
+        // forever. See evictShadowingSegmentEntries.
+        const installedEntry = upsertSegmentEntry(now, map, insertVaryPath, fulfilledEntry, tree.varyPath);
+        if (installedEntry === null && !isOwned) {
+            // The upsert declined the detached candidate (an existing entry took
+            // precedence, or the candidate was already expired), so no cache slot
+            // holds this write's content — nothing for the caller to charge to
+            // the LRU. (An owned entry is returned regardless: it was fulfilled
+            // above and stays live for waiters that hold it, whether or not the
+            // re-key installed it.)
+            return null;
         }
     }
+    return fulfilledEntry;
 }
 async function fetchPrefetchResponse(url, headers) {
     const fetchPriority = 'low';
     // When issuing a prefetch request, don't immediately decode the response; we
     // use the lower level `createFromResponse` API instead because we need to do
     // some extra processing of the response stream. See
-    // `createNonTaskyPrefetchResponseStream` for more details.
+    // `bufferPrefetchResponseBody` for more details.
     const shouldImmediatelyDecode = false;
     const response = await (0, _fetchserverresponse.createFetch)(url, headers, fetchPriority, shouldImmediatelyDecode);
     if (!response.ok) {
@@ -2461,18 +2433,17 @@ async function fetchPrefetchResponse(url, headers) {
     }
     return response;
 }
-async function createNonTaskyPrefetchResponseStream(body, byteLimit) {
-    // Buffer the entire response before passing it to the Flight client. This
-    // ensures that when Flight processes the stream, all model data is available
-    // synchronously. This is important for readVaryParams, which synchronously
-    // checks the thenable status — if data arrived in multiple network chunks,
-    // the thenables might not yet be fulfilled.
-    //
-    // TODO: There are too many intermediate stream transformations in the
-    // prefetch response pipeline (e.g. stripIsPartialByte, this function).
-    // These could all be consolidated into a single transformation. Refactor
-    // once the cached navigations experiment lands.
-    //
+/**
+ * Whether the response was served from the per-segment-capable static
+ * prerender, rather than the old prefetching flow. If this fails, it implies
+ * that PPR is disabled on the route.
+ */ function wasServedFromPerSegmentCache(response) {
+    return response.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER) === '2' || // In output: "export" mode, we can't rely on response headers. But if we
+    // receive a well-formed response, we can assume it's a static response,
+    // because all data is static in this mode.
+    isOutputExportMode;
+}
+async function bufferPrefetchResponseBody(body, byteLimit) {
     // Read the response from the network, optionally truncating at byteLimit.
     const reader = body.getReader();
     const chunks = [];
@@ -2501,30 +2472,19 @@ async function createNonTaskyPrefetchResponseStream(body, byteLimit) {
     // PromiseResolveThenableJob from `await` can cause the root to initialize
     // eagerly, scheduling the continuation before remaining chunks (including
     // promise value rows) are processed. A single chunk avoids this.
-    let buffer;
     if (chunks.length === 1) {
-        buffer = chunks[0];
+        return chunks[0];
     } else if (chunks.length > 1) {
-        buffer = new Uint8Array(size);
+        const buffer = new Uint8Array(size);
         let offset = 0;
         for (const chunk of chunks){
             buffer.set(chunk, offset);
             offset += chunk.byteLength;
         }
+        return buffer;
     } else {
-        buffer = new Uint8Array(0);
+        return new Uint8Array(0);
     }
-    const stream = new ReadableStream({
-        start (controller) {
-            controller.enqueue(buffer);
-            controller.close();
-        }
-    });
-    return {
-        stream,
-        size,
-        buffer
-    };
 }
 /**
  * Creates a streaming (non-buffered) prefetch response stream for dynamic/Full
@@ -2596,44 +2556,71 @@ async function resolveStaleAt(now, staleTimeIterable, response) {
     }
     return now + _navigatereducer.STATIC_STALETIME_MS;
 }
-function writePrerenderResponseIntoCache(now, fetchStrategy, flightData, buildId, headVaryParamsIterable, rootVaryParamsIterable, staleAt, baseTree, renderedSearch, isResponsePartial, // The map the work that spawned this response's request is bound to. See
-// writeDynamicRenderResponseIntoCache.
+function spawnStaticStageCacheWrite(now, response, isResponsePartial, // The navigation response's headers, used to derive the buildId for the
+// write-layer build check (the deployment header, falling back to the
+// response's `b` field). Null for the initial payload, which arrived in
+// the HTML document and has no build-id check.
+responseHeaders, baseTree, renderedSearch, // The map the work that spawned this response's request is bound to. See
+// writeServerResponseIntoCache.
 map) {
-    // Root params are emitted once at the top level; readVaryParams unions them
-    // into the head, and they're threaded down to each segment below.
-    const headVaryParams = (0, _varyparamsdecoding.readVaryParams)(headVaryParamsIterable, rootVaryParamsIterable);
-    const flightDatas = (0, _flightdatahelpers.normalizeFlightData)(flightData);
-    if (typeof flightDatas === 'string') {
-        return;
-    }
-    const navigationSeed = (0, _navigation.convertServerPatchToFullTree)(now, baseTree, flightDatas, renderedSearch, _bfcache.UnknownDynamicStaleTime);
-    writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, rootVaryParamsIterable, staleAt, navigationSeed, null, map);
+    const buildId = responseHeaders !== null ? responseHeaders.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? response.b : undefined;
+    resolveStaleAt(now, response.s).then((staleAt)=>{
+        // TODO: This entire write is legacy and will be deleted in a future
+        // PR: caching is organized around the conceptual shell vs not-shell
+        // distinction, not around the static vs runtime render stages, so a
+        // static-stage write has no place in the model. It's kept only until
+        // its removal PR lands — do not extend it (e.g. with shell
+        // extraction).
+        writeServerResponseIntoCache(now, _types.FetchStrategy.PPR, response, baseTree, // The base tree is the navigation's current tree, not a prediction;
+        // divergence from it carries no signal.
+        null, // Navigation responses always include the param values in the tree,
+        // so there's no pathname to parse them from (nor a need to).
+        null, renderedSearch, buildId, staleAt, isResponsePartial, null, // No owned entries; every write is a detached upsert.
+        null, null, map);
+    }).catch(()=>{
+    // The static stage processing failed. Not fatal — the render
+    // completed normally, we just won't write into the cache.
+    });
 }
-async function processRuntimePrefetchStream(now, runtimePrefetchStream, baseTree, renderedSearch) {
+async function writeRuntimePrefetchStreamIntoCache(now, runtimePrefetchStream, baseTree, renderedSearch, // The map the work that spawned this response's request is bound to. See
+// writeServerResponseIntoCache.
+map) {
     const { stream, isPartial } = await stripIsPartialByte(runtimePrefetchStream);
-    const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(stream, undefined, {
-        allowPartialStream: true
-    });
-    // Root params are emitted once at the top level; readVaryParams unions them
-    // into the head, and we return the iterable so the caller can union it into
-    // each segment too.
-    const rootVaryParamsIterable = serverData.r ?? null;
-    const headVaryParams = (0, _varyparamsdecoding.readVaryParams)(serverData.h, rootVaryParamsIterable);
-    const staleAt = await resolveStaleAt(now, serverData.s);
-    const flightDatas = (0, _flightdatahelpers.normalizeFlightData)(serverData.f);
-    if (typeof flightDatas === 'string') {
-        return null;
+    const buffer = await bufferPrefetchResponseBody(stream);
+    const serverData = await (0, _fetchserverresponse.decodeBufferedStage)(buffer, undefined);
+    // Extract the shell payload, when the response carries one. Same wire
+    // convention as the other live-render responses (see
+    // resolveShellStageResponse): `a` absent means the render wasn't staged —
+    // no shell exists; `null` means the shell IS the full response; a number
+    // is the byte boundary of a distinct shell prefix, which is re-decoded
+    // from a truncated copy of the buffer. An unreadable `a` — pending or
+    // rejected, which only an aborted render produces — conservatively reads
+    // as no shell: the full payload is still written, there's just no shell
+    // stage to extract from it.
+    let shellResponse = null;
+    if (serverData.a !== undefined) {
+        const shellByteLength = (0, _rsctransport.readFulfilledValue)(serverData.a, undefined);
+        if (shellByteLength === null) {
+            shellResponse = serverData;
+        } else if (shellByteLength !== undefined) {
+            try {
+                shellResponse = await (0, _fetchserverresponse.decodeBufferedStage)(buffer.subarray(0, shellByteLength), undefined);
+            } catch  {
+                // The truncated prefix couldn't be decoded. Treat it as if no shell
+                // exists; the full payload is still usable.
+                shellResponse = null;
+            }
+        }
     }
-    const navigationSeed = (0, _navigation.convertServerPatchToFullTree)(now, baseTree, flightDatas, renderedSearch, _bfcache.UnknownDynamicStaleTime);
-    return {
-        flightDatas,
-        navigationSeed,
-        buildId: serverData.b,
-        isResponsePartial: isPartial,
-        headVaryParams,
-        rootVaryParamsIterable,
-        staleAt
-    };
+    writeResponsePayloadsIntoCache(now, // A runtime prefetch stream is by definition a runtime prefetch.
+    _types.FetchStrategy.PPRRuntime, serverData, shellResponse, baseTree, // The base tree is the navigation's current tree, not a prediction;
+    // divergence from it carries no signal.
+    null, // Navigation responses always include the param values in the tree, so
+    // there's no pathname to parse them from (nor a need to).
+    null, renderedSearch, serverData.b, // The response is fully buffered, so staleTime is read synchronously.
+    readFulfilledStaleAt(now, serverData.s), isPartial, null, // This flow owns no pending entries; every write is a detached upsert.
+    null, // Detached writes aren't sized; see writeResponsePayloadsIntoCache.
+    null, map);
 }
 async function stripIsPartialByte(stream) {
     // When there is no recognized marker byte, the fallback depends on whether