switchboard-router 0.9.21 → 0.9.26

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

@@ -33,9 +33,9 @@ Object.defineProperty(exports, "__esModule", {
     readOrCreateRouteCacheEntry: null,
     readOrCreateSegmentCacheEntry: null,
     readRouteCacheEntry: null,
-    readSegmentCacheEntry: null,
     readSegmentCacheEntryForNavigation: null,
     resolveStaleAt: null,
+    segmentCacheMap: null,
     stripIsPartialByte: null,
     upgradeToPendingSegment: null,
     upsertSegmentEntry: null,
@@ -141,15 +141,15 @@ _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;
     },
@@ -205,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
@@ -305,54 +305,30 @@ function readRouteCacheEntry(now, key) {
     }
     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, false);
-}
-function readSegmentCacheEntryForNavigation(now, varyPath, restrictToShell = false) {
-    const isRevalidation = false;
-    if (process.env.__NEXT_EXPOSE_TESTING_API) {
-        const { getCurrentNavigationLock } = require('./navigation-testing-lock');
-        const lock = getCurrentNavigationLock();
-        if (lock !== null) {
-            // Instant Navigation Testing API
-            //
-            // Modify the lookup logic to simulate the behavior that we would expect
-            // to mostly realistically happen in a production environment with a
-            // warm prefetch cache.
-            // If restrictToShell is true, it means we're navigating to a link that
-            // 1) has Partial Prefetching enabled, and 2) does not have a prefetch
-            // prop set. We should only allow the shell to render, not anything that
-            // varies on concrete route params.
-            const lookupVaryPath = restrictToShell ? (0, _varypath.getShellSegmentVaryPath)(varyPath) : varyPath;
-            // To prevent the test navigation from being "polluted" by earlier
-            // prefetches, we'll also only match entries that were created during
-            // the current lock scope. This is tracked by the `ownedEntries` set.
-            const ownedEntries = lock.ownedEntries;
-            // Besides that, the rest of the logic is the same as production.
-            const fulfilled = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), segmentCacheMap, lookupVaryPath, isRevalidation, true);
-            if (fulfilled !== null && ownedEntries.has(fulfilled)) {
-                return fulfilled;
-            }
-            const entry = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), segmentCacheMap, lookupVaryPath, isRevalidation, false);
-            if (entry !== null && ownedEntries.has(entry)) {
-                return entry;
-            }
-            return null;
-        }
+    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(), segmentCacheMap, varyPath, isRevalidation, true);
+    const fulfilled = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, lookupVaryPath, isRevalidation, true);
     if (fulfilled !== null) {
         return fulfilled;
     }
-    return (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), segmentCacheMap, varyPath, isRevalidation, false);
+    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, false);
+    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.
@@ -519,55 +495,29 @@ function deprecated_createOptimisticRouteTree(tree, newRenderedSearch) {
         prefetchHints: tree.prefetchHints
     };
 }
-function readOrCreateSegmentCacheEntry(now, fetchStrategy, tree, // Non-null when this read is part of a locked navigation's prefetch (Instant
-// Navigation Testing API only; always null in production). See below.
-navigationLockPrefetch) {
-    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) {
-        if (process.env.__NEXT_EXPOSE_TESTING_API && navigationLockPrefetch !== null) {
-            // Locked navigation: ignore entries that predate the lock so each
-            // navigation reads only data (re)fetched within the lock scope — a
-            // "clean read." But an entry we already created within this scope is
-            // reused like normal; otherwise the prefetch would discard the entry it
-            // just fetched on every scheduler pass and refetch forever. See
-            // navigation-testing-lock.ts.
-            const { getCurrentNavigationLock, trackNavigationLockPrefetchEntry } = require('./navigation-testing-lock');
-            const lock = getCurrentNavigationLock();
-            if (lock !== null && lock.ownedEntries.has(existingEntry)) {
-                // Track-on-reuse: when this navigation reuses an in-flight (Pending)
-                // entry it didn't spawn — e.g. a runtime-prefetch (PPRRuntime) upgrade
-                // started by an earlier prefetch in the scope — register it on this
-                // navigation's prefetch so the navigation awaits it before reading.
-                // Without this, the navigation can read while that upgrade is still
-                // pending and fall back to a less-specific fulfilled entry (the shell),
-                // never surfacing the resolved value.
-                //
-                // This is content-neutral: the entry is found by the concrete vary-path
-                // (not by strategy), so it's whatever the navigation would read at this
-                // key anyway. Tracking only controls whether we await it now versus
-                // suspend on it during the render, so it can't surface an entry the
-                // navigation wouldn't otherwise read. Tracking is deduped, so it's a
-                // no-op if we already spawned/tracked this entry.
-                if (existingEntry.status === _cachemap.EntryStatus.Pending) {
-                    trackNavigationLockPrefetchEntry(navigationLockPrefetch, existingEntry);
-                }
-                return existingEntry;
-            }
-        } else {
-            return existingEntry;
-        }
+        return existingEntry;
     }
-    // No reusable entry, or a locked navigation discarding a pre-lock entry.
-    // 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
@@ -594,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;
     }
@@ -604,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;
@@ -616,7 +567,7 @@ 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;
 }
 /**
@@ -639,7 +590,12 @@ function overwriteRevalidatingSegmentCacheEntry(now, fetchStrategy, tree) {
     // (TODO: can this be true if `candidateEntry.fetchStrategy >= existingEntry.fetchStrategy`?)
     !existingEntry.isPartial && candidateEntry.isPartial);
 }
-function upsertSegmentEntry(now, varyPath, candidateEntry, // The fully concrete vary path a read for this segment position resolves
+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.
@@ -657,7 +613,7 @@ lookupVaryPath) {
         // 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
@@ -703,9 +659,9 @@ lookupVaryPath) {
     // 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, lookupVaryPath, candidateEntry);
+        evictShadowingSegmentEntries(now, map, lookupVaryPath, candidateEntry);
     }
     return candidateEntry;
 }
@@ -739,7 +695,7 @@ lookupVaryPath) {
  * 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, lookupVaryPath, candidateEntry) {
+ */ 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
@@ -750,7 +706,7 @@ lookupVaryPath) {
     // beyond any real fallback chain, which is bounded by the vary
     // path's length.
     for(let i = 0; i < 32; i++){
-        const shadowEntry = readSegmentCacheEntry(now, lookupVaryPath);
+        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.
@@ -795,16 +751,9 @@ function createDetachedSegmentCacheEntry(now) {
         staleAt,
         version: 0
     };
-    if (process.env.__NEXT_EXPOSE_TESTING_API) {
-        // Instant Navigation Testing API: mark entries created during a lock scope
-        // as owned, so locked navigations match only data (re)fetched within the
-        // scope. No-op when no lock is held (always in production).
-        const { recordNavigationLockOwnedEntry } = require('./navigation-testing-lock');
-        recordNavigationLockOwnedEntry(emptyEntry);
-    }
     return emptyEntry;
 }
-function upgradeToPendingSegment(emptyEntry, fetchStrategy, navigationLockPrefetch) {
+function upgradeToPendingSegment(emptyEntry, fetchStrategy) {
     const pendingEntry = emptyEntry;
     pendingEntry.status = _cachemap.EntryStatus.Pending;
     pendingEntry.fetchStrategy = fetchStrategy;
@@ -820,17 +769,6 @@ function upgradeToPendingSegment(emptyEntry, fetchStrategy, navigationLockPrefet
     // than when receiving the response, because it's guaranteed to happen
     // before the data is read on the server.
     pendingEntry.version = getCurrentSegmentCacheVersion();
-    if (process.env.__NEXT_EXPOSE_TESTING_API && // Instant Navigation Testing API only. Non-null when the requesting
-    // prefetch is driving a locked navigation, in which case the
-    // freshly-spawned pending entry is tracked against that navigation's
-    // prefetch state so the navigation waits for it to fulfill before reading
-    // it. Null at non-scheduler call sites (BFCache fulfillment, response
-    // processing), which don't spawn an in-flight request to wait on, and
-    // always in production.
-    navigationLockPrefetch !== null) {
-        const { trackNavigationLockPrefetchEntry } = require('./navigation-testing-lock');
-        trackNavigationLockPrefetchEntry(navigationLockPrefetch, pendingEntry);
-    }
     return pendingEntry;
 }
 function attemptToFulfillDynamicSegmentFromBFCache(now, segment, tree) {
@@ -855,16 +793,15 @@ function attemptToFulfillDynamicSegmentFromBFCache(now, segment, tree) {
         if (now > dynamicPrefetchStaleAt) {
             return null;
         }
-        const pendingSegment = upgradeToPendingSegment(segment, _types.FetchStrategy.Full, // Fulfilled synchronously from the BFCache; nothing for a locked
-        // navigation to wait on.
-        null);
+        const pendingSegment = upgradeToPendingSegment(segment, _types.FetchStrategy.Full);
         const isPartial = false;
         return fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial, // bfcache data is concrete, never an ISR fallback.
         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) {
@@ -872,14 +809,12 @@ function attemptToUpgradeSegmentFromBFCache(now, tree) {
         if (now > dynamicPrefetchStaleAt) {
             return null;
         }
-        const pendingSegment = upgradeToPendingSegment(createDetachedSegmentCacheEntry(now), _types.FetchStrategy.Full, // Fulfilled synchronously from the BFCache; nothing for a locked
-        // navigation to wait on.
-        null);
+        const pendingSegment = upgradeToPendingSegment(createDetachedSegmentCacheEntry(now), _types.FetchStrategy.Full);
         const isPartial = false;
         const newEntry = fulfillSegmentCacheEntry(pendingSegment, bfcacheEntry.rsc, dynamicPrefetchStaleAt, isPartial, // bfcache data is concrete, never an ISR fallback.
         false, _types.FetchStrategy.Full);
         const segmentVaryPath = (0, _varypath.getSegmentVaryPathForRequest)(_types.FetchStrategy.Full, tree);
-        const upserted = upsertSegmentEntry(now, segmentVaryPath, newEntry, // The concrete lookup path this BFCache upgrade applies to. (In
+        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);
@@ -1244,7 +1179,9 @@ function convertRouteTreeToFlightRouterState(routeTree) {
     }
     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
@@ -1386,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;
@@ -1422,7 +1360,7 @@ async function fetchRouteOnCacheMiss(entry, key) {
             const headVaryParams = (0, _varyparamsdecoding.readVaryParams)(serverData.h, serverData.r);
             writeDynamicTreeResponseIntoCache(Date.now(), // The non-PPR response format is what we'd get if we prefetched these segments
             // using the LoadingBoundary fetch strategy, so mark their cache entries accordingly.
-            _types.FetchStrategy.LoadingBoundary, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, headVaryParams, serverData.r ?? null, pathname, search, nextUrl);
+            _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
@@ -1522,7 +1460,7 @@ fetchStrategy) {
     }
     const { serverResponse, shellResponse, responseSize, closed } = result;
     const now = Date.now();
-    writeSegmentBundleResponseVariants(serverResponse, shellResponse, responseSize, segments, segmentCount, now, fetchStrategy);
+    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
@@ -1663,12 +1601,14 @@ fetchStrategy) {
  * 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(serverResponse, shellResponse, responseSize, segments, segmentCount, now, // Which walk spawned the bundle's entries; decides which payload fulfills
+ */ 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(serverResponse, responseSize, detachEntriesFromSegmentBundle(segments), segmentCount, now, _types.FetchStrategy.PPR, _types.FetchStrategy.PPR);
+            writeSegmentBundleResponse(map, serverResponse, responseSize, detachEntriesFromSegmentBundle(segments), segmentCount, now, _types.FetchStrategy.PPR, _types.FetchStrategy.PPR);
         }
         if (shellResponse === null) {
             // No shell exists. Reject the spawned entries so the task isn't
@@ -1679,18 +1619,15 @@ fetchStrategy) {
             // rejection's backoff expires.
             rejectRemainingSegmentsInBundle(segments, now + 10 * 1000);
         } else {
-            writeSegmentBundleResponse(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. They're still keyed at the shell
-            // vary path: that's the reusable slot, and it serves concrete
-            // fallback reads correctly precisely because the shell and concrete
-            // variants coincide.
+            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(serverResponse, responseSize, segments, segmentCount, now, _types.FetchStrategy.PPR, _types.FetchStrategy.PPR);
+        writeSegmentBundleResponse(map, serverResponse, responseSize, segments, segmentCount, now, _types.FetchStrategy.PPR, _types.FetchStrategy.PPR);
         if (shellResponse !== null && shellResponse !== serverResponse) {
-            writeSegmentBundleResponse(shellResponse, responseSize, detachEntriesFromSegmentBundle(segments), segmentCount, now, _types.FetchStrategy.StaticShell, _types.FetchStrategy.StaticShell);
+            writeSegmentBundleResponse(map, shellResponse, responseSize, detachEntriesFromSegmentBundle(segments), segmentCount, now, _types.FetchStrategy.StaticShell, _types.FetchStrategy.StaticShell);
         }
     }
 }
@@ -1714,7 +1651,7 @@ fetchStrategy) {
  *
  * 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(serverResponse, responseSize, segments, segmentCount, now, fetchStrategy, // The strategy tier that describes this payload's CONTENT, recorded on
+ */ 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
@@ -1799,46 +1736,37 @@ payloadFetchStrategy) {
         // 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;
-        // Determine the vary path to key the segment at. For the full payload,
-        // re-key to a more generic path if the server tells us which params the
-        // segment varies by.
-        const payloadVaryPath = fetchStrategy === _types.FetchStrategy.StaticShell ? node.tree.shellVaryPath : process.env.__NEXT_VARY_PARAMS && varyParams !== null ? (0, _varypath.getFulfilledSegmentVaryPath)(node.tree.varyPath, varyParams) : (0, _varypath.getSegmentVaryPathForRequest)(_types.FetchStrategy.PPR, node.tree);
+        // 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);
-            if (fetchStrategy === _types.FetchStrategy.StaticShell) {
-                // Re-key at the shell vary path, mirroring the RuntimeShell re-key
-                // in fulfillEntrySpawnedByRuntimePrefetch. Usually the entry already
-                // lives there, but the scheduler can also upgrade a pre-existing
-                // Empty entry at a more concrete path in place, so the re-key is
-                // load-bearing. The shadow eviction keeps a stale settled entry at
-                // a more specific path from hiding the shell entry (the just-written
-                // full payload's entry is preferred and survives it). Routed through
-                // the upsert rather than a bare set so the usual precedence rules
-                // apply: a concurrent task's response (e.g. a RuntimeShell entry)
-                // can land in the shell slot first, and this write must not
-                // downgrade it. (In the common case the slot already holds this
-                // very entry, which the upsert replaces in place.)
-                if (process.env.__NEXT_VARY_PARAMS) {
-                    upsertSegmentEntry(now, node.tree.shellVaryPath, fulfilledEntry, node.tree.varyPath);
-                }
-            } else {
-                // Set the fulfilled entry into the canonical cache slot. Pass the
-                // concrete lookup path — the most specific path a read for this
-                // segment position would use — so that if the canonical path is more
-                // generic (i.e. the server re-keyed the segment), any stale settled
-                // entry at a more specific path (e.g. a partial shell entry) that
-                // would shadow this one is evicted. See evictShadowingSegmentEntries.
-                upsertSegmentEntry(now, payloadVaryPath, fulfilledEntry, node.tree.varyPath);
-            }
+            // 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, // Response-write path, not a locked-navigation prefetch.
-            null), data.rsc, entryStaleAt, isPartial, responseIsUpgradeableISRFallback, recordedFetchStrategy);
-            upsertSegmentEntry(now, payloadVaryPath, fulfilledEntry, node.tree.varyPath);
+            const fulfilledEntry = fulfillSegmentCacheEntry(upgradeToPendingSegment(detachedEntry, fetchStrategy), data.rsc, entryStaleAt, isPartial, responseIsUpgradeableISRFallback, recordedFetchStrategy);
+            upsertSegmentEntry(now, map, payloadVaryPath, fulfilledEntry, node.tree.varyPath);
         }
         node = node.parent;
         dataIndex++;
@@ -1995,7 +1923,7 @@ fetchStrategy) {
         // allowed to revalidate.
         const { serverResponse, shellResponse, responseSize } = result;
         const now = Date.now();
-        writeSegmentBundleResponseVariants(serverResponse, shellResponse, responseSize, segments, segmentCount, now, fetchStrategy);
+        writeSegmentBundleResponseVariants(task.segmentCacheMap, serverResponse, shellResponse, responseSize, segments, segmentCount, now, fetchStrategy);
         task.fallbackRetryStatus = _cachemap.EntryStatus.Fulfilled;
         (0, _scheduler.pingPrefetchTask)(task);
         return;
@@ -2157,7 +2085,7 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
                     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);
+                    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.
@@ -2170,7 +2098,7 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
                     // 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);
+                    writePrerenderResponseIntoCache(now, _types.FetchStrategy.RuntimeShell, shellStageData.f, buildId, shellStageData.h, shellStageData.r ?? null, shellStaleAt, dynamicRequestTree, renderedSearch, isShellStagePartial, task.segmentCacheMap);
                 }
             }
         }
@@ -2193,10 +2121,38 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
         }
         const navigationSeed = (0, _navigation.convertServerPatchToFullTree)(now, dynamicRequestTree, flightDatas, renderedSearch, // Not needed for prefetch responses; pass unknown to use the default.
         _bfcache.UnknownDynamicStaleTime);
+        if (navigationSeed.treeDivergedFromBase && // A head-only request uses the MetadataOnlyRequestTree stub rather than
+        // a tree derived from the route entry, so divergence from it carries
+        // no signal.
+        // TODO: This special case goes away once convertServerPatchToFullTree
+        // diffs against the base RouteTree (route.tree) instead of the
+        // request tree.
+        dynamicRequestTree !== MetadataOnlyRequestTree) {
+            // The server rendered a different route tree than the one we requested:
+            // the URL has a rewrite that behaves dynamically, so the params baked
+            // into the request are wrong and the server can never fulfill it. Mark
+            // the route entry — which doubles as the stored prediction pattern, so
+            // this also disables a bad prediction (see matchKnownRoute) that would
+            // otherwise be re-derived on every retry — and invalidate entries that
+            // were derived from it. This mirrors dispatchRetryDueToTreeMismatch on
+            // the navigation path. It can't loop: the refetched route entry is
+            // built from the server's response, so it only mismatches again if the
+            // rewrite's behavior changes again.
+            markRouteEntryAsDynamicRewrite(route);
+            invalidateRouteCacheEntries(key.nextUrl, task.treeAtTimeOfPrefetch);
+            // Reject with an immediate expiration instead of the usual backoff: the
+            // invalidation above triggers a re-prefetch, which per the above does
+            // not loop.
+            // TODO: Consider also bounding retries with a counter on the task
+            // object, so a prefetch that repeatedly fails to settle backs off
+            // regardless of the reason.
+            rejectSegmentEntriesIfStillPending(spawnedEntries, -1);
+            return null;
+        }
         // Aside from writing the data into the cache, this function also returns
         // the entries that were fulfilled, so we can streamingly update their sizes
         // in the LRU as more data comes in.
-        fulfilledEntries = writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, rootVaryParamsIterable, staleAtForSpawnedEntries, navigationSeed, spawnedEntries);
+        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) {
@@ -2227,7 +2183,8 @@ async function fetchSegmentPrefetchesUsingDynamicRequest(task, route, fetchStrat
         return null;
     }
 }
-function writeDynamicTreeResponseIntoCache(now, fetchStrategy, response, serverData, entry, couldBeIntercepted, canonicalUrl, routeIsPPREnabled, headVaryParams, rootVaryParamsIterable, originalPathname, originalSearch, 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
@@ -2253,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;
@@ -2270,7 +2228,7 @@ 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, rootVaryParamsIterable, 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 = [];
@@ -2283,7 +2241,12 @@ function rejectSegmentEntriesIfStillPending(entries, staleAt) {
     }
     return fulfilledEntries;
 }
-function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, rootVaryParamsIterable, 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.
@@ -2318,7 +2281,9 @@ function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, bu
                     return null;
                 }
             }
-            writeSeedDataIntoCache(now, fetchStrategy, tree, staleAt, seedData, isResponsePartial, rootVaryParamsIterable, 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) {
@@ -2335,7 +2300,9 @@ function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, bu
             //
             // Without Cache Components, the server sends the correct isHeadPartial.
             const isHeadPartial = process.env.__NEXT_CACHE_COMPONENTS ? isResponsePartial : flightDataEntry.isHeadPartial;
-            fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, head, isHeadPartial, staleAt, // For head entries, use the head-specific vary params passed as
+            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);
         }
@@ -2354,7 +2321,7 @@ function writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, bu
     }
     return null;
 }
-function writeSeedDataIntoCache(now, fetchStrategy, tree, staleAt, seedData, isResponsePartial, rootVaryParamsIterable, 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];
@@ -2364,7 +2331,9 @@ function writeSeedDataIntoCache(now, fetchStrategy, tree, staleAt, seedData, isR
     // 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, fetchStrategy, rsc, isPartial, staleAt, varyParams, tree, entriesOwnedByCurrentTask);
+    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) {
@@ -2372,12 +2341,12 @@ function writeSeedDataIntoCache(now, fetchStrategy, tree, staleAt, seedData, isR
         for (const [parallelRouteKey, childTree] of slots){
             const childSeedData = seedDataChildren[parallelRouteKey];
             if (childSeedData !== null && childSeedData !== undefined) {
-                writeSeedDataIntoCache(now, fetchStrategy, childTree, staleAt, childSeedData, isResponsePartial, rootVaryParamsIterable, 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.
     //
@@ -2421,7 +2390,7 @@ function fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, rsc, isPartial
         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, canonicalVaryPath, 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
@@ -2429,40 +2398,40 @@ function fulfillEntrySpawnedByRuntimePrefetch(now, fetchStrategy, rsc, isPartial
             // 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, tree.varyPath, fulfilledEntry);
+            evictShadowingSegmentEntries(now, map, tree.varyPath, fulfilledEntry);
         }
     } else {
-        // There's no matching entry. Attempt to create a new one. This is a
-        // response-write path, not a locked-navigation prefetch.
-        const possiblyNewEntry = readOrCreateSegmentCacheEntry(now, fetchStrategy, tree, null);
+        // There's no matching entry. Attempt to create a new one.
+        let possiblyNewEntry = (0, _cachemap.getFromCacheMap)(now, getCurrentSegmentCacheVersion(), map, tree.varyPath, false, false);
+        if (possiblyNewEntry === null) {
+            possiblyNewEntry = insertEmptySegmentCacheEntry(now, map, fetchStrategy, tree);
+        }
         if (possiblyNewEntry.status === _cachemap.EntryStatus.Empty) {
             // Confirmed this is a new entry. We can fulfill it.
             const newEntry = possiblyNewEntry;
-            const fulfilledEntry = fulfillSegmentCacheEntry(// Response-write path, not a locked-navigation prefetch.
-            upgradeToPendingSegment(newEntry, fetchStrategy, null), rsc, staleAt, isPartial, // Dynamic-request (Full/Runtime) responses are not ISR fallbacks.
+            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, tree.varyPath, fulfilledEntry);
+                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, // Response-write path, not a locked-navigation prefetch.
-            null), rsc, staleAt, isPartial, // Dynamic-request (Full/Runtime) responses are not ISR fallbacks.
+            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, varyPath, newEntry, tree.varyPath);
+            upsertSegmentEntry(now, map, varyPath, newEntry, tree.varyPath);
         }
     }
 }
@@ -2627,7 +2596,9 @@ async function resolveStaleAt(now, staleTimeIterable, response) {
     }
     return now + _navigatereducer.STATIC_STALETIME_MS;
 }
-function writePrerenderResponseIntoCache(now, fetchStrategy, flightData, buildId, headVaryParamsIterable, rootVaryParamsIterable, staleAt, baseTree, renderedSearch, isResponsePartial) {
+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);
@@ -2636,8 +2607,7 @@ function writePrerenderResponseIntoCache(now, fetchStrategy, flightData, buildId
         return;
     }
     const navigationSeed = (0, _navigation.convertServerPatchToFullTree)(now, baseTree, flightDatas, renderedSearch, _bfcache.UnknownDynamicStaleTime);
-    writeDynamicRenderResponseIntoCache(now, fetchStrategy, flightDatas, buildId, isResponsePartial, headVaryParams, rootVaryParamsIterable, 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);