@evoscientist/webui 0.2.5 → 0.2.7

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     EntryStatus: null,
+    MetadataOnlyRequestTree: null,
     attemptToFulfillDynamicSegmentFromBFCache: null,
     attemptToUpgradeSegmentFromBFCache: null,
     canNewFetchStrategyProvideMoreContent: null,
@@ -12,15 +13,14 @@ Object.defineProperty(exports, "__esModule", {
     convertRouteTreeToFlightRouterState: null,
     createDetachedSegmentCacheEntry: null,
     createMetadataRouteTree: null,
+    createNonTaskyPrefetchResponseStream: null,
     deprecated_requestOptimisticRouteCacheEntry: null,
-    fetchInlinedSegmentsOnCacheMiss: null,
     fetchRouteOnCacheMiss: null,
-    fetchSegmentOnCacheMiss: null,
     fetchSegmentPrefetchesUsingDynamicRequest: null,
+    fetchSegmentsOnCacheMiss: null,
     fulfillRouteCacheEntry: null,
     getCurrentRouteCacheVersion: null,
     getCurrentSegmentCacheVersion: null,
-    getStaleAt: null,
     getStaleTimeMs: null,
     invalidateEntirePrefetchCache: null,
     invalidateRouteCacheEntries: null,
@@ -33,14 +33,16 @@ Object.defineProperty(exports, "__esModule", {
     readOrCreateRouteCacheEntry: null,
     readOrCreateSegmentCacheEntry: null,
     readRouteCacheEntry: null,
-    readSegmentCacheEntry: null,
+    readSegmentCacheEntryForNavigation: null,
+    resolveStaleAt: null,
+    segmentCacheMap: null,
     stripIsPartialByte: null,
     upgradeToPendingSegment: null,
     upsertSegmentEntry: null,
     waitForSegmentCacheEntry: null,
     writeDynamicRenderResponseIntoCache: null,
-    writeRouteIntoCache: null,
-    writeStaticStageResponseIntoCache: null
+    writePrerenderResponseIntoCache: null,
+    writeRouteIntoCache: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -50,7 +52,10 @@ function _export(target, all) {
 }
 _export(exports, {
     EntryStatus: function() {
-        return EntryStatus;
+        return _cachemap.EntryStatus;
+    },
+    MetadataOnlyRequestTree: function() {
+        return MetadataOnlyRequestTree;
     },
     attemptToFulfillDynamicSegmentFromBFCache: function() {
         return attemptToFulfillDynamicSegmentFromBFCache;
@@ -76,21 +81,21 @@ _export(exports, {
     createMetadataRouteTree: function() {
         return createMetadataRouteTree;
     },
+    createNonTaskyPrefetchResponseStream: function() {
+        return createNonTaskyPrefetchResponseStream;
+    },
     deprecated_requestOptimisticRouteCacheEntry: function() {
         return deprecated_requestOptimisticRouteCacheEntry;
     },
-    fetchInlinedSegmentsOnCacheMiss: function() {
-        return fetchInlinedSegmentsOnCacheMiss;
-    },
     fetchRouteOnCacheMiss: function() {
         return fetchRouteOnCacheMiss;
     },
-    fetchSegmentOnCacheMiss: function() {
-        return fetchSegmentOnCacheMiss;
-    },
     fetchSegmentPrefetchesUsingDynamicRequest: function() {
         return fetchSegmentPrefetchesUsingDynamicRequest;
     },
+    fetchSegmentsOnCacheMiss: function() {
+        return fetchSegmentsOnCacheMiss;
+    },
     fulfillRouteCacheEntry: function() {
         return fulfillRouteCacheEntry;
     },
@@ -100,9 +105,6 @@ _export(exports, {
     getCurrentSegmentCacheVersion: function() {
         return getCurrentSegmentCacheVersion;
     },
-    getStaleAt: function() {
-        return getStaleAt;
-    },
     getStaleTimeMs: function() {
         return getStaleTimeMs;
     },
@@ -139,8 +141,14 @@ _export(exports, {
     readRouteCacheEntry: function() {
         return readRouteCacheEntry;
     },
-    readSegmentCacheEntry: function() {
-        return readSegmentCacheEntry;
+    readSegmentCacheEntryForNavigation: function() {
+        return readSegmentCacheEntryForNavigation;
+    },
+    resolveStaleAt: function() {
+        return resolveStaleAt;
+    },
+    segmentCacheMap: function() {
+        return segmentCacheMap;
     },
     stripIsPartialByte: function() {
         return stripIsPartialByte;
@@ -157,16 +165,18 @@ _export(exports, {
     writeDynamicRenderResponseIntoCache: function() {
         return writeDynamicRenderResponseIntoCache;
     },
+    writePrerenderResponseIntoCache: function() {
+        return writePrerenderResponseIntoCache;
+    },
     writeRouteIntoCache: function() {
         return writeRouteIntoCache;
-    },
-    writeStaticStageResponseIntoCache: function() {
-        return writeStaticStageResponseIntoCache;
     }
 });
+const _approutertypes = require("../../../shared/lib/app-router-types");
 const _varyparamsdecoding = require("../../../shared/lib/segment-cache/vary-params-decoding");
 const _approuterheaders = require("../app-router-headers");
 const _fetchserverresponse = require("../router-reducer/fetch-server-response");
+const _fetch = require("./fetch");
 const _scheduler = require("./scheduler");
 const _varypath = require("./vary-path");
 const _createhreffromurl = require("../router-reducer/create-href-from-url");
@@ -188,13 +198,6 @@ const _constants = require("../../../lib/constants");
 function getStaleTimeMs(staleTimeSeconds) {
     return Math.max(staleTimeSeconds, 30) * 1000;
 }
-var EntryStatus = /*#__PURE__*/ function(EntryStatus) {
-    EntryStatus[EntryStatus["Empty"] = 0] = "Empty";
-    EntryStatus[EntryStatus["Pending"] = 1] = "Pending";
-    EntryStatus[EntryStatus["Fulfilled"] = 2] = "Fulfilled";
-    EntryStatus[EntryStatus["Rejected"] = 3] = "Rejected";
-    return EntryStatus;
-}({});
 const isOutputExportMode = process.env.NODE_ENV === 'production' && process.env.__NEXT_CONFIG_OUTPUT === 'export';
 const MetadataOnlyRequestTree = [
     '',
@@ -202,8 +205,8 @@ const MetadataOnlyRequestTree = [
     null,
     'metadata-only'
 ];
-let routeCacheMap = (0, _cachemap.createCacheMap)();
-let segmentCacheMap = (0, _cachemap.createCacheMap)();
+const routeCacheMap = (0, _cachemap.createCacheMap)();
+const segmentCacheMap = (0, _cachemap.createCacheMap)();
 // All invalidation listeners for the whole cache are tracked in single set.
 // Since we don't yet support tag or path-based invalidation, there's no point
 // tracking them any more granularly than this. Once we add granular
@@ -291,24 +294,41 @@ function pingInvalidationListeners(nextUrl, tree) {
 function readRouteCacheEntry(now, key) {
     const varyPath = (0, _varypath.getRouteVaryPath)(key.pathname, key.search, key.nextUrl);
     const isRevalidation = false;
-    const existingEntry = (0, _cachemap.getFromCacheMap)(now, getCurrentRouteCacheVersion(), routeCacheMap, varyPath, isRevalidation);
+    const existingEntry = (0, _cachemap.getFromCacheMap)(now, getCurrentRouteCacheVersion(), routeCacheMap, varyPath, isRevalidation, false);
     if (existingEntry !== null) {
         return existingEntry;
     }
     // No cache hit. Attempt to construct from template using the new
     // optimistic routing mechanism (pattern-based matching).
     if (process.env.__NEXT_OPTIMISTIC_ROUTING) {
-        return (0, _optimisticroutes.matchKnownRoute)(key.pathname, key.search);
+        return (0, _optimisticroutes.matchKnownRoute)(now, key.pathname, key.search);
     }
     return null;
 }
-function readSegmentCacheEntry(now, varyPath) {
+function readSegmentCacheEntryForNavigation(now, // The map the navigation is bound to: a locked navigation's driving-task
+// map, or the shared map otherwise.
+map, varyPath, restrictToShell = false) {
     const isRevalidation = false;
-    return (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), segmentCacheMap, varyPath, isRevalidation);
+    let lookupVaryPath = varyPath;
+    if (process.env.__NEXT_EXPOSE_TESTING_API && restrictToShell) {
+        // Instant Navigation Testing API: we're navigating to a link that 1) has
+        // Partial Prefetching enabled, and 2) does not have a prefetch prop set.
+        // Only the shell may render, not anything that varies on concrete route
+        // params.
+        lookupVaryPath = (0, _varypath.getShellSegmentVaryPath)(varyPath);
+    }
+    // Prefer a Fulfilled entry (e.g. a cached shell) over a more-specific
+    // Pending/Rejected one so it renders immediately instead of blocking on an
+    // in-flight entry.
+    const fulfilled = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, lookupVaryPath, isRevalidation, true);
+    if (fulfilled !== null) {
+        return fulfilled;
+    }
+    return (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, lookupVaryPath, isRevalidation, false);
 }
-function readRevalidatingSegmentCacheEntry(now, varyPath) {
+function readRevalidatingSegmentCacheEntry(now, map, varyPath) {
     const isRevalidation = true;
-    return (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), segmentCacheMap, varyPath, isRevalidation);
+    return (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, varyPath, isRevalidation, false);
 }
 function waitForSegmentCacheEntry(pendingEntry) {
     // Because the entry is pending, there's already a in-progress request.
@@ -324,7 +344,7 @@ function waitForSegmentCacheEntry(pendingEntry) {
 function createDetachedRouteCacheEntry() {
     return {
         canonicalUrl: null,
-        status: 0,
+        status: _cachemap.EntryStatus.Empty,
         blockedTasks: null,
         tree: null,
         metadata: null,
@@ -334,6 +354,7 @@ function createDetachedRouteCacheEntry() {
         couldBeIntercepted: true,
         // Similarly, we don't yet know if the route supports PPR.
         supportsPerSegmentPrefetching: false,
+        hasDynamicRewrite: false,
         renderedSearch: null,
         // Map-related fields
         ref: null,
@@ -389,7 +410,7 @@ function deprecated_requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl)
     const urlWithoutSearchParams = new URL(requestedUrl);
     urlWithoutSearchParams.search = '';
     const routeWithNoSearchParams = readRouteCacheEntry(now, (0, _cachekey.createCacheKey)(urlWithoutSearchParams.href, nextUrl));
-    if (routeWithNoSearchParams === null || routeWithNoSearchParams.status !== 2) {
+    if (routeWithNoSearchParams === null || routeWithNoSearchParams.status !== _cachemap.EntryStatus.Fulfilled) {
         // Bail out of constructing an optimistic route tree. This will result in
         // a blocking, unprefetched navigation.
         return null;
@@ -417,7 +438,7 @@ function deprecated_requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl)
     // optimistic values.
     const optimisticEntry = {
         canonicalUrl: optimisticCanonicalUrl,
-        status: 2,
+        status: _cachemap.EntryStatus.Fulfilled,
         // This isn't cloned because it's instance-specific
         blockedTasks: null,
         tree: optimisticRouteTree,
@@ -443,17 +464,19 @@ function deprecated_createOptimisticRouteTree(tree, newRenderedSearch) {
     let clonedSlots = null;
     const originalSlots = tree.slots;
     if (originalSlots !== null) {
-        clonedSlots = {};
-        for(const parallelRouteKey in originalSlots){
-            const childTree = originalSlots[parallelRouteKey];
-            clonedSlots[parallelRouteKey] = deprecated_createOptimisticRouteTree(childTree, newRenderedSearch);
+        clonedSlots = new Map();
+        for (const [parallelRouteKey, childTree] of originalSlots){
+            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,
@@ -464,6 +487,7 @@ function deprecated_createOptimisticRouteTree(tree, newRenderedSearch) {
     return {
         requestKey: tree.requestKey,
         segment: tree.segment,
+        shellVaryPath: tree.shellVaryPath,
         refreshState: tree.refreshState,
         varyPath: tree.varyPath,
         isPage: false,
@@ -471,21 +495,29 @@ function deprecated_createOptimisticRouteTree(tree, newRenderedSearch) {
         prefetchHints: tree.prefetchHints
     };
 }
-function readOrCreateSegmentCacheEntry(now, fetchStrategy, tree) {
-    const existingEntry = readSegmentCacheEntry(now, tree.varyPath);
+function readOrCreateSegmentCacheEntry(now, // The map the calling task operates in (`PrefetchTask.segmentCacheMap`,
+// captured when the task was scheduled).
+map, fetchStrategy, tree) {
+    const existingEntry = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, tree.varyPath, false, false);
     if (existingEntry !== null) {
         return existingEntry;
     }
-    // Create a pending entry and add it to the cache. The stale time is set to a
-    // default value; the actual stale time will be set when the entry is
-    // fulfilled with data from the server response.
+    return insertEmptySegmentCacheEntry(now, map, fetchStrategy, tree);
+}
+/**
+ * Creates an empty segment cache entry and inserts it into the cache, keyed
+ * at the vary path a request made with the given fetch strategy is stored
+ * under. The stale time is set to a default value; the actual stale time will
+ * be set when the entry is fulfilled with data from the server response.
+ */ function insertEmptySegmentCacheEntry(now, map, fetchStrategy, tree) {
     const varyPathForRequest = (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
-    const pendingEntry = createDetachedSegmentCacheEntry(now);
+    const emptyEntry = createDetachedSegmentCacheEntry(now);
     const isRevalidation = false;
-    (0, _cachemap.setInCacheMap)(segmentCacheMap, varyPathForRequest, pendingEntry, isRevalidation);
-    return pendingEntry;
+    (0, _cachemap.setInCacheMap)(map, varyPathForRequest, emptyEntry, isRevalidation);
+    return emptyEntry;
 }
-function readOrCreateRevalidatingSegmentEntry(now, fetchStrategy, tree) {
+function readOrCreateRevalidatingSegmentEntry(now, // The map the calling task operates in (`PrefetchTask.segmentCacheMap`).
+map, fetchStrategy, tree) {
     // This function is called when we've already confirmed that a particular
     // segment is cached, but we want to perform another request anyway in case it
     // returns more complete and/or fresher data than we already have. The logic
@@ -512,7 +544,7 @@ function readOrCreateRevalidatingSegmentEntry(now, fetchStrategy, tree) {
     // return a less generic entry upon revalidation. For now, though, this isn't
     // a concern because the keypath is based solely on the prefetch strategy,
     // not on data contained in the response.
-    const existingEntry = readRevalidatingSegmentCacheEntry(now, tree.varyPath);
+    const existingEntry = readRevalidatingSegmentCacheEntry(now, map, tree.varyPath);
     if (existingEntry !== null) {
         return existingEntry;
     }
@@ -522,10 +554,11 @@ function readOrCreateRevalidatingSegmentEntry(now, fetchStrategy, tree) {
     const varyPathForRequest = (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
     const pendingEntry = createDetachedSegmentCacheEntry(now);
     const isRevalidation = true;
-    (0, _cachemap.setInCacheMap)(segmentCacheMap, varyPathForRequest, pendingEntry, isRevalidation);
+    (0, _cachemap.setInCacheMap)(map, varyPathForRequest, pendingEntry, isRevalidation);
     return pendingEntry;
 }
-function overwriteRevalidatingSegmentCacheEntry(now, fetchStrategy, tree) {
+function overwriteRevalidatingSegmentCacheEntry(now, // The map the calling task operates in (`PrefetchTask.segmentCacheMap`).
+map, fetchStrategy, tree) {
     // This function is called when we've already decided to replace an existing
     // revalidation entry. Create a new entry and write it into the cache,
     // overwriting the previous value. The stale time is set to a default value;
@@ -534,10 +567,42 @@ function overwriteRevalidatingSegmentCacheEntry(now, fetchStrategy, tree) {
     const varyPathForRequest = (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
     const pendingEntry = createDetachedSegmentCacheEntry(now);
     const isRevalidation = true;
-    (0, _cachemap.setInCacheMap)(segmentCacheMap, varyPathForRequest, pendingEntry, isRevalidation);
+    (0, _cachemap.setInCacheMap)(map, varyPathForRequest, pendingEntry, isRevalidation);
     return pendingEntry;
 }
-function upsertSegmentEntry(now, varyPath, candidateEntry) {
+/**
+ * Whether an existing cache entry is preferred over an incoming candidate —
+ * i.e. the candidate does NOT supersede it. (On an exact tie — same fetch
+ * strategy, same partialness — this returns false, so the candidate replaces
+ * the existing entry.) This is the precedence rule used both when deciding
+ * whether an upsert may replace the entry at its own keypath, and when
+ * deciding whether an entry at a more specific keypath may be evicted because
+ * it shadows a just-inserted candidate (see `evictShadowingSegmentEntries`).
+ *
+ * Note that "less/more specific" in the comments below refers to fetch
+ * 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) {
+    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.
+    candidateEntry.fetchStrategy !== existingEntry.fetchStrategy && !canNewFetchStrategyProvideMoreContent(existingEntry.fetchStrategy, candidateEntry.fetchStrategy) || // The existing entry isn't partial, but the new one is.
+    // (TODO: can this be true if `candidateEntry.fetchStrategy >= existingEntry.fetchStrategy`?)
+    !existingEntry.isPartial && candidateEntry.isPartial);
+}
+function upsertSegmentEntry(now, // The map the whole upsert (existing-entry read, insert, shadow eviction)
+// operates in. Prefetch response-write paths pass the spawning task's map
+// (`PrefetchTask.segmentCacheMap`), so a response that lands after a
+// testing-lock scope boundary still writes into the map its entries
+// live in.
+map, varyPath, candidateEntry, // The fully concrete vary path a read for this segment position resolves
+// against (all concrete param values, i.e. `tree.varyPath`) — the most
+// specific path a read would use. Note this is the opposite of the
+// generalized keying path that `getSegmentVaryPathForRequest` computes.
+// Used to detect and evict stale entries at more specific keypaths that
+// would otherwise shadow the candidate. Pass null when there's no request
+// context; the shadow check is skipped.
+lookupVaryPath) {
     // We have a new entry that has not yet been inserted into the cache. Before
     // we do so, we need to confirm whether it takes precedence over the existing
     // entry (if one exists).
@@ -548,44 +613,137 @@ function upsertSegmentEntry(now, varyPath, candidateEntry) {
         // The entry is expired. We cannot upsert it.
         return null;
     }
-    const existingEntry = readSegmentCacheEntry(now, varyPath);
+    const existingEntry = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, varyPath, false, false);
     if (existingEntry !== null) {
         // Don't replace a more specific segment with a less-specific one. A case where this
         // might happen is if the existing segment was fetched via
         // `<Link prefetch={true}>`.
-        if (// 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.
-        candidateEntry.fetchStrategy !== existingEntry.fetchStrategy && !canNewFetchStrategyProvideMoreContent(existingEntry.fetchStrategy, candidateEntry.fetchStrategy) || // The existing entry isn't partial, but the new one is.
-        // (TODO: can this be true if `candidateEntry.fetchStrategy >= existingEntry.fetchStrategy`?)
-        !existingEntry.isPartial && candidateEntry.isPartial) {
-            // We're going to leave revalidating entry in the cache so that it doesn't
-            // get revalidated again unnecessarily. Downgrade the Fulfilled entry to
-            // Rejected and null out the data so it can be garbage collected. We leave
-            // `staleAt` intact to prevent subsequent revalidation attempts only until
-            // the entry expires.
-            const rejectedEntry = candidateEntry;
-            rejectedEntry.status = 3;
-            rejectedEntry.rsc = null;
+        if (isExistingSegmentEntryPreferred(existingEntry, candidateEntry)) {
+            // The candidate does not supersede the existing entry. Leave the
+            // existing entry in place and discard the candidate by not inserting it.
+            //
+            // We must not mutate the candidate here (e.g. downgrade it to Rejected or
+            // null out its `rsc`). The caller does not transfer exclusive ownership
+            // of it: it may already have been fulfilled, resolving its promise to a
+            // waiter that holds the entry and reads `rsc` off it later. A navigation
+            // seed is such a waiter, via `waitForSegmentCacheEntry`. Nulling `rsc`
+            // after the fact resolves that read to `null`, so the waiter loses the
+            // data it was about to render. Declining to insert it is enough: the
+            // existing entry stays canonical, and the candidate keeps its valid (if
+            // less complete) data for any waiter that already took it.
             return null;
         }
-        // Evict the existing entry from the cache.
-        (0, _cachemap.deleteFromCacheMap)(existingEntry);
+        // Ping any tasks blocked on the existing entry before replacing it so they
+        // re-run and pick up the new entry. Without this, tasks waiting on the
+        // existing Empty/Pending entry would be stranded — the new fulfilled
+        // candidate has no blockedTasks of its own.
+        if (existingEntry.status === _cachemap.EntryStatus.Empty || existingEntry.status === _cachemap.EntryStatus.Pending) {
+            pingBlockedTasks(existingEntry);
+        }
+    // Replace the existing entry by writing the candidate over its keypath
+    // below (the same mechanism `overwriteRevalidatingSegmentCacheEntry`
+    // uses). We intentionally do NOT call `deleteFromCacheMap` first: deleting
+    // vacates the canonical slot, and `deleteMapEntry` promotes a pending
+    // Revalidation-slot entry into the vacated slot — which the immediate
+    // insert below would then silently overwrite. The in-flight revalidation
+    // would vanish from the map, so the next scheduler pass would find an
+    // empty revalidation slot and spawn a duplicate request instead of
+    // deduping against it. Replacing in place never vacates the slot, so
+    // promotion never runs and the pending revalidating entry stays in its
+    // Revalidation slot where `readOrCreateRevalidatingSegmentEntry`'s dedupe
+    // finds it.
+    //
+    // The displaced entry's map/LRU accounting is handled by the replacement
+    // itself: `setMapEntryValue` drops the displaced value's `ref` and
+    // `updateLruSize` swaps its size for the candidate's, which is exactly
+    // what delete-then-insert did.
     }
     const isRevalidation = false;
-    (0, _cachemap.setInCacheMap)(segmentCacheMap, varyPath, candidateEntry, isRevalidation);
+    (0, _cachemap.setInCacheMap)(map, varyPath, candidateEntry, isRevalidation);
+    if (lookupVaryPath !== null) {
+        evictShadowingSegmentEntries(now, map, lookupVaryPath, candidateEntry);
+    }
     return candidateEntry;
 }
+/**
+ * Evicts stale entries at more specific keypaths that shadow a just-inserted
+ * candidate entry.
+ *
+ * A response can be written to the cache at a MORE GENERIC vary path than the
+ * path the request was issued against — for example, the server may report
+ * that a segment doesn't vary on a param, so the entry is re-keyed with that
+ * param as Fallback. Meanwhile, an older, less useful entry can exist at a
+ * more specific path within the same fallback chain — for example, a partial
+ * shell entry keyed with root params concrete (see
+ * `getShellSegmentVaryPath`). Because segment lookup is
+ * most-specific-match-wins, every subsequent read at the concrete request
+ * path keeps returning the stale specific entry, and the more complete
+ * generic entry is unreachable from that URL. That both wastes the completed
+ * request and can loop: a prefetch task that revalidated the segment reads
+ * back the same stale entry, decides it needs to revalidate again, and
+ * repeats forever.
+ *
+ * The upsert is the one moment we know the ordering between the two entries:
+ * the candidate was produced by a request for this segment position, and
+ * `lookupVaryPath` is the fully concrete path a read for that position
+ * resolves against, so any entry that a read at that path would return in the
+ * candidate's stead is directly comparable to it. If such an entry is settled
+ * and the candidate supersedes it — under the same precedence rules the
+ * 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.
+ */ 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
+    // entry we don't supersede). Each iteration re-reads and re-checks from
+    // scratch (in part because `deleteFromCacheMap` can promote a settled
+    // Revalidation-slot value into the just-vacated slot, surfacing a new entry
+    // at the same keypath). Each iteration deletes an entry from the map, so
+    // the loop terminates naturally; the bound is defensive, and 32 is far
+    // beyond any real fallback chain, which is bounded by the vary
+    // path's length.
+    for(let i = 0; i < 32; i++){
+        const shadowEntry = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, lookupVaryPath, false, false);
+        if (shadowEntry === null || shadowEntry === candidateEntry) {
+            // The candidate is reachable from the lookup path (or the read missed
+            // 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.
+            return;
+        }
+        if (isExistingSegmentEntryPreferred(shadowEntry, candidateEntry)) {
+            // The shadowing entry is preferred over the candidate (e.g. it's a
+            // complete entry fetched with a more specific strategy). Leave it —
+            // reads at this path should keep matching it.
+            return;
+        }
+        // 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.
+        pingBlockedTasks(shadowEntry);
+        (0, _cachemap.deleteFromCacheMap)(shadowEntry);
+    }
+}
 function createDetachedSegmentCacheEntry(now) {
     // Default stale time for pending segment cache entries. The actual stale time
     // is set when the entry is fulfilled with data from the server response.
     const staleAt = now + 30 * 1000;
     const emptyEntry = {
-        status: 0,
+        status: _cachemap.EntryStatus.Empty,
+        blockedTasks: null,
         // Default to assuming the fetch strategy will be PPR. This will be updated
         // when a fetch is actually initiated.
         fetchStrategy: _types.FetchStrategy.PPR,
         rsc: null,
         isPartial: true,
+        isUpgradeableISRFallback: false,
         promise: null,
         // Map-related fields
         ref: null,
@@ -597,7 +755,7 @@ function createDetachedSegmentCacheEntry(now) {
 }
 function upgradeToPendingSegment(emptyEntry, fetchStrategy) {
     const pendingEntry = emptyEntry;
-    pendingEntry.status = 1;
+    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
@@ -637,11 +795,13 @@ function attemptToFulfillDynamicSegmentFromBFCache(now, segment, tree) {
         }
         const pendingSegment = upgradeToPendingSegment(segment, _types.FetchStrategy.Full);
         const isPartial = false;
-        return fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial);
+        return fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial, // bfcache data is concrete, never an ISR fallback.
+        false, _types.FetchStrategy.Full);
     }
     return null;
 }
-function attemptToUpgradeSegmentFromBFCache(now, tree) {
+function attemptToUpgradeSegmentFromBFCache(now, // The map the calling task operates in (`PrefetchTask.segmentCacheMap`).
+map, tree) {
     const varyPath = tree.varyPath;
     const bfcacheEntry = (0, _bfcache.readFromBFCache)(varyPath);
     if (bfcacheEntry !== null) {
@@ -651,10 +811,14 @@ function attemptToUpgradeSegmentFromBFCache(now, tree) {
         }
         const pendingSegment = upgradeToPendingSegment(createDetachedSegmentCacheEntry(now), _types.FetchStrategy.Full);
         const isPartial = false;
-        const newEntry = fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial);
+        const newEntry = fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial, // 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, segmentVaryPath, newEntry);
-        if (upserted !== null && upserted.status === 2) {
+        const upserted = upsertSegmentEntry(now, map, segmentVaryPath, newEntry, // The concrete lookup path this BFCache upgrade applies to. (In
+        // practice a Full request path is already fully concrete, so nothing
+        // can shadow the new entry and the shadow check is a no-op.)
+        tree.varyPath);
+        if (upserted !== null && upserted.status === _cachemap.EntryStatus.Fulfilled) {
             return upserted;
         }
     }
@@ -677,6 +841,7 @@ function createMetadataRouteTree(metadataVaryPath) {
     const metadata = {
         requestKey: _segmentvalueencoding.HEAD_REQUEST_KEY,
         segment: _segmentvalueencoding.HEAD_REQUEST_KEY,
+        shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(metadataVaryPath),
         refreshState: null,
         varyPath: metadataVaryPath,
         // The metadata isn't really a "page" (though it isn't really a "segment"
@@ -692,14 +857,24 @@ function fulfillRouteCacheEntry(now, entry, tree, metadataVaryPath, couldBeInter
     // Get the rendered search from the vary path
     const renderedSearch = (0, _varypath.getRenderedSearchFromVaryPath)(metadataVaryPath) ?? '';
     const fulfilledEntry = entry;
-    fulfilledEntry.status = 2;
+    fulfilledEntry.status = _cachemap.EntryStatus.Fulfilled;
     fulfilledEntry.tree = tree;
     fulfilledEntry.metadata = createMetadataRouteTree(metadataVaryPath);
     // 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
     // change routes dynamically. We have other strategies for handling those.
-    fulfilledEntry.staleAt = now + _navigatereducer.STATIC_STALETIME_MS;
+    //
+    // If the route tree has stale inlining hints (e.g. the initial RSC payload
+    // for a build-time static page, generated before collectPrefetchHints ran),
+    // immediately expire the entry so it gets re-fetched with correct hints.
+    // The segment data itself is still valid — only the route tree (which
+    // contains the hint bits) needs to be re-fetched.
+    if (tree.prefetchHints & _approutertypes.PrefetchHint.InliningHintsStale) {
+        fulfilledEntry.staleAt = -1;
+    } else {
+        fulfilledEntry.staleAt = now + _navigatereducer.STATIC_STALETIME_MS;
+    }
     fulfilledEntry.couldBeIntercepted = couldBeIntercepted;
     fulfilledEntry.canonicalUrl = canonicalUrl;
     fulfilledEntry.renderedSearch = renderedSearch;
@@ -708,11 +883,10 @@ function fulfillRouteCacheEntry(now, entry, tree, metadataVaryPath, couldBeInter
     pingBlockedTasks(entry);
     return fulfilledEntry;
 }
-function writeRouteIntoCache(now, pathname, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching) {
+function writeRouteIntoCache(now, pathname, search, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching) {
     const pendingEntry = createDetachedRouteCacheEntry();
     const fulfilledEntry = fulfillRouteCacheEntry(now, pendingEntry, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
-    const renderedSearch = fulfilledEntry.renderedSearch;
-    const varyPath = (0, _varypath.getFulfilledRouteVaryPath)(pathname, renderedSearch, nextUrl, couldBeIntercepted);
+    const varyPath = (0, _varypath.getFulfilledRouteVaryPath)(pathname, search, nextUrl, couldBeIntercepted);
     const isRevalidation = false;
     (0, _cachemap.setInCacheMap)(routeCacheMap, varyPath, fulfilledEntry, isRevalidation);
     return fulfilledEntry;
@@ -723,29 +897,46 @@ function markRouteEntryAsDynamicRewrite(entry) {
 // 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) {
+function fulfillSegmentCacheEntry(segmentCacheEntry, rsc, staleAt, isPartial, // 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.
+isUpgradeableISRFallback, // The strategy tier describing the CONTENT this entry is fulfilled with —
+// which comes from the response, not the tier the entry was requested at.
+// 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
+// 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
+// SegmentCacheEntryShared['fetchStrategy'].
+fetchStrategy) {
     const fulfilledEntry = segmentCacheEntry;
-    fulfilledEntry.status = 2;
+    fulfilledEntry.status = _cachemap.EntryStatus.Fulfilled;
     fulfilledEntry.rsc = rsc;
     fulfilledEntry.staleAt = staleAt;
     fulfilledEntry.isPartial = isPartial;
+    fulfilledEntry.isUpgradeableISRFallback = isUpgradeableISRFallback;
+    fulfilledEntry.fetchStrategy = fetchStrategy;
     // Resolve any listeners that were waiting for this data.
     if (segmentCacheEntry.promise !== null) {
         segmentCacheEntry.promise.resolve(fulfilledEntry);
         // Free the promise for garbage collection.
         fulfilledEntry.promise = null;
     }
+    pingBlockedTasks(segmentCacheEntry);
     return fulfilledEntry;
 }
 function rejectRouteCacheEntry(entry, staleAt) {
     const rejectedEntry = entry;
-    rejectedEntry.status = 3;
+    rejectedEntry.status = _cachemap.EntryStatus.Rejected;
     rejectedEntry.staleAt = staleAt;
     pingBlockedTasks(entry);
 }
 function rejectSegmentCacheEntry(entry, staleAt) {
     const rejectedEntry = entry;
-    rejectedEntry.status = 3;
+    rejectedEntry.status = _cachemap.EntryStatus.Rejected;
     rejectedEntry.staleAt = staleAt;
     if (entry.promise !== null) {
         // NOTE: We don't currently propagate the reason the prefetch was canceled
@@ -753,10 +944,11 @@ function rejectSegmentCacheEntry(entry, staleAt) {
         entry.promise.resolve(null);
         entry.promise = null;
     }
+    pingBlockedTasks(entry);
 }
 function convertRootTreePrefetchToRouteTree(rootTree, renderedPathname, renderedSearch, acc) {
     // Remove trailing and leading slashes
-    const pathnameParts = renderedPathname.split('/').filter((p)=>p !== '');
+    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);
@@ -774,7 +966,7 @@ function convertTreePrefetchToRouteTree(prefetch, segment, partialVaryPath, requ
     if (prefetchSlots !== null) {
         isPage = false;
         varyPath = (0, _varypath.finalizeLayoutVaryPath)(requestKey, partialVaryPath);
-        slots = {};
+        slots = new Map();
         for(let parallelRouteKey in prefetchSlots){
             const childPrefetch = prefetchSlots[parallelRouteKey];
             const childSegmentName = childPrefetch.name;
@@ -797,7 +989,9 @@ function convertTreePrefetchToRouteTree(prefetch, segment, partialVaryPath, requ
                 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);
+                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,
@@ -817,7 +1011,7 @@ function convertTreePrefetchToRouteTree(prefetch, segment, partialVaryPath, requ
             const childPathnamePartsIndex = childDoesAppearInURL ? pathnamePartsIndex + 1 : pathnamePartsIndex;
             const childRequestKeyPart = (0, _segmentvalueencoding.createSegmentRequestKeyPart)(childSegment);
             const childRequestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(requestKey, parallelRouteKey, childRequestKeyPart);
-            slots[parallelRouteKey] = convertTreePrefetchToRouteTree(childPrefetch, childSegment, childPartialVaryPath, childRequestKey, pathnameParts, childPathnamePartsIndex, renderedSearch, acc);
+            slots.set(parallelRouteKey, convertTreePrefetchToRouteTree(childPrefetch, childSegment, childPartialVaryPath, childRequestKey, pathnameParts, childPathnamePartsIndex, renderedSearch, acc));
         }
     } else {
         if (requestKey.endsWith(_segment.PAGE_SEGMENT_KEY)) {
@@ -842,6 +1036,7 @@ function convertTreePrefetchToRouteTree(prefetch, segment, partialVaryPath, requ
     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
@@ -874,6 +1069,9 @@ function convertReusedFlightRouterStateToRouteTree(parentRouteTree, parallelRout
 }
 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
+    // above the root layout, which the server marks directly.
+    const isRootParam = ((flightRouterState[4] ?? 0) & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0;
     // If the FlightRouterState has a refresh state, then this segment is part of
     // an inactive parallel route. It has a different rendered search query than
     // the outer parent route. In order to construct the inactive route correctly,
@@ -892,7 +1090,7 @@ function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, pare
         isPage = false;
         const paramCacheKey = originalSegment[1];
         const paramName = originalSegment[0];
-        partialVaryPath = (0, _varypath.appendLayoutVaryPath)(parentPartialVaryPath, paramCacheKey, paramName);
+        partialVaryPath = (0, _varypath.appendLayoutVaryPath)(parentPartialVaryPath, paramCacheKey, paramName, isRootParam);
         varyPath = (0, _varypath.finalizeLayoutVaryPath)(requestKey, partialVaryPath);
         segment = originalSegment;
     } else {
@@ -941,16 +1139,14 @@ function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, pare
         const childRequestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(requestKey, parallelRouteKey, childRequestKeyPart);
         const childTree = convertFlightRouterStateToRouteTree(childRouterState, childRequestKey, partialVaryPath, renderedSearch, acc);
         if (slots === null) {
-            slots = {
-                [parallelRouteKey]: childTree
-            };
-        } else {
-            slots[parallelRouteKey] = childTree;
+            slots = new Map();
         }
+        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
@@ -966,9 +1162,10 @@ function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, pare
 }
 function convertRouteTreeToFlightRouterState(routeTree) {
     const parallelRoutes = {};
-    if (routeTree.slots !== null) {
-        for(const parallelRouteKey in routeTree.slots){
-            parallelRoutes[parallelRouteKey] = convertRouteTreeToFlightRouterState(routeTree.slots[parallelRouteKey]);
+    const slots = routeTree.slots;
+    if (slots !== null) {
+        for (const [parallelRouteKey, childTree] of slots){
+            parallelRoutes[parallelRouteKey] = convertRouteTreeToFlightRouterState(childTree);
         }
     }
     const flightRouterState = [
@@ -977,9 +1174,14 @@ function convertRouteTreeToFlightRouterState(routeTree) {
         null,
         null
     ];
+    if (routeTree.prefetchHints !== 0) {
+        flightRouterState[4] = routeTree.prefetchHints;
+    }
     return flightRouterState;
 }
-async function fetchRouteOnCacheMiss(entry, key) {
+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) {
     // 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
@@ -996,9 +1198,6 @@ async function fetchRouteOnCacheMiss(entry, key) {
     if (nextUrl !== null) {
         headers[_approuterheaders.NEXT_URL] = nextUrl;
     }
-    // Tell the server to perform a static pre-render for the Instant Navigation
-    // Testing API. Static pre-renders don't normally happen during development.
-    addInstantPrefetchHeaderIfLocked(headers);
     try {
         const url = new URL(pathname + search, location.origin);
         let response;
@@ -1039,7 +1238,7 @@ async function fetchRouteOnCacheMiss(entry, key) {
             // NOTE: We could embed the route tree into the HTML document, to avoid
             // a second request. We're not doing that currently because it would make
             // the HTML document larger and affect normal page loads.
-            const headResponse = await fetch(url, {
+            const headResponse = await (0, _fetch.fetch)(url, {
                 method: 'HEAD'
             });
             if (headResponse.status < 200 || headResponse.status >= 400) {
@@ -1061,10 +1260,7 @@ async function fetchRouteOnCacheMiss(entry, key) {
             response = await fetchPrefetchResponse(url, headers);
             urlAfterRedirects = response !== null && response.redirected ? new URL(response.url) : url;
         }
-        if (!response || !response.ok || // 204 is a Cache miss. Though theoretically this shouldn't happen when
-        // PPR is enabled, because we always respond to route tree requests, even
-        // if it needs to be blockingly generated on demand.
-        response.status === 204 || !response.body) {
+        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);
@@ -1127,7 +1323,8 @@ async function fetchRouteOnCacheMiss(entry, key) {
             // During this traversal, we accumulate additional data into this
             // "accumulator" object.
             const acc = {
-                metadataVaryPath: null
+                metadataVaryPath: null,
+                treeDivergedFromBase: false
             };
             const routeTree = convertRootTreePrefetchToRouteTree(serverData, renderedPathname, renderedSearch, acc);
             const metadataVaryPath = acc.metadataVaryPath;
@@ -1135,7 +1332,7 @@ async function fetchRouteOnCacheMiss(entry, key) {
                 rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
                 return null;
             }
-            (0, _optimisticroutes.discoverKnownRoute)(Date.now(), pathname, nextUrl, entry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, false // hasDynamicRewrite
+            (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
@@ -1156,13 +1353,14 @@ async function fetchRouteOnCacheMiss(entry, key) {
                 rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
                 return null;
             }
-            // Read head vary params synchronously. Individual segments carry their
-            // own thenables in CacheNodeSeedData.
-            const headVaryParamsThenable = serverData.h;
-            const headVaryParams = headVaryParamsThenable !== null ? (0, _varyparamsdecoding.readVaryParams)(headVaryParamsThenable) : 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, pathname, nextUrl);
+            _types.FetchStrategy.LoadingBoundary, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, headVaryParams, serverData.r ?? null, pathname, search, nextUrl, map);
         }
         if (!couldBeIntercepted) {
             // This route will never be intercepted. So we can use this entry for all
@@ -1187,12 +1385,45 @@ async function fetchRouteOnCacheMiss(entry, key) {
         };
     } catch (error) {
         // Either the connection itself failed, or something bad happened while
-        // decoding the response.
+        // 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);
         return null;
     }
 }
-async function fetchSegmentOnCacheMiss(route, segmentCacheEntry, routeKey, tree) {
+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
+// finishes.
+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
+// identical either way; this only decides which payload of the response
+// fulfills the entries.
+fetchStrategy) {
     // 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
@@ -1200,6 +1431,68 @@ async function fetchSegmentOnCacheMiss(route, segmentCacheEntry, routeKey, tree)
     //
     // Segment fetches are non-blocking so we don't need to ping the scheduler
     // on completion.
+    let result;
+    try {
+        result = await fetchSegmentsOnCacheMissImpl(route, routeKey, tree);
+    } 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);
+        return null;
+    }
+    if (result === 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);
+        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
+    };
+}
+/**
+ * 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.
+ *
+ * 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) {
     // 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
@@ -1221,156 +1514,423 @@ async function fetchSegmentOnCacheMiss(route, segmentCacheEntry, routeKey, tree)
     if (nextUrl !== null) {
         headers[_approuterheaders.NEXT_URL] = nextUrl;
     }
-    // Tell the server to perform a static pre-render for the Instant Navigation
-    // Testing API. Static pre-renders don't normally happen during development.
-    addInstantPrefetchHeaderIfLocked(headers);
     const requestUrl = isOutputExportMode ? addSegmentPathToUrlInOutputExportMode(url, normalizedRequestKey) : url;
-    try {
-        const response = await fetchPrefetchResponse(requestUrl, headers);
-        if (!response || !response.ok || response.status === 204 || // Cache miss
-        // 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) {
-            // Server responded with an error, or with a miss. We should still cache
-            // the response, but we can try again after 10 seconds.
-            rejectSegmentCacheEntry(segmentCacheEntry, Date.now() + 10 * 1000);
-            return null;
-        }
-        // See TODO in fetchRouteOnCacheMiss about removing `closed` for
-        // buffered prefetch paths.
-        const closed = (0, _promisewithresolvers.createPromiseWithResolvers)();
-        const { stream: prefetchStream, size: responseSize } = await createNonTaskyPrefetchResponseStream(response.body);
-        closed.resolve();
-        (0, _cachemap.setSizeInCacheMap)(segmentCacheEntry, 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.
-            rejectSegmentCacheEntry(segmentCacheEntry, Date.now() + 10 * 1000);
-            return null;
-        }
-        const now = Date.now();
-        const staleAt = now + getStaleTimeMs(serverData.staleTime);
-        const fulfilledEntry = fulfillSegmentCacheEntry(segmentCacheEntry, serverData.rsc, staleAt, serverData.isPartial);
-        // If the server tells us which params the segment varies by, we can re-key
-        // the entry to a more generic vary path. This allows the entry to be reused
-        // across different param values for params that the segment doesn't
-        // actually depend on.
-        const varyParams = serverData.varyParams;
-        const fulfilledVaryPath = process.env.__NEXT_VARY_PARAMS && varyParams !== null ? (0, _varypath.getFulfilledSegmentVaryPath)(tree.varyPath, varyParams) : (0, _varypath.getSegmentVaryPathForRequest)(segmentCacheEntry.fetchStrategy, tree);
-        // Re-key and upsert the entry at the fulfilled vary path. This ensures
-        // the entry is stored at the most generic path possible based on which
-        // params the segment actually depends on.
-        upsertSegmentEntry(now, fulfilledVaryPath, fulfilledEntry);
-        return {
-            value: fulfilledEntry,
-            // Return a promise that resolves when the network connection closes, so
-            // the scheduler can track the number of concurrent network connections.
-            closed: closed.promise
-        };
-    } catch (error) {
-        // Either the connection itself failed, or something bad happened while
-        // decoding the response.
-        rejectSegmentCacheEntry(segmentCacheEntry, Date.now() + 10 * 1000);
+    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) {
+        // Server responded with an error or a miss — fetched but not usable.
         return null;
     }
-}
-async function fetchInlinedSegmentsOnCacheMiss(route, routeKey, tree, spawnedEntries) {
-    // When prefetch inlining is enabled, all segment data for a route is bundled
-    // into a single /_inlined response instead of individual per-segment
-    // requests. This function fetches that response and walks the tree to fill
-    // all segment cache entries at once.
-    const url = new URL(route.canonicalUrl, location.origin);
-    const nextUrl = routeKey.nextUrl;
-    const headers = {
-        [_approuterheaders.RSC_HEADER]: '1',
-        [_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER]: '1',
-        [_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER]: '/' + _segment.PAGE_SEGMENT_KEY
-    };
-    if (nextUrl !== null) {
-        headers[_approuterheaders.NEXT_URL] = nextUrl;
+    // 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) {
+        return null;
     }
-    addInstantPrefetchHeaderIfLocked(headers);
-    try {
-        const response = await fetchPrefetchResponse(url, headers);
-        if (!response || !response.ok || response.status === 204 || response.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER) !== '2' && !isOutputExportMode || !response.body) {
-            rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
-            return null;
+    if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverResponse.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.
+        return null;
+    }
+    // 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
+    // variant: each segment's param-dependent rows land past the boundary and
+    // decode as still-pending, which renders as the param fallback. It also
+    // rewinds the response's signals — `needsRuntimeRequest` and `isPartial`
+    // 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);
+    let shellResponse;
+    if (shellOffset === null) {
+        shellResponse = serverResponse;
+    } else if (shellOffset === 0) {
+        shellResponse = null;
+    } else {
+        try {
+            shellResponse = await (0, _fetchserverresponse.decodeBufferedStage)(buffer.subarray(0, shellOffset), headers);
+        } catch  {
+            // The truncated prefix couldn't be decoded. Treat it as if no shell
+            // 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.)
+            shellResponse = null;
         }
-        // See TODO in fetchRouteOnCacheMiss about removing `closed` for
-        // buffered prefetch paths.
-        const closed = (0, _promisewithresolvers.createPromiseWithResolvers)();
-        const { stream: prefetchStream } = await createNonTaskyPrefetchResponseStream(response.body);
-        closed.resolve();
-        const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
-            allowPartialStream: true
-        });
-        if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.tree.segment.buildId) !== (0, _navigationbuildid.getNavigationBuildId)()) {
-            rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
-            return 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);
         }
-        const now = Date.now();
-        // Walk the inlined tree in parallel with the RouteTree and fill
-        // segment cache entries.
-        fillInlinedSegmentEntries(now, route, tree, serverData.tree, spawnedEntries);
-        // Fill the head entry.
-        const headStaleAt = now + getStaleTimeMs(serverData.head.staleTime);
-        const headKey = route.metadata.requestKey;
-        const ownedHeadEntry = spawnedEntries.get(headKey);
-        if (ownedHeadEntry !== undefined) {
-            fulfillSegmentCacheEntry(ownedHeadEntry, serverData.head.rsc, headStaleAt, serverData.head.isPartial);
+        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 {
-            // The head was already cached. Try to upsert if the entry is empty.
-            const existingEntry = readOrCreateSegmentCacheEntry(now, _types.FetchStrategy.PPR, route.metadata);
-            if (existingEntry.status === 0) {
-                fulfillSegmentCacheEntry(upgradeToPendingSegment(existingEntry, _types.FetchStrategy.PPR), serverData.head.rsc, headStaleAt, serverData.head.isPartial);
+            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;
         }
-        // Reject any remaining entries that were not fulfilled by the response.
-        rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
-        return {
-            value: null,
-            closed: closed.promise
+        // 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
         };
-    } catch (error) {
-        rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
-        return null;
+        clonedTail.parent = clonedNode;
+        clonedTail = clonedNode;
+        node = node.parent;
     }
+    return head;
 }
-function fillInlinedSegmentEntries(now, route, tree, inlinedNode, spawnedEntries) {
-    // Check if the spawned entries map has an entry for this segment's key.
-    const segment = inlinedNode.segment;
-    const staleAt = now + getStaleTimeMs(segment.staleTime);
-    const ownedEntry = spawnedEntries.get(tree.requestKey);
-    if (ownedEntry !== undefined) {
-        // We own this entry. Fulfill it directly.
-        fulfillSegmentCacheEntry(ownedEntry, segment.rsc, staleAt, segment.isPartial);
-    } else {
-        // Not owned by us — this is extra data from the inlined response for a
-        // segment that was already cached. Try to upsert if the entry is empty.
-        const existingEntry = readOrCreateSegmentCacheEntry(now, _types.FetchStrategy.PPR, tree);
-        if (existingEntry.status === 0) {
-            fulfillSegmentCacheEntry(upgradeToPendingSegment(existingEntry, _types.FetchStrategy.PPR), segment.rsc, staleAt, segment.isPartial);
+// 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;
+}
+/**
+ * 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.
+ *
+ * For the one response kind that isn't buffered when read — a dynamic `Full`
+ * response (fetchStrategy.Full with Partial Prefetching disabled) — use
+ * `resolveStaleAt` instead, since its values aren't materialized synchronously.
+ */ function readFulfilledStaleAt(now, staleTime) {
+    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;
     }
-    // Recurse into children.
-    if (tree.slots !== null && inlinedNode.slots !== null) {
-        for(const parallelRouteKey in tree.slots){
-            const childTree = tree.slots[parallelRouteKey];
-            const childInlinedNode = inlinedNode.slots[parallelRouteKey];
-            if (childInlinedNode !== undefined) {
-                fillInlinedSegmentEntries(now, route, childTree, childInlinedNode, spawnedEntries);
-            }
+    if (staleTimeSeconds === undefined || isNaN(staleTimeSeconds)) {
+        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.
+ *
+ * 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.
+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;
+        try {
+            result = await fetchSegmentsOnCacheMissImpl(route, routeKey, tree);
+        } catch  {
+            break;
+        }
+        if (task.isCanceled) {
+            break;
+        }
+        if (result === null) {
+            continue;
         }
+        if (result.serverResponse.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);
+        task.fallbackRetryStatus = _cachemap.EntryStatus.Fulfilled;
+        (0, _scheduler.pingPrefetchTask)(task);
+        return;
     }
+    // The loop finished without success (exhausted its retries, broke out on a
+    // 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) {
     const key = task.key;
@@ -1379,6 +1939,9 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
     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.
         dynamicRequestTree = MetadataOnlyRequestTree;
     }
     const headers = {
@@ -1398,6 +1961,11 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
                 headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] = '2';
                 break;
             }
+        case _types.FetchStrategy.RuntimeShell:
+            {
+                headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] = '3';
+                break;
+            }
         case _types.FetchStrategy.LoadingBoundary:
             {
                 headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] = '1';
@@ -1466,27 +2034,125 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
             }),
             response.cacheData
         ]);
-        // Read head vary params synchronously. Individual segments carry their
-        // own thenables in CacheNodeSeedData.
-        const headVaryParamsThenable = serverData.h;
-        const headVaryParams = headVaryParamsThenable !== null ? (0, _varyparamsdecoding.readVaryParams)(headVaryParamsThenable) : null;
         const now = Date.now();
-        const staleAt = await getStaleAt(now, serverData.s, response);
-        // PPRRuntime prefetches are partial when the server marks the response
-        // as '~' (Partial). Full/LoadingBoundary prefetches are always complete.
-        const isResponsePartial = fetchStrategy === _types.FetchStrategy.PPRRuntime && (cacheData?.isResponsePartial ?? false);
-        // 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.
+        const staleAt = await resolveStaleAt(now, serverData.s, response);
         const buildId = response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.b;
-        const flightDatas = (0, _flightdatahelpers.normalizeFlightData)(serverData.f);
+        // 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);
-        fulfilledEntries = writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, staleAt, navigationSeed, spawnedEntries);
+        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) {
@@ -1502,11 +2168,23 @@ 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);
         return null;
     }
 }
-function writeDynamicTreeResponseIntoCache(now, fetchStrategy, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, headVaryParams, originalPathname, nextUrl) {
+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
@@ -1532,7 +2210,8 @@ function writeDynamicTreeResponseIntoCache(now, fetchStrategy, response, serverD
     // During this traversal, we accumulate additional data into this
     // "accumulator" object.
     const acc = {
-        metadataVaryPath: null
+        metadataVaryPath: null,
+        treeDivergedFromBase: false
     };
     const routeTree = convertRootFlightRouterStateToRouteTree(flightRouterState, renderedSearch, acc);
     const metadataVaryPath = acc.metadataVaryPath;
@@ -1540,7 +2219,7 @@ function writeDynamicTreeResponseIntoCache(now, fetchStrategy, response, serverD
         rejectRouteCacheEntry(entry, now + 10 * 1000);
         return;
     }
-    (0, _optimisticroutes.discoverKnownRoute)(now, originalPathname, nextUrl, entry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, false // hasDynamicRewrite
+    (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.
@@ -1549,20 +2228,25 @@ function writeDynamicTreeResponseIntoCache(now, fetchStrategy, response, serverD
     // 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, getStaleAtFromHeader(now, response), navigationSeed, null);
+    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 === 1) {
+        if (entry.status === _cachemap.EntryStatus.Pending) {
             rejectSegmentCacheEntry(entry, staleAt);
-        } else if (entry.status === 2) {
+        } else if (entry.status === _cachemap.EntryStatus.Fulfilled) {
             fulfilledEntries.push(entry);
         }
     }
     return fulfilledEntries;
 }
-function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, staleAt, navigationSeed, spawnedEntries) {
+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
+// 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) {
     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.
@@ -1587,8 +2271,9 @@ function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, bu
             let tree = routeTree;
             for(let i = 0; i < segmentPath.length; i += 2){
                 const parallelRouteKey = segmentPath[i];
-                if (tree?.slots?.[parallelRouteKey] !== undefined) {
-                    tree = tree.slots[parallelRouteKey];
+                const childTree = tree?.slots?.get(parallelRouteKey);
+                if (childTree !== undefined) {
+                    tree = childTree;
                 } else {
                     if (spawnedEntries !== null) {
                         rejectSegmentEntriesIfStillPending(spawnedEntries, now + 10 * 1000);
@@ -1596,20 +2281,28 @@ function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, bu
                     return null;
                 }
             }
-            writeSeedDataIntoCache(now, fetchStrategy, tree, staleAt, seedData, isResponsePartial, spawnedEntries);
+            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 head = flightDataEntry.head;
         if (head !== null && metadataTree !== null) {
-            // When Cache Components is enabled, the server conservatively marks
-            // the head as partial during static generation (isPossiblyPartialHead
-            // in app-render.tsx), even for fully static pages where the head is
-            // actually complete. When the response is non-partial, we override
-            // this since the server confirmed no dynamic content exists.
+            // 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 always sends the correct
-            // isHeadPartial value, so no override is needed.
-            const isHeadPartial = !isResponsePartial && process.env.__NEXT_CACHE_COMPONENTS ? false : flightDataEntry.isHeadPartial;
-            fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, head, isHeadPartial, staleAt, // For head entries, use the head-specific vary params passed as
+            // 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);
         }
@@ -1628,64 +2321,117 @@ function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, bu
     }
     return null;
 }
-function writeSeedDataIntoCache(now, fetchStrategy, tree, staleAt, seedData, isResponsePartial, entriesOwnedByCurrentTask) {
+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;
-    const varyParamsThenable = seedData[4];
-    // Each segment carries its own vary params thenable in the seed data. The
-    // thenable resolves to the set of params the segment accessed during render.
-    // A null thenable means tracking was not enabled (not a prerender).
-    const varyParams = varyParamsThenable !== null ? (0, _varyparamsdecoding.readVaryParams)(varyParamsThenable) : null;
-    fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, rsc, isPartial, staleAt, varyParams, tree, entriesOwnedByCurrentTask);
+    // 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 in slots){
-            const childTree = slots[parallelRouteKey];
+        for (const [parallelRouteKey, childTree] of slots){
             const childSeedData = seedDataChildren[parallelRouteKey];
             if (childSeedData !== null && childSeedData !== undefined) {
-                writeSeedDataIntoCache(now, fetchStrategy, childTree, staleAt, childSeedData, isResponsePartial, entriesOwnedByCurrentTask);
+                writeSeedDataIntoCache(now, map, fetchStrategy, childTree, staleAt, childSeedData, isResponsePartial, rootVaryParamsIterable, entriesOwnedByCurrentTask);
             }
         }
     }
 }
-function fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, rsc, isPartial, staleAt, segmentVaryParams, tree, entriesOwnedByCurrentTask) {
+function fulfillEntrySpawnedByRuntimePrefetch(now, map, fetchStrategy, rsc, isPartial, staleAt, segmentVaryParams, tree, entriesOwnedByCurrentTask) {
+    // Decide whether to re-key the entry under a more generic vary path based on
+    // which params the segment actually depends on.
+    //
+    // Skip re-keying for Full prefetches: as of today, `varyParams` tracking only
+    // works within the static stage portion of a response. A Full prefetch
+    // response covers all stages, and we can't track params during the dynamic
+    // stage without dead-locking the Flight stream, so the server-reported set is
+    // incomplete and can't be trusted for the full response. Re-keying with an
+    // 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.
+    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);
+        }
+    }
     // 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);
-        // Re-key the entry based on which params the segment actually depends on.
-        if (process.env.__NEXT_VARY_PARAMS && segmentVaryParams !== null) {
-            const fulfilledVaryPath = (0, _varypath.getFulfilledSegmentVaryPath)(tree.varyPath, segmentVaryParams);
+        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)(segmentCacheMap, fulfilledVaryPath, fulfilledEntry, isRevalidation);
+            (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);
         }
     } else {
         // There's no matching entry. Attempt to create a new one.
-        const possiblyNewEntry = readOrCreateSegmentCacheEntry(now, fetchStrategy, tree);
-        if (possiblyNewEntry.status === 0) {
+        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);
-            // Re-key the entry based on which params the segment actually depends on.
-            if (process.env.__NEXT_VARY_PARAMS && segmentVaryParams !== null) {
-                const fulfilledVaryPath = (0, _varypath.getFulfilledSegmentVaryPath)(tree.varyPath, segmentVaryParams);
+            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)(segmentCacheMap, fulfilledVaryPath, fulfilledEntry, isRevalidation);
+                (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);
-            // Use the fulfilled vary path if available, otherwise fall back to
-            // the request vary path.
-            const varyPath = process.env.__NEXT_VARY_PARAMS && segmentVaryParams !== null ? (0, _varypath.getFulfilledSegmentVaryPath)(tree.varyPath, segmentVaryParams) : (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
-            upsertSegmentEntry(now, varyPath, newEntry);
+            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);
         }
     }
 }
@@ -1715,7 +2461,7 @@ async function fetchPrefetchResponse(url, headers) {
     }
     return response;
 }
-async function createNonTaskyPrefetchResponseStream(body) {
+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
@@ -1727,13 +2473,22 @@ async function createNonTaskyPrefetchResponseStream(body) {
     // These could all be consolidated into a single transformation. Refactor
     // once the cached navigations experiment lands.
     //
-    // Read the entire response from the network.
+    // Read the response from the network, optionally truncating at byteLimit.
     const reader = body.getReader();
     const chunks = [];
     let size = 0;
     while(true){
         const { done, value } = await reader.read();
         if (done) break;
+        if (byteLimit !== undefined && size + value.byteLength >= byteLimit) {
+            const remaining = byteLimit - size;
+            if (remaining > 0) {
+                chunks.push(value.byteLength > remaining ? value.subarray(0, remaining) : value);
+                size += remaining;
+            }
+            reader.cancel();
+            break;
+        }
         chunks.push(value);
         size += value.byteLength;
     }
@@ -1767,7 +2522,8 @@ async function createNonTaskyPrefetchResponseStream(body) {
     });
     return {
         stream,
-        size
+        size,
+        buffer
     };
 }
 /**
@@ -1816,23 +2572,12 @@ function addSegmentPathToUrlInOutputExportMode(url, segmentPath) {
 function canNewFetchStrategyProvideMoreContent(currentStrategy, newStrategy) {
     return currentStrategy < newStrategy;
 }
-/**
- * Adds the instant prefetch header if the navigation lock is active.
- * Uses a lazy require to ensure dead code elimination.
- */ function addInstantPrefetchHeaderIfLocked(headers) {
-    if (process.env.__NEXT_EXPOSE_TESTING_API) {
-        const { isNavigationLocked } = require('./navigation-testing-lock');
-        if (isNavigationLocked()) {
-            headers[_approuterheaders.NEXT_INSTANT_PREFETCH_HEADER] = '1';
-        }
-    }
-}
 function getStaleAtFromHeader(now, response) {
     const staleTimeSeconds = parseInt(response.headers.get(_approuterheaders.NEXT_ROUTER_STALE_TIME_HEADER) ?? '', 10);
     const staleTimeMs = !isNaN(staleTimeSeconds) ? getStaleTimeMs(staleTimeSeconds) : _navigatereducer.STATIC_STALETIME_MS;
     return now + staleTimeMs;
 }
-async function getStaleAt(now, staleTimeIterable, response) {
+async function resolveStaleAt(now, staleTimeIterable, response) {
     if (staleTimeIterable !== undefined) {
         // Iterate the async iterable and take the last yielded value. The server
         // yields updated staleTime values during the render; the last one is the
@@ -1851,25 +2596,30 @@ async function getStaleAt(now, staleTimeIterable, response) {
     }
     return now + _navigatereducer.STATIC_STALETIME_MS;
 }
-function writeStaticStageResponseIntoCache(now, flightData, buildId, headVaryParamsThenable, staleAt, baseTree, renderedSearch, isResponsePartial) {
-    const fetchStrategy = isResponsePartial ? _types.FetchStrategy.PPR : _types.FetchStrategy.Full;
-    const headVaryParams = headVaryParamsThenable !== null ? (0, _varyparamsdecoding.readVaryParams)(headVaryParamsThenable) : null;
+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.
+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, staleAt, navigationSeed, null // spawnedEntries — no pre-created entries; will create or upsert
-    );
+    writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, rootVaryParamsIterable, staleAt, navigationSeed, null, map);
 }
 async function processRuntimePrefetchStream(now, runtimePrefetchStream, baseTree, renderedSearch) {
     const { stream, isPartial } = await stripIsPartialByte(runtimePrefetchStream);
     const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(stream, undefined, {
         allowPartialStream: true
     });
-    const headVaryParamsThenable = serverData.h;
-    const headVaryParams = headVaryParamsThenable !== null ? (0, _varyparamsdecoding.readVaryParams)(headVaryParamsThenable) : null;
-    const staleAt = await getStaleAt(now, serverData.s);
+    // 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;
@@ -1881,6 +2631,7 @@ async function processRuntimePrefetchStream(now, runtimePrefetchStream, baseTree
         buildId: serverData.b,
         isResponsePartial: isPartial,
         headVaryParams,
+        rootVaryParamsIterable,
         staleAt
     };
 }