@semiont/frontend 0.3.3 → 0.3.4

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     cancelPrefetchTask: null,
     isPrefetchTaskDirty: null,
+    pingPrefetchScheduler: null,
     pingPrefetchTask: null,
     reschedulePrefetchTask: null,
     schedulePrefetchTask: null,
@@ -23,6 +24,9 @@ _export(exports, {
     isPrefetchTaskDirty: function() {
         return isPrefetchTaskDirty;
     },
+    pingPrefetchScheduler: function() {
+        return pingPrefetchScheduler;
+    },
     pingPrefetchTask: function() {
         return pingPrefetchTask;
     },
@@ -39,10 +43,10 @@ _export(exports, {
 const _approutertypes = require("../../../shared/lib/app-router-types");
 const _matchsegments = require("../match-segments");
 const _cache = require("./cache");
-const _varypath = require("./vary-path");
 const _cachekey = require("./cache-key");
 const _types = require("./types");
 const _segment = require("../../../shared/lib/segment");
+const _lru = require("./lru");
 const scheduleMicrotask = typeof queueMicrotask === 'function' ? queueMicrotask : (fn)=>Promise.resolve().then(fn).catch((error)=>setTimeout(()=>{
             throw error;
         }));
@@ -69,15 +73,16 @@ function startRevalidationCooldown() {
     revalidationCooldownTimeoutHandle = setTimeout(()=>{
         revalidationCooldownTimeoutHandle = null;
         // Retry the prefetch queue now that the cooldown has expired.
-        ensureWorkIsScheduled();
+        pingPrefetchScheduler();
     }, REVALIDATION_COOLDOWN_MS);
 }
-function schedulePrefetchTask(key, treeAtTimeOfPrefetch, fetchStrategy, priority, onInvalidate) {
+function schedulePrefetchTask(key, treeAtTimeOfPrefetch, fetchStrategy, priority, onInvalidate, _onComplete) {
     // Spawn a new prefetch task
     const task = {
         key,
         treeAtTimeOfPrefetch,
-        cacheVersion: (0, _cache.getCurrentCacheVersion)(),
+        routeCacheVersion: (0, _cache.getCurrentRouteCacheVersion)(),
+        segmentCacheVersion: (0, _cache.getCurrentSegmentCacheVersion)(),
         priority,
         phase: 1,
         hasBackgroundWork: false,
@@ -88,6 +93,9 @@ function schedulePrefetchTask(key, treeAtTimeOfPrefetch, fetchStrategy, priority
         onInvalidate,
         _heapIndex: -1
     };
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        task._onComplete = _onComplete;
+    }
     trackMostRecentlyHoveredLink(task);
     heapPush(taskHeap, task);
     // Schedule an async task to process the queue.
@@ -97,7 +105,7 @@ function schedulePrefetchTask(key, treeAtTimeOfPrefetch, fetchStrategy, priority
     // By deferring to a microtask, we only process the queue once per JS task.
     // If they have different priorities, it also ensures they are processed in
     // the optimal order.
-    ensureWorkIsScheduled();
+    pingPrefetchScheduler();
     return task;
 }
 function cancelPrefetchTask(task) {
@@ -108,6 +116,14 @@ function cancelPrefetchTask(task) {
     // does not get added back to the queue when it's pinged by the network.
     task.isCanceled = true;
     heapDelete(taskHeap, task);
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        // Call completion callback. In practice this shouldn't be reached for
+        // test-initiated prefetches since cancellation is only used by the Link
+        // component when elements scroll out of viewport.
+        const onComplete = task._onComplete;
+        task._onComplete = undefined;
+        onComplete?.();
+    }
 }
 function reschedulePrefetchTask(task, treeAtTimeOfPrefetch, fetchStrategy, priority) {
     // Bump the prefetch task to the top of the queue, as if it were a fresh
@@ -116,6 +132,10 @@ function reschedulePrefetchTask(task, treeAtTimeOfPrefetch, fetchStrategy, prior
     //
     // The primary use case is to increase the priority of a Link-initated
     // prefetch on hover.
+    //
+    // Note: _onComplete is not reset here because it's preserved on the same
+    // task object. When the rescheduled task completes, the original callback
+    // will still be invoked.
     // Un-cancel the task, in case it was previously canceled.
     task.isCanceled = false;
     task.phase = 1;
@@ -134,7 +154,7 @@ function reschedulePrefetchTask(task, treeAtTimeOfPrefetch, fetchStrategy, prior
     } else {
         heapPush(taskHeap, task);
     }
-    ensureWorkIsScheduled();
+    pingPrefetchScheduler();
 }
 function isPrefetchTaskDirty(task, nextUrl, tree) {
     // This is used to quickly bail out of a prefetch task if the result is
@@ -142,8 +162,7 @@ function isPrefetchTaskDirty(task, nextUrl, tree) {
     // strictly an optimization — theoretically, if it always returned true, no
     // behavior should change because a full prefetch task will effectively
     // perform the same checks.
-    const currentCacheVersion = (0, _cache.getCurrentCacheVersion)();
-    return task.cacheVersion !== currentCacheVersion || task.treeAtTimeOfPrefetch !== tree || task.key.nextUrl !== nextUrl;
+    return task.routeCacheVersion !== (0, _cache.getCurrentRouteCacheVersion)() || task.segmentCacheVersion !== (0, _cache.getCurrentSegmentCacheVersion)() || task.treeAtTimeOfPrefetch !== tree || task.key.nextUrl !== nextUrl;
 }
 function trackMostRecentlyHoveredLink(task) {
     // Track the mostly recently hovered link, i.e. the most recently scheduled
@@ -159,7 +178,7 @@ function trackMostRecentlyHoveredLink(task) {
         mostRecentlyHoveredLink = task;
     }
 }
-function ensureWorkIsScheduled() {
+function pingPrefetchScheduler() {
     if (didScheduleMicrotask) {
         // Already scheduled a task to process the queue
         return;
@@ -229,7 +248,7 @@ function onPrefetchConnectionClosed() {
     inProgressRequests--;
     // Notify the scheduler that we have more bandwidth, and can continue
     // processing tasks.
-    ensureWorkIsScheduled();
+    pingPrefetchScheduler();
 }
 function pingPrefetchTask(task) {
     // "Ping" a prefetch that's already in progress to notify it of new data.
@@ -240,7 +259,7 @@ function pingPrefetchTask(task) {
     }
     // Add the task back to the queue.
     heapPush(taskHeap, task);
-    ensureWorkIsScheduled();
+    pingPrefetchScheduler();
 }
 function processQueueInMicrotask() {
     didScheduleMicrotask = false;
@@ -251,7 +270,8 @@ function processQueueInMicrotask() {
     // Process the task queue until we run out of network bandwidth.
     let task = heapPeek(taskHeap);
     while(task !== null && hasNetworkBandwidth(task)){
-        task.cacheVersion = (0, _cache.getCurrentCacheVersion)();
+        task.routeCacheVersion = (0, _cache.getCurrentRouteCacheVersion)();
+        task.segmentCacheVersion = (0, _cache.getCurrentSegmentCacheVersion)();
         const exitStatus = pingRoute(now, task);
         // These fields are only valid for a single attempt. Reset them after each
         // iteration of the task queue.
@@ -283,6 +303,13 @@ function processQueueInMicrotask() {
                     heapResift(taskHeap, task);
                 } else {
                     // The prefetch is complete. Continue to the next task.
+                    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+                        // Notify the Instant Navigation Testing API that the prefetch has
+                        // completed, so it can proceed with navigation.
+                        const onComplete = task._onComplete;
+                        task._onComplete = undefined;
+                        onComplete?.();
+                    }
                     heapPop(taskHeap);
                 }
                 task = heapPeek(taskHeap);
@@ -291,6 +318,13 @@ function processQueueInMicrotask() {
                 exitStatus;
         }
     }
+    // Run LRU cleanup only when the scheduler is fully idle: no queued tasks and
+    // no in-progress requests. At that point, all active prefetch tasks have
+    // finished reading from the cache (moving recently used entries to the front
+    // of the list), so only genuinely stale data gets evicted.
+    if (task === null && inProgressRequests === 0) {
+        (0, _lru.cleanup)();
+    }
 }
 /**
  * Check this during a prefetch task to determine if background work can be
@@ -332,7 +366,7 @@ function pingRoute(now, task) {
                 {
                     if (background(task)) {
                         routeWithoutSearch.status = _cache.EntryStatus.Pending;
-                        spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(routeWithoutSearch, task, keyWithoutSearch));
+                        spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(routeWithoutSearch, keyWithoutSearch));
                     }
                     break;
                 }
@@ -365,7 +399,7 @@ function pingRootRouteTree(now, task, route) {
                 // behavior if PPR is disabled for a route (via the incremental opt-in).
                 //
                 // Those cases will be handled here.
-                spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(route, task, task.key));
+                spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(route, task.key));
                 // If the request takes longer than a minute, a subsequent request should
                 // retry instead of waiting for this one. When the response is received,
                 // this value will be replaced by a new value based on the stale time sent
@@ -413,7 +447,26 @@ function pingRootRouteTree(now, task, route) {
                 // If it turned out that the route isn't PPR-enabled, we need to use `LoadingBoundary` instead.
                 // We don't need to do this for runtime prefetches, because those are only available in
                 // `cacheComponents`, where every route is PPR.
-                const fetchStrategy = task.fetchStrategy === _types.FetchStrategy.PPR ? route.isPPREnabled ? _types.FetchStrategy.PPR : _types.FetchStrategy.LoadingBoundary : task.fetchStrategy;
+                let fetchStrategy;
+                if (tree.prefetchHints & _approutertypes.PrefetchHint.SubtreeHasInstant) {
+                    // If `instant` is defined anywhere on the target route, ignore the
+                    // fetch strategy and switch to unified strategy used by Cache
+                    // Components (called `PPR` for now, will likely be renamed).
+                    //
+                    // In practice, this just means that a "full" prefetch (<Link
+                    // prefetch={true}>) has no effect. You're meant to use Runtime
+                    // Prefetching instead — that's the new pattern that replaces
+                    // prefetch={true}.
+                    //
+                    // The reason we check for `instant` rather than the `cacheComponents`
+                    // flag is to support incremental adoption. `prefetch={true}` will
+                    // continue to work until you opt into `instant`.
+                    fetchStrategy = _types.FetchStrategy.PPR;
+                } else if (task.fetchStrategy === _types.FetchStrategy.PPR) {
+                    fetchStrategy = route.supportsPerSegmentPrefetching ? _types.FetchStrategy.PPR : _types.FetchStrategy.LoadingBoundary;
+                } else {
+                    fetchStrategy = task.fetchStrategy;
+                }
                 switch(fetchStrategy){
                     case _types.FetchStrategy.PPR:
                         {
@@ -482,7 +535,7 @@ function pingStaticHead(now, task, route) {
     // The Head data for a page (metadata, viewport) is not really a route
     // segment, in the sense that it doesn't appear in the route tree. But we
     // store it in the cache as if it were, using a special key.
-    pingStaticSegmentData(now, task, route, (0, _cache.readOrCreateSegmentCacheEntry)(now, _types.FetchStrategy.PPR, route, route.metadata), task.key, route.metadata);
+    pingStaticSegmentData(now, task, route, (0, _cache.readOrCreateSegmentCacheEntry)(now, _types.FetchStrategy.PPR, route.metadata), task.key, route.metadata);
 }
 function pingRuntimeHead(now, task, route, spawnedEntries, fetchStrategy) {
     pingRouteTreeAndIncludeDynamicData(now, task, route, route.metadata, false, spawnedEntries, // When prefetching the head, there's no difference between Full
@@ -502,7 +555,7 @@ function pingSharedPartOfCacheComponentsTree(now, task, route, oldTree, newTree)
     // "new" part of the tree, we switch to a different traversal,
     // pingNewPartOfCacheComponentsTree.
     // Prefetch this segment's static data.
-    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.fetchStrategy, route, newTree);
+    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.fetchStrategy, newTree);
     pingStaticSegmentData(now, task, route, segment, task.key, newTree);
     // Recursively ping the children.
     const oldTreeChildren = oldTree[1];
@@ -540,7 +593,7 @@ function pingNewPartOfCacheComponentsTree(now, task, route, tree) {
     // shared layouts.) Segments in here default to being prefetched statically.
     // However, if the server instructs us to, we may switch to a runtime
     // prefetch instead. Traverse the tree and check at each segment.
-    if (tree.hasRuntimePrefetch) {
+    if (tree.prefetchHints & _approutertypes.PrefetchHint.HasRuntimePrefetch) {
         // This route has a runtime prefetch response. Since we're below the shared
         // layout, everything from this point should be prefetched using a single,
         // combined runtime request, rather than using per-segment static requests.
@@ -571,7 +624,7 @@ function pingNewPartOfCacheComponentsTree(now, task, route, tree) {
         return 2;
     }
     // This segment should not be runtime prefetched. Prefetch its static data.
-    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.fetchStrategy, route, tree);
+    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.fetchStrategy, tree);
     pingStaticSegmentData(now, task, route, segment, task.key, tree);
     if (tree.slots !== null) {
         if (!hasNetworkBandwidth(task)) {
@@ -633,7 +686,7 @@ function diffRouteTreeAgainstCurrent(now, task, route, oldTree, newTree, spawned
                             // inside new part of the tree. If there's no loading boundary
                             // anywhere in the tree, the server will never return any data, so
                             // we can skip the request.
-                            const subtreeHasLoadingBoundary = newTreeChild.hasLoadingBoundary !== _approutertypes.HasLoadingBoundary.SubtreeHasNoLoadingBoundary;
+                            const subtreeHasLoadingBoundary = (newTreeChild.prefetchHints & (_approutertypes.PrefetchHint.SegmentHasLoadingBoundary | _approutertypes.PrefetchHint.SubtreeHasLoadingBoundary)) !== 0;
                             const requestTreeChild = subtreeHasLoadingBoundary ? pingPPRDisabledRouteTreeUpToLoadingBoundary(now, task, route, newTreeChild, null, spawnedEntries) : (0, _cache.convertRouteTreeToFlightRouterState)(newTreeChild);
                             requestTreeChildren[parallelRouteKey] = requestTreeChild;
                             break;
@@ -679,8 +732,7 @@ function diffRouteTreeAgainstCurrent(now, task, route, oldTree, newTree, spawned
         newTree.segment,
         requestTreeChildren,
         null,
-        null,
-        newTree.isRootLayout
+        null
     ];
     return requestTree;
 }
@@ -696,7 +748,7 @@ function pingPPRDisabledRouteTreeUpToLoadingBoundary(now, task, route, tree, ref
     // "inside-shared-layout" tells the server where to start looking for a
     // loading boundary.
     let refetchMarker = refetchMarkerContext === null ? 'inside-shared-layout' : null;
-    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.fetchStrategy, route, tree);
+    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.fetchStrategy, tree);
     switch(segment.status){
         case _cache.EntryStatus.Empty:
             {
@@ -723,7 +775,7 @@ function pingPPRDisabledRouteTreeUpToLoadingBoundary(now, task, route, tree, ref
         case _cache.EntryStatus.Fulfilled:
             {
                 // The segment is already cached.
-                const segmentHasLoadingBoundary = tree.hasLoadingBoundary === _approutertypes.HasLoadingBoundary.SegmentHasLoadingBoundary;
+                const segmentHasLoadingBoundary = (tree.prefetchHints & _approutertypes.PrefetchHint.SegmentHasLoadingBoundary) !== 0;
                 if (segmentHasLoadingBoundary) {
                     // This segment has a loading boundary, which means the server won't
                     // render its children. So there's nothing left to prefetch along this
@@ -754,8 +806,7 @@ function pingPPRDisabledRouteTreeUpToLoadingBoundary(now, task, route, tree, ref
         tree.segment,
         requestTreeChildren,
         null,
-        refetchMarker,
-        tree.isRootLayout
+        refetchMarker
     ];
     return requestTree;
 }
@@ -773,12 +824,21 @@ function pingRouteTreeAndIncludeDynamicData(now, task, route, tree, isInsideRefe
     // We can have a task with `FetchStrategy.PPR` where some of its segments are configured to
     // always use runtime prefetching (via `export const prefetch`), and those should check for
     // entries that include search params.
-    fetchStrategy, route, tree);
+    fetchStrategy, tree);
     let spawnedSegment = null;
     switch(segment.status){
         case _cache.EntryStatus.Empty:
             {
-                // This segment is not cached. Include it in the request.
+                // This segment is not cached.
+                if (fetchStrategy === _types.FetchStrategy.Full) {
+                    // Check if there's a matching entry in the bfcache. If so, fulfill the
+                    // segment using the bfcache entry instead of issuing a new request.
+                    const fulfilled = (0, _cache.attemptToFulfillDynamicSegmentFromBFCache)(now, segment, tree);
+                    if (fulfilled !== null) {
+                        break;
+                    }
+                }
+                // Include it in the request.
                 spawnedSegment = (0, _cache.upgradeToPendingSegment)(segment, fetchStrategy);
                 break;
             }
@@ -786,12 +846,23 @@ function pingRouteTreeAndIncludeDynamicData(now, task, route, tree, isInsideRefe
             {
                 // The segment is already cached.
                 if (segment.isPartial && (0, _cache.canNewFetchStrategyProvideMoreContent)(segment.fetchStrategy, fetchStrategy)) {
-                    // The cached segment contains dynamic holes, and was prefetched using a less specific strategy than the current one.
-                    // This means we're in one of these cases:
+                    // The cached segment contains dynamic holes, and was prefetched using a
+                    // less specific strategy than the current one. This means we're in one
+                    // of these cases:
                     //   - we have a static prefetch, and we're doing a runtime prefetch
-                    //   - we have a static or runtime prefetch, and we're doing a Full prefetch (or a navigation).
-                    // In either case, we need to include it in the request to get a more specific (or full) version.
-                    spawnedSegment = pingFullSegmentRevalidation(now, route, tree, fetchStrategy);
+                    //   - we have a static or runtime prefetch, and we're doing a Full
+                    //     prefetch (or a navigation).
+                    // In either case, we need to include it in the request to get a more
+                    // specific (or full) version. However, if there's a non-stale bfcache
+                    // entry from a previous navigation, prefer that over making a new
+                    // request.
+                    if (fetchStrategy === _types.FetchStrategy.Full) {
+                        const fulfilled = (0, _cache.attemptToUpgradeSegmentFromBFCache)(now, tree);
+                        if (fulfilled !== null) {
+                            break;
+                        }
+                    }
+                    spawnedSegment = pingFullSegmentRevalidation(now, tree, fetchStrategy);
                 }
                 break;
             }
@@ -801,7 +872,7 @@ function pingRouteTreeAndIncludeDynamicData(now, task, route, tree, isInsideRefe
                 // There's either another prefetch currently in progress, or the previous
                 // attempt failed. If the new strategy can provide more content, fetch it again.
                 if ((0, _cache.canNewFetchStrategyProvideMoreContent)(segment.fetchStrategy, fetchStrategy)) {
-                    spawnedSegment = pingFullSegmentRevalidation(now, route, tree, fetchStrategy);
+                    spawnedSegment = pingFullSegmentRevalidation(now, tree, fetchStrategy);
                 }
                 break;
             }
@@ -825,8 +896,7 @@ function pingRouteTreeAndIncludeDynamicData(now, task, route, tree, isInsideRefe
         tree.segment,
         requestTreeChildren,
         null,
-        refetchMarker,
-        tree.isRootLayout
+        refetchMarker
     ];
     return requestTree;
 }
@@ -861,6 +931,18 @@ function pingRuntimePrefetches(now, task, route, tree, spawnedRuntimePrefetches,
 function pingStaticSegmentData(now, task, route, segment, routeKey, tree) {
     switch(segment.status){
         case _cache.EntryStatus.Empty:
+            if (process.env.__NEXT_PREFETCH_INLINING) {
+                // All segment data for this route is bundled into a single
+                // /_inlined response. Walk the full route tree to collect all
+                // Empty segments, upgrade them to Pending, and spawn one
+                // bundled request. Subsequent calls for other segments in the
+                // same tree will see them as Pending and skip.
+                const inlinedEntries = collectInlinedEntries(now, route);
+                if (inlinedEntries.size > 0) {
+                    spawnPrefetchSubtask((0, _cache.fetchInlinedSegmentsOnCacheMiss)(route, routeKey, route.tree, inlinedEntries));
+                }
+                break;
+            }
             // Upgrade to Pending so we know there's already a request in progress
             spawnPrefetchSubtask((0, _cache.fetchSegmentOnCacheMiss)(route, (0, _cache.upgradeToPendingSegment)(segment, _types.FetchStrategy.PPR), routeKey, tree));
             break;
@@ -925,13 +1007,38 @@ function pingStaticSegmentData(now, task, route, segment, routeKey, tree) {
 // there's nothing else for us to do (except write the server data into the
 // entry, which is handled by `fetchSegmentOnCacheMiss`).
 }
+/**
+ * Walks the RouteTree (including the head metadata) and collects any segments
+ * that are still Empty into a Map, upgrading them to Pending. These entries
+ * will be fulfilled by the inlined prefetch response.
+ */ function collectInlinedEntries(now, route) {
+    const entries = new Map();
+    collectInlinedEntriesImpl(now, route.tree, entries);
+    // Also collect the head/metadata entry.
+    const headEntry = (0, _cache.readOrCreateSegmentCacheEntry)(now, _types.FetchStrategy.PPR, route.metadata);
+    if (headEntry.status === _cache.EntryStatus.Empty) {
+        entries.set(route.metadata.requestKey, (0, _cache.upgradeToPendingSegment)(headEntry, _types.FetchStrategy.PPR));
+    }
+    return entries;
+}
+function collectInlinedEntriesImpl(now, tree, entries) {
+    const entry = (0, _cache.readOrCreateSegmentCacheEntry)(now, _types.FetchStrategy.PPR, tree);
+    if (entry.status === _cache.EntryStatus.Empty) {
+        entries.set(tree.requestKey, (0, _cache.upgradeToPendingSegment)(entry, _types.FetchStrategy.PPR));
+    }
+    if (tree.slots !== null) {
+        for(const parallelRouteKey in tree.slots){
+            collectInlinedEntriesImpl(now, tree.slots[parallelRouteKey], entries);
+        }
+    }
+}
 function pingPPRSegmentRevalidation(now, route, routeKey, tree) {
-    const revalidatingSegment = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, _types.FetchStrategy.PPR, route, tree);
+    const revalidatingSegment = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, _types.FetchStrategy.PPR, tree);
     switch(revalidatingSegment.status){
         case _cache.EntryStatus.Empty:
-            // Spawn a prefetch request and upsert the segment into the cache
-            // upon completion.
-            upsertSegmentOnCompletion(spawnPrefetchSubtask((0, _cache.fetchSegmentOnCacheMiss)(route, (0, _cache.upgradeToPendingSegment)(revalidatingSegment, _types.FetchStrategy.PPR), routeKey, tree)), (0, _varypath.getSegmentVaryPathForRequest)(_types.FetchStrategy.PPR, tree));
+            // Spawn a prefetch request. The fetch function handles upserting
+            // the entry at the correct fulfilled vary path upon completion.
+            spawnPrefetchSubtask((0, _cache.fetchSegmentOnCacheMiss)(route, (0, _cache.upgradeToPendingSegment)(revalidatingSegment, _types.FetchStrategy.PPR), routeKey, tree));
             break;
         case _cache.EntryStatus.Pending:
             break;
@@ -942,8 +1049,8 @@ function pingPPRSegmentRevalidation(now, route, routeKey, tree) {
             revalidatingSegment;
     }
 }
-function pingFullSegmentRevalidation(now, route, tree, fetchStrategy) {
-    const revalidatingSegment = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, fetchStrategy, route, tree);
+function pingFullSegmentRevalidation(now, tree, fetchStrategy) {
+    const revalidatingSegment = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, fetchStrategy, tree);
     if (revalidatingSegment.status === _cache.EntryStatus.Empty) {
         // During a Full/PPRRuntime prefetch, a single dynamic request is made for all the
         // segments that we need. So we don't initiate a request here directly. By
@@ -951,7 +1058,8 @@ function pingFullSegmentRevalidation(now, route, tree, fetchStrategy) {
         // that this segment should be included in the request that's sent to
         // the server.
         const pendingSegment = (0, _cache.upgradeToPendingSegment)(revalidatingSegment, fetchStrategy);
-        upsertSegmentOnCompletion((0, _cache.waitForSegmentCacheEntry)(pendingSegment), (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree));
+        // The upsert is handled by fulfillEntrySpawnedByRuntimePrefetch
+        // when the dynamic prefetch response is written into the cache.
         return pendingSegment;
     } else {
         // There's already a revalidation in progress.
@@ -959,9 +1067,10 @@ function pingFullSegmentRevalidation(now, route, tree, fetchStrategy) {
         if ((0, _cache.canNewFetchStrategyProvideMoreContent)(nonEmptyRevalidatingSegment.fetchStrategy, fetchStrategy)) {
             // The existing revalidation was fetched using a less specific strategy.
             // Reset it and start a new revalidation.
-            const emptySegment = (0, _cache.overwriteRevalidatingSegmentCacheEntry)(fetchStrategy, route, tree);
+            const emptySegment = (0, _cache.overwriteRevalidatingSegmentCacheEntry)(now, fetchStrategy, tree);
             const pendingSegment = (0, _cache.upgradeToPendingSegment)(emptySegment, fetchStrategy);
-            upsertSegmentOnCompletion((0, _cache.waitForSegmentCacheEntry)(pendingSegment), (0, _varypath.getSegmentVaryPathForRequest)(fetchStrategy, tree));
+            // The upsert is handled by fulfillEntrySpawnedByRuntimePrefetch
+            // when the dynamic prefetch response is written into the cache.
             return pendingSegment;
         }
         switch(nonEmptyRevalidatingSegment.status){
@@ -980,16 +1089,6 @@ function pingFullSegmentRevalidation(now, route, tree, fetchStrategy) {
         }
     }
 }
-const noop = ()=>{};
-function upsertSegmentOnCompletion(promise, varyPath) {
-    // Wait for a segment to finish loading, then upsert it into the cache
-    promise.then((fulfilled)=>{
-        if (fulfilled !== null) {
-            // Received new data. Attempt to replace the existing entry in the cache.
-            (0, _cache.upsertSegmentEntry)(Date.now(), varyPath, fulfilled);
-        }
-    }, noop);
-}
 function doesCurrentSegmentMatchCachedSegment(route, currentSegment, cachedSegment) {
     if (cachedSegment === _segment.PAGE_SEGMENT_KEY) {
         // In the FlightRouterState stored by the router, the page segment has the

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

@@ -9,6 +9,10 @@ Object.defineProperty(exports, "__esModule", {
     finalizeMetadataVaryPath: null,
     finalizePageVaryPath: null,
     getFulfilledRouteVaryPath: null,
+    getFulfilledSegmentVaryPath: null,
+    getPartialLayoutVaryPath: null,
+    getPartialPageVaryPath: null,
+    getRenderedSearchFromVaryPath: null,
     getRouteVaryPath: null,
     getSegmentVaryPathForRequest: null
 });
@@ -37,6 +41,18 @@ _export(exports, {
     getFulfilledRouteVaryPath: function() {
         return getFulfilledRouteVaryPath;
     },
+    getFulfilledSegmentVaryPath: function() {
+        return getFulfilledSegmentVaryPath;
+    },
+    getPartialLayoutVaryPath: function() {
+        return getPartialLayoutVaryPath;
+    },
+    getPartialPageVaryPath: function() {
+        return getPartialPageVaryPath;
+    },
+    getRenderedSearchFromVaryPath: function() {
+        return getRenderedSearchFromVaryPath;
+    },
     getRouteVaryPath: function() {
         return getRouteVaryPath;
     },
@@ -50,10 +66,13 @@ const _segmentvalueencoding = require("../../../shared/lib/segment-cache/segment
 function getRouteVaryPath(pathname, search, nextUrl) {
     // requestKey -> searchParams -> nextUrl
     const varyPath = {
+        id: null,
         value: pathname,
         parent: {
+            id: '?',
             value: search,
             parent: {
+                id: null,
                 value: nextUrl,
                 parent: null
             }
@@ -66,10 +85,13 @@ function getFulfilledRouteVaryPath(pathname, search, nextUrl, couldBeIntercepted
     // re-keyed based on which inputs the response varies by.
     // requestKey -> searchParams -> nextUrl
     const varyPath = {
+        id: null,
         value: pathname,
         parent: {
+            id: '?',
             value: search,
             parent: {
+                id: null,
                 value: couldBeIntercepted ? nextUrl : _cachemap.Fallback,
                 parent: null
             }
@@ -77,8 +99,9 @@ function getFulfilledRouteVaryPath(pathname, search, nextUrl, couldBeIntercepted
     };
     return varyPath;
 }
-function appendLayoutVaryPath(parentPath, cacheKey) {
+function appendLayoutVaryPath(parentPath, cacheKey, paramName) {
     const varyPathPart = {
+        id: paramName,
         value: cacheKey,
         parent: parentPath
     };
@@ -86,23 +109,34 @@ function appendLayoutVaryPath(parentPath, cacheKey) {
 }
 function finalizeLayoutVaryPath(requestKey, varyPath) {
     const layoutVaryPath = {
+        id: null,
         value: requestKey,
         parent: varyPath
     };
     return layoutVaryPath;
 }
+function getPartialLayoutVaryPath(finalizedVaryPath) {
+    // This is the inverse of finalizeLayoutVaryPath.
+    return finalizedVaryPath.parent;
+}
 function finalizePageVaryPath(requestKey, renderedSearch, varyPath) {
     // Unlike layouts, a page segment's vary path also includes the search string.
     // requestKey -> searchParams -> pathParams
     const pageVaryPath = {
+        id: null,
         value: requestKey,
         parent: {
+            id: '?',
             value: renderedSearch,
             parent: varyPath
         }
     };
     return pageVaryPath;
 }
+function getPartialPageVaryPath(finalizedVaryPath) {
+    // This is the inverse of finalizePageVaryPath.
+    return finalizedVaryPath.parent.parent;
+}
 function finalizeMetadataVaryPath(pageRequestKey, renderedSearch, varyPath) {
     // The metadata "segment" is not a real segment because it doesn't exist in
     // the normal structure of the route tree, but in terms of caching, it
@@ -129,11 +163,13 @@ function finalizeMetadataVaryPath(pageRequestKey, renderedSearch, varyPath) {
     // different parallel pages are things like route groups and parallel
     // route slots. As long as it's always the same one, it doesn't matter.
     const pageVaryPath = {
+        id: null,
         // Append the actual metadata request key to the page request key. Note
         // that we're not using a separate vary path part; it's unnecessary because
         // these are not conceptually separate inputs.
         value: pageRequestKey + _segmentvalueencoding.HEAD_REQUEST_KEY,
         parent: {
+            id: '?',
             value: renderedSearch,
             parent: varyPath
         }
@@ -181,8 +217,10 @@ function getSegmentVaryPathForRequest(fetchStrategy, tree) {
             const searchParamsVaryPath = originalVaryPath.parent;
             const pathParamsVaryPath = searchParamsVaryPath.parent;
             const patchedVaryPath = {
+                id: null,
                 value: originalVaryPath.value,
                 parent: {
+                    id: '?',
                     value: _cachemap.Fallback,
                     parent: pathParamsVaryPath
                 }
@@ -198,14 +236,38 @@ function clonePageVaryPathWithNewSearchParams(originalVaryPath, newSearch) {
     //               ^ This part gets replaced with newSearch
     const searchParamsVaryPath = originalVaryPath.parent;
     const clonedVaryPath = {
+        id: null,
         value: originalVaryPath.value,
         parent: {
+            id: '?',
             value: newSearch,
             parent: searchParamsVaryPath.parent
         }
     };
     return clonedVaryPath;
 }
+function getRenderedSearchFromVaryPath(varyPath) {
+    const searchParams = varyPath.parent.value;
+    return typeof searchParams === 'string' ? searchParams : null;
+}
+function getFulfilledSegmentVaryPath(original, varyParams) {
+    // Re-keys a segment's vary path based on which params the segment actually
+    // depends on. Params that are NOT in the varyParams set are replaced with
+    // Fallback, allowing the cache entry to be reused across different values of
+    // those params.
+    // This is called when a segment is fulfilled with data from the server. The
+    // varyParams set comes from the server and indicates which params were
+    // accessed during rendering.
+    const clone = {
+        id: original.id,
+        // If the id is null, this node is not a param (e.g., it's a request key).
+        // If the id is in the varyParams set, keep the original value.
+        // Otherwise, replace with Fallback to make it reusable.
+        value: original.id === null || varyParams.has(original.id) ? original.value : _cachemap.Fallback,
+        parent: original.parent === null ? null : getFulfilledSegmentVaryPath(original.parent, varyParams)
+    };
+    return clone;
+}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });

package/standalone/node_modules/next/dist/client/components/unauthorized.js

@@ -32,7 +32,7 @@ function unauthorized() {
         });
     }
     const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
-        value: "E394",
+        value: "E1002",
         enumerable: false,
         configurable: true
     });