@semiont/frontend 0.3.3 → 0.3.4

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

@@ -4,26 +4,43 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     EntryStatus: null,
+    attemptToFulfillDynamicSegmentFromBFCache: null,
+    attemptToUpgradeSegmentFromBFCache: null,
     canNewFetchStrategyProvideMoreContent: null,
+    convertReusedFlightRouterStateToRouteTree: null,
+    convertRootFlightRouterStateToRouteTree: null,
     convertRouteTreeToFlightRouterState: null,
     createDetachedSegmentCacheEntry: null,
+    createMetadataRouteTree: null,
+    deprecated_requestOptimisticRouteCacheEntry: null,
+    fetchInlinedSegmentsOnCacheMiss: null,
     fetchRouteOnCacheMiss: null,
     fetchSegmentOnCacheMiss: null,
     fetchSegmentPrefetchesUsingDynamicRequest: null,
-    getCurrentCacheVersion: null,
+    fulfillRouteCacheEntry: null,
+    getCurrentRouteCacheVersion: null,
+    getCurrentSegmentCacheVersion: null,
+    getStaleAt: null,
     getStaleTimeMs: null,
+    invalidateEntirePrefetchCache: null,
+    invalidateRouteCacheEntries: null,
+    invalidateSegmentCacheEntries: null,
+    markRouteEntryAsDynamicRewrite: null,
     overwriteRevalidatingSegmentCacheEntry: null,
     pingInvalidationListeners: null,
+    processRuntimePrefetchStream: null,
     readOrCreateRevalidatingSegmentEntry: null,
     readOrCreateRouteCacheEntry: null,
     readOrCreateSegmentCacheEntry: null,
     readRouteCacheEntry: null,
     readSegmentCacheEntry: null,
-    requestOptimisticRouteCacheEntry: null,
-    revalidateEntireCache: null,
+    stripIsPartialByte: null,
     upgradeToPendingSegment: null,
     upsertSegmentEntry: null,
-    waitForSegmentCacheEntry: null
+    waitForSegmentCacheEntry: null,
+    writeDynamicRenderResponseIntoCache: null,
+    writeRouteIntoCache: null,
+    writeStaticStageResponseIntoCache: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -35,15 +52,36 @@ _export(exports, {
     EntryStatus: function() {
         return EntryStatus;
     },
+    attemptToFulfillDynamicSegmentFromBFCache: function() {
+        return attemptToFulfillDynamicSegmentFromBFCache;
+    },
+    attemptToUpgradeSegmentFromBFCache: function() {
+        return attemptToUpgradeSegmentFromBFCache;
+    },
     canNewFetchStrategyProvideMoreContent: function() {
         return canNewFetchStrategyProvideMoreContent;
     },
+    convertReusedFlightRouterStateToRouteTree: function() {
+        return convertReusedFlightRouterStateToRouteTree;
+    },
+    convertRootFlightRouterStateToRouteTree: function() {
+        return convertRootFlightRouterStateToRouteTree;
+    },
     convertRouteTreeToFlightRouterState: function() {
         return convertRouteTreeToFlightRouterState;
     },
     createDetachedSegmentCacheEntry: function() {
         return createDetachedSegmentCacheEntry;
     },
+    createMetadataRouteTree: function() {
+        return createMetadataRouteTree;
+    },
+    deprecated_requestOptimisticRouteCacheEntry: function() {
+        return deprecated_requestOptimisticRouteCacheEntry;
+    },
+    fetchInlinedSegmentsOnCacheMiss: function() {
+        return fetchInlinedSegmentsOnCacheMiss;
+    },
     fetchRouteOnCacheMiss: function() {
         return fetchRouteOnCacheMiss;
     },
@@ -53,18 +91,42 @@ _export(exports, {
     fetchSegmentPrefetchesUsingDynamicRequest: function() {
         return fetchSegmentPrefetchesUsingDynamicRequest;
     },
-    getCurrentCacheVersion: function() {
-        return getCurrentCacheVersion;
+    fulfillRouteCacheEntry: function() {
+        return fulfillRouteCacheEntry;
+    },
+    getCurrentRouteCacheVersion: function() {
+        return getCurrentRouteCacheVersion;
+    },
+    getCurrentSegmentCacheVersion: function() {
+        return getCurrentSegmentCacheVersion;
+    },
+    getStaleAt: function() {
+        return getStaleAt;
     },
     getStaleTimeMs: function() {
         return getStaleTimeMs;
     },
+    invalidateEntirePrefetchCache: function() {
+        return invalidateEntirePrefetchCache;
+    },
+    invalidateRouteCacheEntries: function() {
+        return invalidateRouteCacheEntries;
+    },
+    invalidateSegmentCacheEntries: function() {
+        return invalidateSegmentCacheEntries;
+    },
+    markRouteEntryAsDynamicRewrite: function() {
+        return markRouteEntryAsDynamicRewrite;
+    },
     overwriteRevalidatingSegmentCacheEntry: function() {
         return overwriteRevalidatingSegmentCacheEntry;
     },
     pingInvalidationListeners: function() {
         return pingInvalidationListeners;
     },
+    processRuntimePrefetchStream: function() {
+        return processRuntimePrefetchStream;
+    },
     readOrCreateRevalidatingSegmentEntry: function() {
         return readOrCreateRevalidatingSegmentEntry;
     },
@@ -80,11 +142,8 @@ _export(exports, {
     readSegmentCacheEntry: function() {
         return readSegmentCacheEntry;
     },
-    requestOptimisticRouteCacheEntry: function() {
-        return requestOptimisticRouteCacheEntry;
-    },
-    revalidateEntireCache: function() {
-        return revalidateEntireCache;
+    stripIsPartialByte: function() {
+        return stripIsPartialByte;
     },
     upgradeToPendingSegment: function() {
         return upgradeToPendingSegment;
@@ -94,14 +153,22 @@ _export(exports, {
     },
     waitForSegmentCacheEntry: function() {
         return waitForSegmentCacheEntry;
+    },
+    writeDynamicRenderResponseIntoCache: function() {
+        return writeDynamicRenderResponseIntoCache;
+    },
+    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 _scheduler = require("./scheduler");
 const _varypath = require("./vary-path");
-const _appbuildid = require("../../app-build-id");
 const _createhreffromurl = require("../router-reducer/create-href-from-url");
 const _cachekey = require("./cache-key");
 const _routeparams = require("../../route-params");
@@ -113,6 +180,11 @@ const _links = require("../links");
 const _segment = require("../../../shared/lib/segment");
 const _types = require("./types");
 const _promisewithresolvers = require("../../../shared/lib/promise-with-resolvers");
+const _bfcache = require("./bfcache");
+const _optimisticroutes = require("./optimistic-routes");
+const _navigation = require("./navigation");
+const _navigationbuildid = require("../../navigation-build-id");
+const _constants = require("../../../lib/constants");
 function getStaleTimeMs(staleTimeSeconds) {
     return Math.max(staleTimeSeconds, 30) * 1000;
 }
@@ -139,26 +211,32 @@ let segmentCacheMap = (0, _cachemap.createCacheMap)();
 // the listeners and allow the caller to poll the prefetch cache with a new
 // prefetch task if desired.
 let invalidationListeners = null;
-// Incrementing counter used to track cache invalidations.
-let currentCacheVersion = 0;
-function getCurrentCacheVersion() {
-    return currentCacheVersion;
+// Incrementing counters used to track cache invalidations. Route and segment
+// caches have separate versions so they can be invalidated independently.
+// Invalidation does not eagerly evict anything from the cache; entries are
+// lazily evicted when read.
+let currentRouteCacheVersion = 0;
+let currentSegmentCacheVersion = 0;
+function getCurrentRouteCacheVersion() {
+    return currentRouteCacheVersion;
+}
+function getCurrentSegmentCacheVersion() {
+    return currentSegmentCacheVersion;
+}
+function invalidateEntirePrefetchCache(nextUrl, tree) {
+    currentRouteCacheVersion++;
+    currentSegmentCacheVersion++;
+    (0, _links.pingVisibleLinks)(nextUrl, tree);
+    pingInvalidationListeners(nextUrl, tree);
 }
-function revalidateEntireCache(nextUrl, tree) {
-    // Increment the current cache version. This does not eagerly evict anything
-    // from the cache, but because all the entries are versioned, and we check
-    // the version when reading from the cache, this effectively causes all
-    // entries to be evicted lazily. We do it lazily because in the future,
-    // actions like revalidateTag or refresh will not evict the entire cache,
-    // but rather some subset of the entries.
-    currentCacheVersion++;
-    // Start a cooldown before re-prefetching to allow CDN cache propagation.
-    (0, _scheduler.startRevalidationCooldown)();
-    // Prefetch all the currently visible links again, to re-fill the cache.
+function invalidateRouteCacheEntries(nextUrl, tree) {
+    currentRouteCacheVersion++;
+    (0, _links.pingVisibleLinks)(nextUrl, tree);
+    pingInvalidationListeners(nextUrl, tree);
+}
+function invalidateSegmentCacheEntries(nextUrl, tree) {
+    currentSegmentCacheVersion++;
     (0, _links.pingVisibleLinks)(nextUrl, tree);
-    // Similarly, notify all invalidation listeners (i.e. those passed to
-    // `router.prefetch(onInvalidate)`), so they can trigger a new prefetch
-    // if needed.
     pingInvalidationListeners(nextUrl, tree);
 }
 function attachInvalidationListener(task) {
@@ -213,15 +291,24 @@ function pingInvalidationListeners(nextUrl, tree) {
 function readRouteCacheEntry(now, key) {
     const varyPath = (0, _varypath.getRouteVaryPath)(key.pathname, key.search, key.nextUrl);
     const isRevalidation = false;
-    return (0, _cachemap.getFromCacheMap)(now, getCurrentCacheVersion(), routeCacheMap, varyPath, isRevalidation);
+    const existingEntry = (0, _cachemap.getFromCacheMap)(now, getCurrentRouteCacheVersion(), routeCacheMap, varyPath, isRevalidation);
+    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 null;
 }
 function readSegmentCacheEntry(now, varyPath) {
     const isRevalidation = false;
-    return (0, _cachemap.getFromCacheMap)(now, getCurrentCacheVersion(), segmentCacheMap, varyPath, isRevalidation);
+    return (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), segmentCacheMap, varyPath, isRevalidation);
 }
 function readRevalidatingSegmentCacheEntry(now, varyPath) {
     const isRevalidation = true;
-    return (0, _cachemap.getFromCacheMap)(now, getCurrentCacheVersion(), segmentCacheMap, varyPath, isRevalidation);
+    return (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), segmentCacheMap, varyPath, isRevalidation);
 }
 function waitForSegmentCacheEntry(pendingEntry) {
     // Because the entry is pending, there's already a in-progress request.
@@ -234,14 +321,8 @@ function waitForSegmentCacheEntry(pendingEntry) {
     }
     return promiseWithResolvers.promise;
 }
-function readOrCreateRouteCacheEntry(now, task, key) {
-    attachInvalidationListener(task);
-    const existingEntry = readRouteCacheEntry(now, key);
-    if (existingEntry !== null) {
-        return existingEntry;
-    }
-    // Create a pending entry and add it to the cache.
-    const pendingEntry = {
+function createDetachedRouteCacheEntry() {
+    return {
         canonicalUrl: null,
         status: 0,
         blockedTasks: null,
@@ -252,7 +333,7 @@ function readOrCreateRouteCacheEntry(now, task, key) {
         // from the server.
         couldBeIntercepted: true,
         // Similarly, we don't yet know if the route supports PPR.
-        isPPREnabled: false,
+        supportsPerSegmentPrefetching: false,
         renderedSearch: null,
         // Map-related fields
         ref: null,
@@ -260,14 +341,23 @@ function readOrCreateRouteCacheEntry(now, task, key) {
         // Since this is an empty entry, there's no reason to ever evict it. It will
         // be updated when the data is populated.
         staleAt: Infinity,
-        version: getCurrentCacheVersion()
+        version: getCurrentRouteCacheVersion()
     };
+}
+function readOrCreateRouteCacheEntry(now, task, key) {
+    attachInvalidationListener(task);
+    const existingEntry = readRouteCacheEntry(now, key);
+    if (existingEntry !== null) {
+        return existingEntry;
+    }
+    // Create a pending entry and add it to the cache.
+    const pendingEntry = createDetachedRouteCacheEntry();
     const varyPath = (0, _varypath.getRouteVaryPath)(key.pathname, key.search, key.nextUrl);
     const isRevalidation = false;
     (0, _cachemap.setInCacheMap)(routeCacheMap, varyPath, pendingEntry, isRevalidation);
     return pendingEntry;
 }
-function requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl) {
+function deprecated_requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl) {
     // This function is called during a navigation when there was no matching
     // route tree in the prefetch cache. Before de-opting to a blocking,
     // unprefetched navigation, we will first attempt to construct an "optimistic"
@@ -321,8 +411,8 @@ function requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl) {
     const optimisticUrl = new URL(routeWithNoSearchParams.canonicalUrl, location.origin);
     optimisticUrl.search = optimisticCanonicalSearch;
     const optimisticCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(optimisticUrl);
-    const optimisticRouteTree = createOptimisticRouteTree(routeWithNoSearchParams.tree, optimisticRenderedSearch);
-    const optimisticMetadataTree = createOptimisticRouteTree(routeWithNoSearchParams.metadata, optimisticRenderedSearch);
+    const optimisticRouteTree = deprecated_createOptimisticRouteTree(routeWithNoSearchParams.tree, optimisticRenderedSearch);
+    const optimisticMetadataTree = deprecated_createOptimisticRouteTree(routeWithNoSearchParams.metadata, optimisticRenderedSearch);
     // Clone the base route tree, and override the relevant fields with our
     // optimistic values.
     const optimisticEntry = {
@@ -333,7 +423,8 @@ function requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl) {
         tree: optimisticRouteTree,
         metadata: optimisticMetadataTree,
         couldBeIntercepted: routeWithNoSearchParams.couldBeIntercepted,
-        isPPREnabled: routeWithNoSearchParams.isPPREnabled,
+        supportsPerSegmentPrefetching: routeWithNoSearchParams.supportsPerSegmentPrefetching,
+        hasDynamicRewrite: routeWithNoSearchParams.hasDynamicRewrite,
         // Override the rendered search with the optimistic value.
         renderedSearch: optimisticRenderedSearch,
         // Map-related fields
@@ -346,7 +437,7 @@ function requestOptimisticRouteCacheEntry(now, requestedUrl, nextUrl) {
     // perform the current navigation. Just return it to the caller.
     return optimisticEntry;
 }
-function createOptimisticRouteTree(tree, newRenderedSearch) {
+function deprecated_createOptimisticRouteTree(tree, newRenderedSearch) {
     // Create a new route tree that identical to the original one except for
     // the rendered search string, which is contained in the vary path.
     let clonedSlots = null;
@@ -355,7 +446,7 @@ function createOptimisticRouteTree(tree, newRenderedSearch) {
         clonedSlots = {};
         for(const parallelRouteKey in originalSlots){
             const childTree = originalSlots[parallelRouteKey];
-            clonedSlots[parallelRouteKey] = createOptimisticRouteTree(childTree, newRenderedSearch);
+            clonedSlots[parallelRouteKey] = deprecated_createOptimisticRouteTree(childTree, newRenderedSearch);
         }
     }
     // We only need to clone the vary path if the route is a page.
@@ -363,38 +454,38 @@ function createOptimisticRouteTree(tree, newRenderedSearch) {
         return {
             requestKey: tree.requestKey,
             segment: tree.segment,
+            refreshState: tree.refreshState,
             varyPath: (0, _varypath.clonePageVaryPathWithNewSearchParams)(tree.varyPath, newRenderedSearch),
             isPage: true,
             slots: clonedSlots,
-            isRootLayout: tree.isRootLayout,
-            hasLoadingBoundary: tree.hasLoadingBoundary,
-            hasRuntimePrefetch: tree.hasRuntimePrefetch
+            prefetchHints: tree.prefetchHints
         };
     }
     return {
         requestKey: tree.requestKey,
         segment: tree.segment,
+        refreshState: tree.refreshState,
         varyPath: tree.varyPath,
         isPage: false,
         slots: clonedSlots,
-        isRootLayout: tree.isRootLayout,
-        hasLoadingBoundary: tree.hasLoadingBoundary,
-        hasRuntimePrefetch: tree.hasRuntimePrefetch
+        prefetchHints: tree.prefetchHints
     };
 }
-function readOrCreateSegmentCacheEntry(now, fetchStrategy, route, tree) {
+function readOrCreateSegmentCacheEntry(now, fetchStrategy, tree) {
     const existingEntry = readSegmentCacheEntry(now, tree.varyPath);
     if (existingEntry !== null) {
         return existingEntry;
     }
-    // Create a pending entry and add it to the cache.
+    // 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.
     const varyPathForRequest = (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
-    const pendingEntry = createDetachedSegmentCacheEntry(route.staleAt);
+    const pendingEntry = createDetachedSegmentCacheEntry(now);
     const isRevalidation = false;
     (0, _cachemap.setInCacheMap)(segmentCacheMap, varyPathForRequest, pendingEntry, isRevalidation);
     return pendingEntry;
 }
-function readOrCreateRevalidatingSegmentEntry(now, fetchStrategy, route, tree) {
+function readOrCreateRevalidatingSegmentEntry(now, 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
@@ -425,19 +516,23 @@ function readOrCreateRevalidatingSegmentEntry(now, fetchStrategy, route, tree) {
     if (existingEntry !== null) {
         return existingEntry;
     }
-    // Create a pending entry and add it to the cache.
+    // 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.
     const varyPathForRequest = (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
-    const pendingEntry = createDetachedSegmentCacheEntry(route.staleAt);
+    const pendingEntry = createDetachedSegmentCacheEntry(now);
     const isRevalidation = true;
     (0, _cachemap.setInCacheMap)(segmentCacheMap, varyPathForRequest, pendingEntry, isRevalidation);
     return pendingEntry;
 }
-function overwriteRevalidatingSegmentCacheEntry(fetchStrategy, route, tree) {
+function overwriteRevalidatingSegmentCacheEntry(now, 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.
+    // overwriting the previous value. 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.
     const varyPathForRequest = (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree);
-    const pendingEntry = createDetachedSegmentCacheEntry(route.staleAt);
+    const pendingEntry = createDetachedSegmentCacheEntry(now);
     const isRevalidation = true;
     (0, _cachemap.setInCacheMap)(segmentCacheMap, varyPathForRequest, pendingEntry, isRevalidation);
     return pendingEntry;
@@ -449,7 +544,7 @@ function upsertSegmentEntry(now, varyPath, candidateEntry) {
     // TODO: We should not upsert an entry if its key was invalidated in the time
     // since the request was made. We can do that by passing the "owner" entry to
     // this function and confirming it's the same as `existingEntry`.
-    if ((0, _cachemap.isValueExpired)(now, getCurrentCacheVersion(), candidateEntry)) {
+    if ((0, _cachemap.isValueExpired)(now, getCurrentSegmentCacheVersion(), candidateEntry)) {
         // The entry is expired. We cannot upsert it.
         return null;
     }
@@ -470,7 +565,6 @@ function upsertSegmentEntry(now, varyPath, candidateEntry) {
             // the entry expires.
             const rejectedEntry = candidateEntry;
             rejectedEntry.status = 3;
-            rejectedEntry.loading = null;
             rejectedEntry.rsc = null;
             return null;
         }
@@ -481,14 +575,16 @@ function upsertSegmentEntry(now, varyPath, candidateEntry) {
     (0, _cachemap.setInCacheMap)(segmentCacheMap, varyPath, candidateEntry, isRevalidation);
     return candidateEntry;
 }
-function createDetachedSegmentCacheEntry(staleAt) {
+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,
         // 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,
-        loading: null,
         isPartial: true,
         promise: null,
         // Map-related fields
@@ -510,13 +606,60 @@ function upgradeToPendingSegment(emptyEntry, fetchStrategy) {
         pendingEntry.isPartial = false;
     }
     // Set the version here, since this is right before the request is initiated.
-    // The next time the global cache version is incremented, the entry will
+    // The next time the segment cache version is incremented, the entry will
     // effectively be evicted. This happens before initiating the request, rather
     // than when receiving the response, because it's guaranteed to happen
     // before the data is read on the server.
-    pendingEntry.version = getCurrentCacheVersion();
+    pendingEntry.version = getCurrentSegmentCacheVersion();
     return pendingEntry;
 }
+function attemptToFulfillDynamicSegmentFromBFCache(now, segment, tree) {
+    // Attempts to fulfill an empty segment cache entry using data from the
+    // bfcache. This is only valid during a Full prefetch (i.e. one that includes
+    // dynamic data), because the bfcache stores data from navigations which
+    // always include dynamic data.
+    // We always use the canonical vary path when checking the bfcache. This is
+    // the same operation we'd use to access the cache during a
+    // regular navigation.
+    const varyPath = tree.varyPath;
+    // Read from the BFCache without expiring it (pass -1). We check freshness
+    // ourselves using navigatedAt, because the BFCache's staleAt may have been
+    // overridden by a per-page unstable_dynamicStaleTime and can't be used to
+    // derive the original request time.
+    const bfcacheEntry = (0, _bfcache.readFromBFCache)(varyPath);
+    if (bfcacheEntry !== null) {
+        // The stale time for dynamic prefetches (default: 5 mins) is different
+        // from the stale time for regular navigations (default: 0 secs). Use
+        // navigatedAt to compute the correct expiry for prefetch purposes.
+        const dynamicPrefetchStaleAt = bfcacheEntry.navigatedAt + _navigatereducer.STATIC_STALETIME_MS;
+        if (now > dynamicPrefetchStaleAt) {
+            return null;
+        }
+        const pendingSegment = upgradeToPendingSegment(segment, _types.FetchStrategy.Full);
+        const isPartial = false;
+        return fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial);
+    }
+    return null;
+}
+function attemptToUpgradeSegmentFromBFCache(now, tree) {
+    const varyPath = tree.varyPath;
+    const bfcacheEntry = (0, _bfcache.readFromBFCache)(varyPath);
+    if (bfcacheEntry !== null) {
+        const dynamicPrefetchStaleAt = bfcacheEntry.navigatedAt + _navigatereducer.STATIC_STALETIME_MS;
+        if (now > dynamicPrefetchStaleAt) {
+            return null;
+        }
+        const pendingSegment = upgradeToPendingSegment(createDetachedSegmentCacheEntry(now), _types.FetchStrategy.Full);
+        const isPartial = false;
+        const newEntry = fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial);
+        const segmentVaryPath = (0, _varypath.getSegmentVaryPathForRequest)(_types.FetchStrategy.Full, tree);
+        const upserted = upsertSegmentEntry(now, segmentVaryPath, newEntry);
+        if (upserted !== null && upserted.status === 2) {
+            return upserted;
+        }
+    }
+    return null;
+}
 function pingBlockedTasks(entry) {
     const blockedTasks = entry.blockedTasks;
     if (blockedTasks !== null) {
@@ -526,7 +669,7 @@ function pingBlockedTasks(entry) {
         entry.blockedTasks = null;
     }
 }
-function fulfillRouteCacheEntry(entry, tree, metadataVaryPath, staleAt, couldBeIntercepted, canonicalUrl, renderedSearch, isPPREnabled) {
+function createMetadataRouteTree(metadataVaryPath) {
     // The Head is not actually part of the route tree, but other than that, it's
     // fetched and cached like a segment. Some functions expect a RouteTree
     // object, so rather than fork the logic in all those places, we use this
@@ -534,33 +677,56 @@ function fulfillRouteCacheEntry(entry, tree, metadataVaryPath, staleAt, couldBeI
     const metadata = {
         requestKey: _segmentvalueencoding.HEAD_REQUEST_KEY,
         segment: _segmentvalueencoding.HEAD_REQUEST_KEY,
+        refreshState: null,
         varyPath: metadataVaryPath,
         // The metadata isn't really a "page" (though it isn't really a "segment"
         // either) but for the purposes of how this field is used, it behaves like
         // one. If this logic ever gets more complex we can change this to an enum.
         isPage: true,
         slots: null,
-        isRootLayout: false,
-        hasLoadingBoundary: _approutertypes.HasLoadingBoundary.SubtreeHasNoLoadingBoundary,
-        hasRuntimePrefetch: false
+        prefetchHints: 0
     };
+    return metadata;
+}
+function fulfillRouteCacheEntry(now, entry, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching) {
+    // Get the rendered search from the vary path
+    const renderedSearch = (0, _varypath.getRenderedSearchFromVaryPath)(metadataVaryPath) ?? '';
     const fulfilledEntry = entry;
     fulfilledEntry.status = 2;
     fulfilledEntry.tree = tree;
-    fulfilledEntry.metadata = metadata;
-    fulfilledEntry.staleAt = staleAt;
+    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;
     fulfilledEntry.couldBeIntercepted = couldBeIntercepted;
     fulfilledEntry.canonicalUrl = canonicalUrl;
     fulfilledEntry.renderedSearch = renderedSearch;
-    fulfilledEntry.isPPREnabled = isPPREnabled;
+    fulfilledEntry.supportsPerSegmentPrefetching = supportsPerSegmentPrefetching;
+    fulfilledEntry.hasDynamicRewrite = false;
     pingBlockedTasks(entry);
     return fulfilledEntry;
 }
-function fulfillSegmentCacheEntry(segmentCacheEntry, rsc, loading, staleAt, isPartial) {
+function writeRouteIntoCache(now, pathname, 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 isRevalidation = false;
+    (0, _cachemap.setInCacheMap)(routeCacheMap, varyPath, fulfilledEntry, isRevalidation);
+    return fulfilledEntry;
+}
+function markRouteEntryAsDynamicRewrite(entry) {
+    entry.hasDynamicRewrite = true;
+// Note: The caller is responsible for also calling invalidateRouteCacheEntries
+// to invalidate other entries that may have been derived from this template
+// before we knew it had a dynamic rewrite.
+}
+function fulfillSegmentCacheEntry(segmentCacheEntry, rsc, staleAt, isPartial) {
     const fulfilledEntry = segmentCacheEntry;
     fulfilledEntry.status = 2;
     fulfilledEntry.rsc = rsc;
-    fulfilledEntry.loading = loading;
     fulfilledEntry.staleAt = staleAt;
     fulfilledEntry.isPartial = isPartial;
     // Resolve any listeners that were waiting for this data.
@@ -611,15 +777,14 @@ function convertTreePrefetchToRouteTree(prefetch, segment, partialVaryPath, requ
         slots = {};
         for(let parallelRouteKey in prefetchSlots){
             const childPrefetch = prefetchSlots[parallelRouteKey];
-            const childParamName = childPrefetch.name;
-            const childParamType = childPrefetch.paramType;
-            const childServerSentParamKey = childPrefetch.paramKey;
+            const childSegmentName = childPrefetch.name;
+            const childParam = childPrefetch.param;
             let childDoesAppearInURL;
             let childSegment;
             let childPartialVaryPath;
-            if (childParamType !== null) {
+            if (childParam !== null) {
                 // This segment is parameterized. Get the param from the pathname.
-                const childParamValue = (0, _routeparams.parseDynamicParamFromURLPart)(childParamType, pathnameParts, pathnamePartsIndex);
+                const childParamValue = (0, _routeparams.parseDynamicParamFromURLPart)(childParam.type, pathnameParts, pathnamePartsIndex);
                 // Assign a cache key to the segment, based on the param value. In the
                 // pre-Segment Cache implementation, the server computes this and sends
                 // it in the body of the response. In the Segment Cache implementation,
@@ -631,20 +796,21 @@ function convertTreePrefetchToRouteTree(prefetch, segment, partialVaryPath, requ
                 // doing anyway.
                 const childParamKey = // The server omits this field from the prefetch response when
                 // cacheComponents is enabled.
-                childServerSentParamKey !== null ? childServerSentParamKey : (0, _routeparams.getCacheKeyForDynamicParam)(childParamValue, '');
-                childPartialVaryPath = (0, _varypath.appendLayoutVaryPath)(partialVaryPath, childParamKey);
+                childParam.key !== null ? childParam.key : (0, _routeparams.getCacheKeyForDynamicParam)(childParamValue, '');
+                childPartialVaryPath = (0, _varypath.appendLayoutVaryPath)(partialVaryPath, childParamKey, childSegmentName);
                 childSegment = [
-                    childParamName,
+                    childSegmentName,
                     childParamKey,
-                    childParamType
+                    childParam.type,
+                    childParam.siblings
                 ];
                 childDoesAppearInURL = true;
             } else {
                 // This segment does not have a param. Inherit the partial vary path of
                 // the parent.
                 childPartialVaryPath = partialVaryPath;
-                childSegment = childParamName;
-                childDoesAppearInURL = (0, _routeparams.doesStaticSegmentAppearInURL)(childParamName);
+                childSegment = childSegmentName;
+                childDoesAppearInURL = (0, _routeparams.doesStaticSegmentAppearInURL)(childSegmentName);
             }
             // Only increment the index if the segment appears in the URL. If it's a
             // "virtual" segment, like a route group, it remains the same.
@@ -676,27 +842,48 @@ function convertTreePrefetchToRouteTree(prefetch, segment, partialVaryPath, requ
     return {
         requestKey,
         segment,
-        varyPath,
+        refreshState: null,
         // TODO: Cheating the type system here a bit because TypeScript can't tell
         // that the type of isPage and varyPath are consistent. The fix would be to
         // create separate constructors and call the appropriate one from each of
         // the branches above. Just seems a bit overkill only for one field so I'll
         // leave it as-is for now. If isPage were wrong it would break the behavior
         // and we'd catch it quickly, anyway.
+        varyPath: varyPath,
         isPage: isPage,
         slots,
-        isRootLayout: prefetch.isRootLayout,
-        // This field is only relevant to dynamic routes. For a PPR/static route,
-        // there's always some partial loading state we can fetch.
-        hasLoadingBoundary: _approutertypes.HasLoadingBoundary.SegmentHasLoadingBoundary,
-        hasRuntimePrefetch: prefetch.hasRuntimePrefetch
+        prefetchHints: prefetch.prefetchHints
     };
 }
 function convertRootFlightRouterStateToRouteTree(flightRouterState, renderedSearch, acc) {
     return convertFlightRouterStateToRouteTree(flightRouterState, _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY, null, renderedSearch, acc);
 }
-function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, parentPartialVaryPath, renderedSearch, acc) {
+function convertReusedFlightRouterStateToRouteTree(parentRouteTree, parallelRouteKey, flightRouterState, renderedSearch, acc) {
+    // Create a RouteTree for a FlightRouterState that was reused from an older
+    // route. This happens during a navigation when a parallel route slot does not
+    // match the target route; we reuse whatever slot was already active.
+    // Unlike a FlightRouterState, the RouteTree type contains backreferences to
+    // the parent segments. Append the vary path to the parent's vary path.
+    const parentPartialVaryPath = parentRouteTree.isPage ? (0, _varypath.getPartialPageVaryPath)(parentRouteTree.varyPath) : (0, _varypath.getPartialLayoutVaryPath)(parentRouteTree.varyPath);
+    const segment = flightRouterState[0];
+    // And the request key.
+    const parentRequestKey = parentRouteTree.requestKey;
+    const requestKeyPart = (0, _segmentvalueencoding.createSegmentRequestKeyPart)(segment);
+    const requestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(parentRequestKey, parallelRouteKey, requestKeyPart);
+    return convertFlightRouterStateToRouteTree(flightRouterState, requestKey, parentPartialVaryPath, renderedSearch, acc);
+}
+function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, parentPartialVaryPath, parentRenderedSearch, acc) {
     const originalSegment = flightRouterState[0];
+    // 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,
+    // we must restore the query that was originally used to render it.
+    const compressedRefreshState = flightRouterState[2] ?? null;
+    const refreshState = compressedRefreshState !== null ? {
+        canonicalUrl: compressedRefreshState[0],
+        renderedSearch: compressedRefreshState[1]
+    } : null;
+    const renderedSearch = refreshState !== null ? refreshState.renderedSearch : parentRenderedSearch;
     let segment;
     let partialVaryPath;
     let isPage;
@@ -704,7 +891,8 @@ function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, pare
     if (Array.isArray(originalSegment)) {
         isPage = false;
         const paramCacheKey = originalSegment[1];
-        partialVaryPath = (0, _varypath.appendLayoutVaryPath)(parentPartialVaryPath, paramCacheKey);
+        const paramName = originalSegment[0];
+        partialVaryPath = (0, _varypath.appendLayoutVaryPath)(parentPartialVaryPath, paramCacheKey, paramName);
         varyPath = (0, _varypath.finalizeLayoutVaryPath)(requestKey, partialVaryPath);
         segment = originalSegment;
     } else {
@@ -763,20 +951,17 @@ function convertFlightRouterStateToRouteTree(flightRouterState, requestKey, pare
     return {
         requestKey,
         segment,
-        varyPath,
+        refreshState,
         // TODO: Cheating the type system here a bit because TypeScript can't tell
         // that the type of isPage and varyPath are consistent. The fix would be to
         // create separate constructors and call the appropriate one from each of
         // the branches above. Just seems a bit overkill only for one field so I'll
         // leave it as-is for now. If isPage were wrong it would break the behavior
         // and we'd catch it quickly, anyway.
+        varyPath: varyPath,
         isPage: isPage,
         slots,
-        isRootLayout: flightRouterState[4] === true,
-        hasLoadingBoundary: flightRouterState[5] !== undefined ? flightRouterState[5] : _approutertypes.HasLoadingBoundary.SubtreeHasNoLoadingBoundary,
-        // Non-static tree responses are only used by apps that haven't adopted
-        // Cache Components. So this is always false.
-        hasRuntimePrefetch: false
+        prefetchHints: flightRouterState[4] ?? 0
     };
 }
 function convertRouteTreeToFlightRouterState(routeTree) {
@@ -790,12 +975,11 @@ function convertRouteTreeToFlightRouterState(routeTree) {
         routeTree.segment,
         parallelRoutes,
         null,
-        null,
-        routeTree.isRootLayout
+        null
     ];
     return flightRouterState;
 }
-async function fetchRouteOnCacheMiss(entry, task, key) {
+async function fetchRouteOnCacheMiss(entry, key) {
     // This function is allowed to use async/await because it contains the actual
     // fetch that gets issued on a cache miss. Notice it writes the result to the
     // cache entry directly, rather than return data that is then written by
@@ -812,6 +996,9 @@ async function fetchRouteOnCacheMiss(entry, task, 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;
@@ -900,7 +1087,13 @@ async function fetchRouteOnCacheMiss(entry, task, key) {
         // Check whether the response varies based on the Next-Url header.
         const varyHeader = response.headers.get('vary');
         const couldBeIntercepted = varyHeader !== null && varyHeader.includes(_approuterheaders.NEXT_URL);
-        // Track when the network connection closes.
+        // TODO: The `closed` promise was originally used to track when a streaming
+        // network connection closes, so the scheduler could limit concurrent
+        // connections. Now that prefetch responses are buffered, `closed` is
+        // resolved immediately after buffering — before the outer function even
+        // returns. This mechanism is only still meaningful for dynamic (Full)
+        // prefetches, which use incremental streaming. Consider removing the
+        // `closed` plumbing for buffered prefetch paths.
         const closed = (0, _promisewithresolvers.createPromiseWithResolvers)();
         // This checks whether the response was served from the per-segment cache,
         // rather than the old prefetching flow. If it fails, it implies that PPR
@@ -910,16 +1103,15 @@ async function fetchRouteOnCacheMiss(entry, task, key) {
         // because all data is static in this mode.
         isOutputExportMode;
         if (routeIsPPREnabled) {
-            const prefetchStream = createPrefetchResponseStream(response.body, closed.resolve, function onResponseSizeUpdate(size) {
-                (0, _cachemap.setSizeInCacheMap)(entry, size);
+            const { stream: prefetchStream, size: responseSize } = await createNonTaskyPrefetchResponseStream(response.body);
+            closed.resolve();
+            (0, _cachemap.setSizeInCacheMap)(entry, responseSize);
+            const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
+                allowPartialStream: true
             });
-            const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers);
-            if (serverData.buildId !== (0, _appbuildid.getAppBuildId)()) {
+            if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.buildId) !== (0, _navigationbuildid.getNavigationBuildId)()) {
                 // The server build does not match the client. Treat as a 404. During
                 // an actual navigation, the router will trigger an MPA navigation.
-                // TODO: Consider moving the build ID to a response header so we can check
-                // it before decoding the response, and so there's one way of checking
-                // across all response types.
                 // TODO: We should cache the fact that this is an MPA navigation.
                 rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
                 return null;
@@ -943,31 +1135,34 @@ async function fetchRouteOnCacheMiss(entry, task, key) {
                 rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
                 return null;
             }
-            const staleTimeMs = getStaleTimeMs(serverData.staleTime);
-            fulfillRouteCacheEntry(entry, routeTree, metadataVaryPath, Date.now() + staleTimeMs, couldBeIntercepted, canonicalUrl, renderedSearch, routeIsPPREnabled);
+            (0, _optimisticroutes.discoverKnownRoute)(Date.now(), pathname, nextUrl, entry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, false // hasDynamicRewrite
+            );
         } else {
             // PPR is not enabled for this route. The server responds with a
             // different format (FlightRouterState) that we need to convert.
             // TODO: We will unify the responses eventually. I'm keeping the types
             // separate for now because FlightRouterState has so many
             // overloaded concerns.
-            const prefetchStream = createPrefetchResponseStream(response.body, closed.resolve, function onResponseSizeUpdate(size) {
-                (0, _cachemap.setSizeInCacheMap)(entry, size);
+            const { stream: prefetchStream, size: responseSize } = await createNonTaskyPrefetchResponseStream(response.body);
+            closed.resolve();
+            (0, _cachemap.setSizeInCacheMap)(entry, responseSize);
+            const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
+                allowPartialStream: true
             });
-            const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers);
-            if (serverData.b !== (0, _appbuildid.getAppBuildId)()) {
+            if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.b) !== (0, _navigationbuildid.getNavigationBuildId)()) {
                 // The server build does not match the client. Treat as a 404. During
                 // an actual navigation, the router will trigger an MPA navigation.
-                // TODO: Consider moving the build ID to a response header so we can check
-                // it before decoding the response, and so there's one way of checking
-                // across all response types.
                 // TODO: We should cache the fact that this is an MPA navigation.
                 rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
                 return null;
             }
-            writeDynamicTreeResponseIntoCache(Date.now(), task, // The non-PPR response format is what we'd get if we prefetched these segments
+            // 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;
+            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);
+            _types.FetchStrategy.LoadingBoundary, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, headVaryParams, pathname, nextUrl);
         }
         if (!couldBeIntercepted) {
             // This route will never be intercepted. So we can use this entry for all
@@ -1026,6 +1221,9 @@ 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);
@@ -1044,27 +1242,36 @@ async function fetchSegmentOnCacheMiss(route, segmentCacheEntry, routeKey, tree)
             rejectSegmentCacheEntry(segmentCacheEntry, Date.now() + 10 * 1000);
             return null;
         }
-        // Track when the network connection closes.
+        // See TODO in fetchRouteOnCacheMiss about removing `closed` for
+        // buffered prefetch paths.
         const closed = (0, _promisewithresolvers.createPromiseWithResolvers)();
-        // Wrap the original stream in a new stream that never closes. That way the
-        // Flight client doesn't error if there's a hanging promise.
-        const prefetchStream = createPrefetchResponseStream(response.body, closed.resolve, function onResponseSizeUpdate(size) {
-            (0, _cachemap.setSizeInCacheMap)(segmentCacheEntry, size);
+        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
         });
-        const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers);
-        if (serverData.buildId !== (0, _appbuildid.getAppBuildId)()) {
+        if ((response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.buildId) !== (0, _navigationbuildid.getNavigationBuildId)()) {
             // The server build does not match the client. Treat as a 404. During
             // an actual navigation, the router will trigger an MPA navigation.
-            // TODO: Consider moving the build ID to a response header so we can check
-            // it before decoding the response, and so there's one way of checking
-            // across all response types.
             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: fulfillSegmentCacheEntry(segmentCacheEntry, serverData.rsc, serverData.loading, // TODO: The server does not currently provide per-segment stale time.
-            // So we use the stale time of the route.
-            route.staleAt, serverData.isPartial),
+            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
@@ -1076,6 +1283,95 @@ async function fetchSegmentOnCacheMiss(route, segmentCacheEntry, routeKey, tree)
         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;
+    }
+    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;
+        }
+        // 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;
+        }
+        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);
+        } 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);
+            }
+        }
+        // Reject any remaining entries that were not fulfilled by the response.
+        rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
+        return {
+            value: null,
+            closed: closed.promise
+        };
+    } catch (error) {
+        rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
+        return null;
+    }
+}
+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);
+        }
+    }
+    // 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);
+            }
+        }
+    }
+}
 async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrategy, dynamicRequestTree, spawnedEntries) {
     const key = task.key;
     const url = new URL(route.canonicalUrl, location.origin);
@@ -1132,30 +1428,73 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
             rejectSegmentEntriesIfStillPending(spawnedEntries, Date.now() + 10 * 1000);
             return null;
         }
-        // Track when the network connection closes.
+        // Track when the network connection closes. Only meaningful for Full
+        // (dynamic) prefetches which use incremental streaming. For buffered
+        // paths, this is resolved immediately — see TODO in fetchRouteOnCacheMiss.
         const closed = (0, _promisewithresolvers.createPromiseWithResolvers)();
         let fulfilledEntries = null;
-        const prefetchStream = createPrefetchResponseStream(response.body, closed.resolve, function onResponseSizeUpdate(totalBytesReceivedSoFar) {
-            // When processing a dynamic response, we don't know how large each
-            // individual segment is, so approximate by assiging each segment
-            // the average of the total response size.
-            if (fulfilledEntries === null) {
-                // Haven't received enough data yet to know which segments
-                // were included.
-                return;
-            }
-            const averageSize = totalBytesReceivedSoFar / fulfilledEntries.length;
-            for (const entry of fulfilledEntries){
-                (0, _cachemap.setSizeInCacheMap)(entry, averageSize);
-            }
-        });
-        const serverData = await (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers);
-        const isResponsePartial = fetchStrategy === _types.FetchStrategy.PPRRuntime ? serverData.rp?.[0] === true : // (even if we did set the prefetch header, we only use this codepath for non-PPR-enabled routes)
-        false;
+        let prefetchStream;
+        let bufferedResponseSize = null;
+        if (fetchStrategy === _types.FetchStrategy.Full) {
+            // Full prefetches are dynamic responses stored in the prefetch cache.
+            // They don't carry vary params or other cache metadata, so there's no
+            // need to buffer them. Use the incremental version to allow data to be
+            // processed as it arrives.
+            prefetchStream = createIncrementalPrefetchResponseStream(response.body, closed.resolve, function onResponseSizeUpdate(totalBytesReceivedSoFar) {
+                // When processing a dynamic response, we don't know how large each
+                // individual segment is, so approximate by assigning each segment
+                // the average of the total response size.
+                if (fulfilledEntries === null) {
+                    // Haven't received enough data yet to know which segments
+                    // were included.
+                    return;
+                }
+                const averageSize = totalBytesReceivedSoFar / fulfilledEntries.length;
+                for (const entry of fulfilledEntries){
+                    (0, _cachemap.setSizeInCacheMap)(entry, averageSize);
+                }
+            });
+        } else {
+            const { stream, size } = await createNonTaskyPrefetchResponseStream(response.body);
+            closed.resolve();
+            prefetchStream = stream;
+            bufferedResponseSize = size;
+        }
+        const [serverData, cacheData] = await Promise.all([
+            (0, _fetchserverresponse.createFromNextReadableStream)(prefetchStream, headers, {
+                allowPartialStream: true
+            }),
+            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.
-        fulfilledEntries = writeDynamicRenderResponseIntoCache(Date.now(), task, fetchStrategy, response, serverData, isResponsePartial, route, spawnedEntries);
+        const buildId = response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.b;
+        const flightDatas = (0, _flightdatahelpers.normalizeFlightData)(serverData.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);
+        // For buffered responses, update LRU sizes now that we know which
+        // entries were fulfilled.
+        if (bufferedResponseSize !== null && fulfilledEntries !== null && fulfilledEntries.length > 0) {
+            const averageSize = bufferedResponseSize / fulfilledEntries.length;
+            for (const entry of fulfilledEntries){
+                (0, _cachemap.setSizeInCacheMap)(entry, averageSize);
+            }
+        }
         // Return a promise that resolves when the network connection closes, so
         // the scheduler can track the number of concurrent network connections.
         return {
@@ -1167,9 +1506,7 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
         return null;
     }
 }
-function writeDynamicTreeResponseIntoCache(now, task, fetchStrategy, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled) {
-    // Get the URL that was used to render the target page. This may be different
-    // from the URL in the request URL, if the page was rewritten.
+function writeDynamicTreeResponseIntoCache(now, fetchStrategy, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, headVaryParams, originalPathname, nextUrl) {
     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
@@ -1185,14 +1522,9 @@ function writeDynamicTreeResponseIntoCache(now, task, fetchStrategy, response, s
         return;
     }
     const flightRouterState = flightData.tree;
-    // For runtime prefetches, stale time is in the payload at rp[1].
-    // For other responses, fall back to the header.
-    const staleTimeSeconds = typeof serverData.rp?.[1] === 'number' ? serverData.rp[1] : parseInt(response.headers.get(_approuterheaders.NEXT_ROUTER_STALE_TIME_HEADER) ?? '', 10);
-    const staleTimeMs = !isNaN(staleTimeSeconds) ? getStaleTimeMs(staleTimeSeconds) : _navigatereducer.STATIC_STALETIME_MS;
-    // If the response contains dynamic holes, then we must conservatively assume
-    // that any individual segment might contain dynamic holes, and also the
-    // head. If it did not contain dynamic holes, then we can assume every segment
-    // and the head is completely static.
+    // If the response was postponed, segments may contain dynamic holes.
+    // The head has its own partiality flag (flightDataEntry.isHeadPartial)
+    // which is handled separately in writeDynamicRenderResponseIntoCache.
     const isResponsePartial = response.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER) === '1';
     // Convert the server-sent data into the RouteTree format used by the
     // client cache.
@@ -1208,17 +1540,16 @@ function writeDynamicTreeResponseIntoCache(now, task, fetchStrategy, response, s
         rejectRouteCacheEntry(entry, now + 10 * 1000);
         return;
     }
-    const fulfilledEntry = fulfillRouteCacheEntry(entry, routeTree, metadataVaryPath, now + staleTimeMs, couldBeIntercepted, canonicalUrl, renderedSearch, routeIsPPREnabled);
+    (0, _optimisticroutes.discoverKnownRoute)(now, originalPathname, nextUrl, entry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, false // hasDynamicRewrite
+    );
     // If the server sent segment data as part of the response, we should write
     // it into the cache to prevent a second, redundant prefetch request.
-    //
-    // TODO: When `clientSegmentCache` is enabled, the server does not include
-    // segment data when responding to a route tree prefetch request. However,
-    // when `clientSegmentCache` is set to "client-only", and PPR is enabled (or
-    // the page is fully static), the normal check is bypassed and the server
-    // responds with the full page. This is a temporary situation until we can
-    // remove the "client-only" option. Then, we can delete this function call.
-    writeDynamicRenderResponseIntoCache(now, task, fetchStrategy, response, serverData, isResponsePartial, fulfilledEntry, null);
+    // TODO: This is a leftover branch from before Client Segment Cache was
+    // enabled everywhere. Tree prefetches should never include segment data.  We
+    // can delete it. Leaving for a subsequent PR.
+    const navigationSeed = (0, _navigation.convertServerPatchToFullTree)(now, flightRouterState, normalizedFlightDataResult, renderedSearch, _bfcache.UnknownDynamicStaleTime);
+    const buildId = response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? serverData.b;
+    writeDynamicRenderResponseIntoCache(now, fetchStrategy, normalizedFlightDataResult, buildId, isResponsePartial, headVaryParams, getStaleAtFromHeader(now, response), navigationSeed, null);
 }
 function rejectSegmentEntriesIfStillPending(entries, staleAt) {
     const fulfilledEntries = [];
@@ -1231,31 +1562,19 @@ function rejectSegmentEntriesIfStillPending(entries, staleAt) {
     }
     return fulfilledEntries;
 }
-function writeDynamicRenderResponseIntoCache(now, task, fetchStrategy, response, serverData, isResponsePartial, route, spawnedEntries) {
-    if (serverData.b !== (0, _appbuildid.getAppBuildId)()) {
+function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, staleAt, navigationSeed, spawnedEntries) {
+    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.
-        // TODO: Consider moving the build ID to a response header so we can check
-        // it before decoding the response, and so there's one way of checking
-        // across all response types.
         if (spawnedEntries !== null) {
             rejectSegmentEntriesIfStillPending(spawnedEntries, now + 10 * 1000);
         }
         return null;
     }
-    const flightDatas = (0, _flightdatahelpers.normalizeFlightData)(serverData.f);
-    if (typeof flightDatas === 'string') {
-        // This means navigating to this route will result in an MPA navigation.
-        // TODO: We should cache this, too, so that the MPA navigation is immediate.
-        return null;
-    }
-    // For runtime prefetches, stale time is in the payload at rp[1].
-    // For other responses, fall back to the header.
-    const staleTimeSeconds = typeof serverData.rp?.[1] === 'number' ? serverData.rp[1] : parseInt(response.headers.get(_approuterheaders.NEXT_ROUTER_STALE_TIME_HEADER) ?? '', 10);
-    const staleTimeMs = !isNaN(staleTimeSeconds) ? getStaleTimeMs(staleTimeSeconds) : _navigatereducer.STATIC_STALETIME_MS;
-    const staleAt = now + staleTimeMs;
-    for (const flightData of flightDatas){
-        const seedData = flightData.seedData;
+    const routeTree = navigationSeed.routeTree;
+    const metadataTree = navigationSeed.metadataVaryPath !== null ? createMetadataRouteTree(navigationSeed.metadataVaryPath) : null;
+    for (const flightDataEntry of flightDatas){
+        const seedData = flightDataEntry.seedData;
         if (seedData !== null) {
             // The data sent by the server represents only a subtree of the app. We
             // need to find the part of the task tree that matches the response.
@@ -1264,8 +1583,8 @@ function writeDynamicRenderResponseIntoCache(now, task, fetchStrategy, response,
             // pattern of parallel route key and segment:
             //
             //   [string, Segment, string, Segment, string, Segment, ...]
-            const segmentPath = flightData.segmentPath;
-            let tree = route.tree;
+            const segmentPath = flightDataEntry.segmentPath;
+            let tree = routeTree;
             for(let i = 0; i < segmentPath.length; i += 2){
                 const parallelRouteKey = segmentPath[i];
                 if (tree?.slots?.[parallelRouteKey] !== undefined) {
@@ -1277,11 +1596,22 @@ function writeDynamicRenderResponseIntoCache(now, task, fetchStrategy, response,
                     return null;
                 }
             }
-            writeSeedDataIntoCache(now, task, fetchStrategy, route, tree, staleAt, seedData, isResponsePartial, spawnedEntries);
+            writeSeedDataIntoCache(now, fetchStrategy, tree, staleAt, seedData, isResponsePartial, spawnedEntries);
         }
-        const head = flightData.head;
-        if (head !== null) {
-            fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, route, head, null, flightData.isHeadPartial, staleAt, route.metadata, 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.
+            //
+            // 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
+            // parameter.
+            headVaryParams, metadataTree, spawnedEntries);
         }
     }
     // Any entry that's still pending was intentionally not rendered by the
@@ -1298,13 +1628,17 @@ function writeDynamicRenderResponseIntoCache(now, task, fetchStrategy, response,
     }
     return null;
 }
-function writeSeedDataIntoCache(now, task, fetchStrategy, route, tree, staleAt, seedData, isResponsePartial, entriesOwnedByCurrentTask) {
+function writeSeedDataIntoCache(now, fetchStrategy, tree, staleAt, seedData, isResponsePartial, entriesOwnedByCurrentTask) {
     // This function is used to write the result of a runtime server request
     // (CacheNodeSeedData) into the prefetch cache.
     const rsc = seedData[0];
-    const loading = seedData[2];
     const isPartial = rsc === null || isResponsePartial;
-    fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, route, rsc, loading, isPartial, staleAt, tree, entriesOwnedByCurrentTask);
+    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);
     // Recursively write the child data into the cache.
     const slots = tree.slots;
     if (slots !== null) {
@@ -1313,30 +1647,45 @@ function writeSeedDataIntoCache(now, task, fetchStrategy, route, tree, staleAt,
             const childTree = slots[parallelRouteKey];
             const childSeedData = seedDataChildren[parallelRouteKey];
             if (childSeedData !== null && childSeedData !== undefined) {
-                writeSeedDataIntoCache(now, task, fetchStrategy, route, childTree, staleAt, childSeedData, isResponsePartial, entriesOwnedByCurrentTask);
+                writeSeedDataIntoCache(now, fetchStrategy, childTree, staleAt, childSeedData, isResponsePartial, entriesOwnedByCurrentTask);
             }
         }
     }
 }
-function fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, route, rsc, loading, isPartial, staleAt, tree, entriesOwnedByCurrentTask) {
+function fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, rsc, isPartial, staleAt, segmentVaryParams, tree, entriesOwnedByCurrentTask) {
     // 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) {
-        fulfillSegmentCacheEntry(ownedEntry, rsc, loading, staleAt, isPartial);
+        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 isRevalidation = false;
+            (0, _cachemap.setInCacheMap)(segmentCacheMap, fulfilledVaryPath, fulfilledEntry, isRevalidation);
+        }
     } else {
         // There's no matching entry. Attempt to create a new one.
-        const possiblyNewEntry = readOrCreateSegmentCacheEntry(now, fetchStrategy, route, tree);
+        const possiblyNewEntry = readOrCreateSegmentCacheEntry(now, fetchStrategy, tree);
         if (possiblyNewEntry.status === 0) {
             // Confirmed this is a new entry. We can fulfill it.
             const newEntry = possiblyNewEntry;
-            fulfillSegmentCacheEntry(upgradeToPendingSegment(newEntry, fetchStrategy), rsc, loading, staleAt, isPartial);
+            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 isRevalidation = false;
+                (0, _cachemap.setInCacheMap)(segmentCacheMap, fulfilledVaryPath, fulfilledEntry, isRevalidation);
+            }
         } 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(staleAt), fetchStrategy), rsc, loading, staleAt, isPartial);
-            upsertSegmentEntry(now, (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree), newEntry);
+            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);
         }
     }
 }
@@ -1345,7 +1694,7 @@ async function fetchPrefetchResponse(url, headers) {
     // When issuing a prefetch request, don't immediately decode the response; we
     // use the lower level `createFromResponse` API instead because we need to do
     // some extra processing of the response stream. See
-    // `createPrefetchResponseStream` for more details.
+    // `createNonTaskyPrefetchResponseStream` for more details.
     const shouldImmediatelyDecode = false;
     const response = await (0, _fetchserverresponse.createFetch)(url, headers, fetchPriority, shouldImmediatelyDecode);
     if (!response.ok) {
@@ -1366,20 +1715,69 @@ async function fetchPrefetchResponse(url, headers) {
     }
     return response;
 }
-function createPrefetchResponseStream(originalFlightStream, onStreamClose, onResponseSizeUpdate) {
-    // When PPR is enabled, prefetch streams may contain references that never
-    // resolve, because that's how we encode dynamic data access. In the decoded
-    // object returned by the Flight client, these are reified into hanging
-    // promises that suspend during render, which is effectively what we want.
-    // The UI resolves when it switches to the dynamic data stream
-    // (via useDeferredValue(dynamic, static)).
+async function createNonTaskyPrefetchResponseStream(body) {
+    // Buffer the entire response before passing it to the Flight client. This
+    // ensures that when Flight processes the stream, all model data is available
+    // synchronously. This is important for readVaryParams, which synchronously
+    // checks the thenable status — if data arrived in multiple network chunks,
+    // the thenables might not yet be fulfilled.
     //
-    // However, the Flight implementation currently errors if the server closes
-    // the response before all the references are resolved. As a cheat to work
-    // around this, we wrap the original stream in a new stream that never closes,
-    // and therefore doesn't error.
+    // TODO: There are too many intermediate stream transformations in the
+    // prefetch response pipeline (e.g. stripIsPartialByte, this function).
+    // These could all be consolidated into a single transformation. Refactor
+    // once the cached navigations experiment lands.
     //
-    // While processing the original stream, we also incrementally update the size
+    // Read the entire response from the network.
+    const reader = body.getReader();
+    const chunks = [];
+    let size = 0;
+    while(true){
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+        size += value.byteLength;
+    }
+    // Concatenate into a single chunk so that Flight's processBinaryChunk
+    // processes all rows synchronously in one call. Multiple chunks would not
+    // be sufficient: even though reader.read() resolves as a microtask for
+    // already-enqueued data, the `await` continuation from
+    // createFromReadableStream can interleave between chunks. If the root
+    // model row isn't the first row (e.g. outlined values come first), the
+    // PromiseResolveThenableJob from `await` can cause the root to initialize
+    // eagerly, scheduling the continuation before remaining chunks (including
+    // promise value rows) are processed. A single chunk avoids this.
+    let buffer;
+    if (chunks.length === 1) {
+        buffer = chunks[0];
+    } else if (chunks.length > 1) {
+        buffer = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks){
+            buffer.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+    } else {
+        buffer = new Uint8Array(0);
+    }
+    const stream = new ReadableStream({
+        start (controller) {
+            controller.enqueue(buffer);
+            controller.close();
+        }
+    });
+    return {
+        stream,
+        size
+    };
+}
+/**
+ * Creates a streaming (non-buffered) prefetch response stream for dynamic/Full
+ * prefetches. These are essentially dynamic responses that get stored in the
+ * prefetch cache — they don't carry vary params or other cache metadata that
+ * requires synchronous thenable resolution, so there's no need to buffer them.
+ * They should continue to stream so consumers can process data as it arrives.
+ */ function createIncrementalPrefetchResponseStream(originalFlightStream, onStreamClose, onResponseSizeUpdate) {
+    // While processing the original stream, we incrementally update the size
     // of the cache entry in the LRU.
     let totalByteLength = 0;
     const reader = originalFlightStream.getReader();
@@ -1392,15 +1790,11 @@ function createPrefetchResponseStream(originalFlightStream, onStreamClose, onRes
                     // from the server.
                     controller.enqueue(value);
                     // Incrementally update the size of the cache entry in the LRU.
-                    // NOTE: Since prefetch responses are delivered in a single chunk,
-                    // it's not really necessary to do this streamingly, but I'm doing it
-                    // anyway in case this changes in the future.
                     totalByteLength += value.byteLength;
                     onResponseSizeUpdate(totalByteLength);
                     continue;
                 }
-                // The server stream has closed. Exit, but intentionally do not close
-                // the target stream. We do notify the caller, though.
+                controller.close();
                 onStreamClose();
                 return;
             }
@@ -1422,6 +1816,113 @@ 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) {
+    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
+        // final staleTime.
+        let staleTimeSeconds;
+        for await (const value of staleTimeIterable){
+            staleTimeSeconds = value;
+        }
+        if (staleTimeSeconds !== undefined) {
+            const staleTimeMs = isNaN(staleTimeSeconds) ? _navigatereducer.STATIC_STALETIME_MS : getStaleTimeMs(staleTimeSeconds);
+            return now + staleTimeMs;
+        }
+    }
+    if (response !== undefined) {
+        return getStaleAtFromHeader(now, 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;
+    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
+    );
+}
+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);
+    const flightDatas = (0, _flightdatahelpers.normalizeFlightData)(serverData.f);
+    if (typeof flightDatas === 'string') {
+        return null;
+    }
+    const navigationSeed = (0, _navigation.convertServerPatchToFullTree)(now, baseTree, flightDatas, renderedSearch, _bfcache.UnknownDynamicStaleTime);
+    return {
+        flightDatas,
+        navigationSeed,
+        buildId: serverData.b,
+        isResponsePartial: isPartial,
+        headVaryParams,
+        staleAt
+    };
+}
+async function stripIsPartialByte(stream) {
+    // When there is no recognized marker byte, the fallback depends on whether
+    // Cached Navigations is enabled. When enabled, dynamic navigation responses
+    // don't have a marker but may contain dynamic holes, so they are treated as
+    // partial. When disabled, unmarked responses are treated as non-partial.
+    const defaultIsPartial = !!process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS;
+    const reader = stream.getReader();
+    const { done, value } = await reader.read();
+    if (done || !value || value.byteLength === 0) {
+        return {
+            stream: new ReadableStream({
+                start: (c)=>c.close()
+            }),
+            isPartial: defaultIsPartial
+        };
+    }
+    const firstByte = value[0];
+    const hasMarker = firstByte === 0x23 || firstByte === 0x7e;
+    const isPartial = hasMarker ? firstByte === 0x7e : defaultIsPartial;
+    const remainder = hasMarker ? value.byteLength > 1 ? value.subarray(1) : null : value;
+    return {
+        isPartial,
+        stream: new ReadableStream({
+            start (controller) {
+                if (remainder) {
+                    controller.enqueue(remainder);
+                }
+            },
+            async pull (controller) {
+                const result = await reader.read();
+                if (result.done) {
+                    controller.close();
+                } else {
+                    controller.enqueue(result.value);
+                }
+            }
+        })
+    };
+}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });