failproofai 1.0.11-beta.0 → 1.0.11-beta.2

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

@@ -5,12 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     cancelPrefetchTask: null,
     isPrefetchTaskDirty: null,
+    needsSpeculativePrefetch: null,
     pingPrefetchScheduler: null,
     pingPrefetchTask: null,
     reschedulePrefetchTask: null,
     schedulePrefetchTask: null,
-    startRevalidationCooldown: null,
-    subtreeHasSpeculativePrefetch: null
+    startRevalidationCooldown: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -25,6 +25,9 @@ _export(exports, {
     isPrefetchTaskDirty: function() {
         return isPrefetchTaskDirty;
     },
+    needsSpeculativePrefetch: function() {
+        return needsSpeculativePrefetch;
+    },
     pingPrefetchScheduler: function() {
         return pingPrefetchScheduler;
     },
@@ -39,18 +42,13 @@ _export(exports, {
     },
     startRevalidationCooldown: function() {
         return startRevalidationCooldown;
-    },
-    subtreeHasSpeculativePrefetch: function() {
-        return subtreeHasSpeculativePrefetch;
     }
 });
+const _varypath = require("./vary-path");
 const _approutertypes = require("../../../shared/lib/app-router-types");
-const _matchsegments = require("../match-segments");
 const _cache = require("./cache");
 const _cachekey = require("./cache-key");
-const _routeparams = require("../../route-params");
 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;
@@ -81,7 +79,7 @@ function startRevalidationCooldown() {
         pingPrefetchScheduler();
     }, REVALIDATION_COOLDOWN_MS);
 }
-function schedulePrefetchTask(key, treeAtTimeOfPrefetch, fetchStrategy, priority, onInvalidate, navigationLockPrefetch) {
+function schedulePrefetchTask(key, renderTreeAtTimeOfPrefetch, fetchStrategy, priority, onInvalidate, navigationLockPrefetch) {
     // Bind the task to the segment cache map that is active right now: the
     // shared map, unless the Instant Navigation Testing lock is held, in which
     // case the task gets the lock scope's private map. This is the single
@@ -98,7 +96,7 @@ function schedulePrefetchTask(key, treeAtTimeOfPrefetch, fetchStrategy, priority
     // Spawn a new prefetch task
     const task = {
         key,
-        treeAtTimeOfPrefetch,
+        renderTreeAtTimeOfPrefetch,
         routeCacheVersion: (0, _cache.getCurrentRouteCacheVersion)(),
         segmentCacheVersion: (0, _cache.getCurrentSegmentCacheVersion)(),
         segmentCacheMap: taskSegmentCacheMap,
@@ -140,7 +138,7 @@ function cancelPrefetchTask(task) {
     // bails (settling its status to Rejected), so there's nothing to clean up here.
     heapDelete(taskHeap, task);
 }
-function reschedulePrefetchTask(task, treeAtTimeOfPrefetch, fetchStrategy, priority) {
+function reschedulePrefetchTask(task, renderTreeAtTimeOfPrefetch, fetchStrategy, priority) {
     // Bump the prefetch task to the top of the queue, as if it were a fresh
     // task. This is essentially the same as canceling the task and scheduling
     // a new one, except it reuses the original object.
@@ -160,7 +158,7 @@ function reschedulePrefetchTask(task, treeAtTimeOfPrefetch, fetchStrategy, prior
     task.priority = // If this task is the most recently hovered link, maintain its
     // Intent priority, even if the rescheduled priority is lower.
     task === mostRecentlyHoveredLink ? _types.PrefetchPriority.Intent : priority;
-    task.treeAtTimeOfPrefetch = treeAtTimeOfPrefetch;
+    task.renderTreeAtTimeOfPrefetch = renderTreeAtTimeOfPrefetch;
     task.fetchStrategy = fetchStrategy;
     trackMostRecentlyHoveredLink(task);
     if (task._heapIndex !== -1) {
@@ -171,13 +169,13 @@ function reschedulePrefetchTask(task, treeAtTimeOfPrefetch, fetchStrategy, prior
     }
     pingPrefetchScheduler();
 }
-function isPrefetchTaskDirty(task, nextUrl, tree) {
+function isPrefetchTaskDirty(task, nextUrl, root) {
     // This is used to quickly bail out of a prefetch task if the result is
     // guaranteed to not have changed since the task was initiated. This is
     // strictly an optimization — theoretically, if it always returned true, no
     // behavior should change because a full prefetch task will effectively
     // perform the same checks.
-    return task.routeCacheVersion !== (0, _cache.getCurrentRouteCacheVersion)() || task.segmentCacheVersion !== (0, _cache.getCurrentSegmentCacheVersion)() || task.treeAtTimeOfPrefetch !== tree || task.key.nextUrl !== nextUrl;
+    return task.routeCacheVersion !== (0, _cache.getCurrentRouteCacheVersion)() || task.segmentCacheVersion !== (0, _cache.getCurrentSegmentCacheVersion)() || task.renderTreeAtTimeOfPrefetch !== root || task.key.nextUrl !== nextUrl;
 }
 function trackMostRecentlyHoveredLink(task) {
     // Track the mostly recently hovered link, i.e. the most recently scheduled
@@ -321,15 +319,14 @@ function processQueueInMicrotask() {
                     // Finished prefetching the route tree. The two-phase (Shell then
                     // Speculative) flow only applies to routes that have opted into
                     // Partial Prefetching — either globally via the `partialPrefetching`
-                    // config or per segment (`prefetch: 'partial'` or
-                    // `'unstable_eager'`), all surfaced as the
+                    // config or per segment (`prefetch: 'partial'`), both surfaced as the
                     // `SubtreeHasPartialPrefetching` hint on the route tree. Every other
                     // route skips the Shell phase and goes straight to Speculative.
                     //
                     // The route entry is fulfilled at this point (the RouteTree phase
                     // just completed), so its prefetch hints are available.
                     const route = (0, _cache.readRouteCacheEntry)(now, task.key);
-                    const routeHasPartialPrefetching = route !== null && route.status === _cache.EntryStatus.Fulfilled && (route.tree.prefetchHints & _approutertypes.PrefetchHint.SubtreeHasPartialPrefetching) !== 0;
+                    const routeHasPartialPrefetching = route !== null && route.status === _cache.EntryStatus.Fulfilled && (route.root.tree.prefetchHints & _approutertypes.PrefetchHint.SubtreeHasPartialPrefetching) !== 0;
                     task.phase = routeHasPartialPrefetching ? 1 : 0;
                     heapResift(taskHeap, task);
                 } else if (task.phase === 1) {
@@ -433,7 +430,7 @@ function pingRoute(now, task) {
                 {
                     if (background(task)) {
                         routeWithoutSearch.status = _cache.EntryStatus.Pending;
-                        spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(routeWithoutSearch, keyWithoutSearch, task.segmentCacheMap));
+                        spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(routeWithoutSearch, keyWithoutSearch));
                     }
                     break;
                 }
@@ -472,7 +469,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.key, task.segmentCacheMap));
+                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
@@ -515,7 +512,7 @@ function pingRootRouteTree(now, task, route) {
                     // Stop prefetching segments until there's more bandwidth.
                     return 0;
                 }
-                const tree = route.tree;
+                const tree = route.root.tree;
                 // A task's fetch strategy gets set to `PPR` for any "auto" prefetch.
                 // 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
@@ -553,51 +550,64 @@ function pingRootRouteTree(now, task, route) {
                             // do another pass to perform a runtime prefetch.
                             // Derive the static walk's parameters once per pass; the walk
                             // functions below receive them as arguments and are phase-agnostic.
-                            // During the Shell phase the walk targets the App Shell variant of
-                            // each segment (keyed at the shell vary paths); otherwise it's the
-                            // ordinary per-segment static strategy. This is the only place the
-                            // phase is consulted — everything below keys off the strategy.
+                            // During the Shell phase the walk requests each segment's
+                            // shell-stage variant (keyed at the shell vary paths); otherwise
+                            // it's the ordinary per-segment static strategy. This is the only
+                            // place the phase is consulted — everything below keys off
+                            // the strategy.
                             const staticWalkStrategy = task.phase === 1 ? _types.FetchStrategy.StaticShell : _types.FetchStrategy.PPR;
-                            if (staticWalkStrategy === _types.FetchStrategy.PPR && !subtreeHasSpeculativePrefetch(task.fetchStrategy, tree.prefetchHints)) {
-                                // Nothing in the target route needs to be speculatively prefetched.
-                                // Bail out. (A PPR walk is the Speculative pass; same check as
-                                // the per-subtree bail in pingNewPartOfCacheComponentsTree.)
+                            // In PPF, links may skip speculative prefetching if they only need a shell.
+                            if (staticWalkStrategy === _types.FetchStrategy.PPR && !needsSpeculativePrefetch(task.fetchStrategy, route.root.tree.prefetchHints)) {
                                 return 2;
                             }
-                            pingStaticHead(now, task, route, staticWalkStrategy);
-                            const exitStatus = pingSharedPartOfCacheComponentsTree(now, task, route, task.treeAtTimeOfPrefetch, tree, null, staticWalkStrategy);
+                            // The head is a one-node tree beside the route tree (see
+                            // createMetadataRouteTree in cache.ts); it takes the same walk as
+                            // a segment the current page doesn't have. If the head was inlined
+                            // into a page's bundle (HeadOutlined is NOT set on the root), skip
+                            // the standalone walk — the head data will arrive as part of that
+                            // page's response, and its runtime-completeness signal is carried
+                            // by that page's own entries.
+                            const head = route.root.head;
+                            if (!process.env.__NEXT_PREFETCH_INLINING || (route.root.tree.prefetchHints & _approutertypes.PrefetchHint.HeadOutlined) !== 0 || // An inlined head that can't attempt a static fetch still deopts
+                            // to the runtime request (the first check of the decision point
+                            // in pingSegmentInCacheComponentsTree); only the static fetch
+                            // itself is skipped for an inlined head.
+                            walkCanUseRuntimeRequests(staticWalkStrategy, route) && !shouldSegmentAttemptStaticRequest(staticWalkStrategy, head)) {
+                                const headExitStatus = pingNewPartOfCacheComponentsTree(now, task, route, head, null, staticWalkStrategy);
+                                if (headExitStatus === 0) {
+                                    return 0;
+                                }
+                            }
+                            const exitStatus = pingSharedPartOfCacheComponentsTree(now, task, route, task.renderTreeAtTimeOfPrefetch.tree, tree, null, staticWalkStrategy);
                             if (exitStatus === 0) {
                                 // Child yielded without finishing.
                                 return 0;
                             }
-                            // We may need to do a runtime prefetch for one or more segments.
-                            // Before checking, we can do some fast checks to bail out of this
-                            // branch early.
-                            //
-                            // Runtime prefetches are only issued for walks that require runtime
-                            // completeness — the same per-pass predicate that produced the
-                            // deopt registrations during the traversal above; see the decision
-                            // point in pingNewPartOfCacheComponentsTree. Which segments
-                            // actually need a runtime request — registered directly, or only
-                            // as the fallback after an insufficient static attempt — was
-                            // decided there.
-                            if (walkRequiresRuntimeCompleteness(staticWalkStrategy, route)) {
+                            // `pingSegmentInCacheComponentsTree` may have determined that
+                            // we need to do a runtime prefetch for one or more segments.
+                            // Bail out early if runtime prefetches are not permitted for this route.
+                            if (walkCanUseRuntimeRequests(staticWalkStrategy, route)) {
                                 const runtimeStrategy = staticWalkStrategy === _types.FetchStrategy.StaticShell ? _types.FetchStrategy.RuntimeShell : _types.FetchStrategy.PPRRuntime;
                                 // spawnedRuntimePrefetches was populated during the traversal
                                 // above: every subtree in the new part of the tree that needs a
-                                // runtime prefetch — plus, during the Shell phase, the head, if
-                                // its static attempt was insufficient (see above).
+                                // runtime prefetch, the head included — it registers under its
+                                // own request key, like any segment, when its own static attempt
+                                // was insufficient or never happened.
                                 //
                                 // If it's null, nothing in the new part of the tree is a candidate
                                 // for runtime prefetching, and we don't fetch the head, either —
-                                // the head is runtime prefetched only if one of the segments is.
+                                // the head is runtime prefetched only if something is.
                                 const spawnedRuntimePrefetches = task.spawnedRuntimePrefetches;
                                 if (spawnedRuntimePrefetches !== null) {
                                     const spawnedEntries = new Map();
-                                    pingRuntimeHead(now, task, route, spawnedEntries, runtimeStrategy);
+                                    // The head has no position in the request tree — a runtime
+                                    // response carries it beside the segments (see
+                                    // writeServerResponseIntoCache in cache.ts) — so the head's
+                                    // own request tree is discarded.
+                                    pingRouteTreeAndIncludeDynamicData(now, task, route, head, false, spawnedEntries, runtimeStrategy);
                                     const requestTree = pingRuntimePrefetches(now, task, route, tree, spawnedRuntimePrefetches, spawnedEntries, runtimeStrategy);
                                     if (spawnedEntries.size > 0) {
-                                        spawnPrefetchSubtask((0, _cache.fetchSegmentPrefetchesUsingDynamicRequest)(task, route, runtimeStrategy, requestTree, spawnedEntries));
+                                        spawnPrefetchSubtask((0, _cache.fetchSegmentPrefetchesUsingRuntimeRequest)(task, route, runtimeStrategy, requestTree, spawnedEntries));
                                     }
                                 }
                             }
@@ -613,7 +623,7 @@ function pingRootRouteTree(now, task, route) {
                                 // and fall through to Speculative.
                                 return 2;
                             }
-                            // Prefetch multiple segments using a single dynamic request.
+                            // Prefetch multiple segments using a single runtime request.
                             // TODO: We can consolidate this branch with previous one by modeling
                             // it as if the first segment in the new tree has runtime prefetching
                             // enabled. Will do this as a follow-up refactor. Might want to remove
@@ -621,11 +631,18 @@ function pingRootRouteTree(now, task, route) {
                             // really that much duplication, just would be nice to remove one of
                             // these codepaths.
                             const spawnedEntries = new Map();
-                            pingRuntimeHead(now, task, route, spawnedEntries, fetchStrategy);
-                            const dynamicRequestTree = diffRouteTreeAgainstCurrent(now, task, route, task.treeAtTimeOfPrefetch, tree, spawnedEntries, fetchStrategy);
+                            // The head has no position in the request tree — a runtime response
+                            // carries it beside the segments (see writeServerResponseIntoCache
+                            // in cache.ts) — so the head's own request tree is discarded.
+                            const head = route.root.head;
+                            pingRouteTreeAndIncludeDynamicData(now, task, route, head, false, spawnedEntries, // When prefetching the head, there's no difference between Full
+                            // and LoadingBoundary: the head has no loading boundary, so a
+                            // LoadingBoundary request would skip it.
+                            fetchStrategy === _types.FetchStrategy.LoadingBoundary ? _types.FetchStrategy.Full : fetchStrategy);
+                            const dynamicRequestTree = diffRouteTreeAgainstCurrent(now, task, route, task.renderTreeAtTimeOfPrefetch.tree, tree, spawnedEntries, fetchStrategy);
                             let needsDynamicRequest = spawnedEntries.size > 0;
                             if (needsDynamicRequest) {
-                                spawnPrefetchSubtask((0, _cache.fetchSegmentPrefetchesUsingDynamicRequest)(task, route, fetchStrategy, dynamicRequestTree, spawnedEntries));
+                                spawnPrefetchSubtask((0, _cache.fetchSegmentPrefetchesUsingRuntimeRequest)(task, route, fetchStrategy, dynamicRequestTree, spawnedEntries));
                             }
                             return 2;
                         }
@@ -642,99 +659,53 @@ function pingRootRouteTree(now, task, route) {
     return 2;
 }
 /**
- * Prefetches the Head data for a page (metadata, viewport). The Head 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.
+ * Whether the task can use runtime requests to prefetch the content.
  *
- * Symmetric with the per-segment decision point in
- * pingNewPartOfCacheComponentsTree: the head deopts to the runtime prefetch
- * path either when it requires runtime completeness and no static attempt is
- * happening, or when a fulfilled static head entry reported that a runtime
- * request would return more content than the entry contains. Deopting
- * registers the head under its metadata request key, which makes the runtime
- * gate in pingRootRouteTree fire even when every tree segment was
- * sufficient; pingRuntimeHead performs the actual head work.
- */ function pingStaticHead(now, task, route, // The per-pass static walk strategy; see pingRootRouteTree where
-// it's derived.
-fetchStrategy) {
-    // The head is subject to the same per-pass runtime-completeness contract
-    // as the route's segments: during an App Shell walk, and during any walk
-    // of a Partial Prefetching route, the head needs a response at least as
-    // complete as a runtime one.
-    const headRequiresRuntimeCompleteness = walkRequiresRuntimeCompleteness(fetchStrategy, route);
-    if (headRequiresRuntimeCompleteness && // The head is not a tree node — it hangs off the route root — so the
-    // static-attempt hint is read from the root's node. (Segments read the
-    // bit from their own node; see the decision point in
-    // pingNewPartOfCacheComponentsTree.)
-    (route.tree.prefetchHints & _approutertypes.PrefetchHint.ShouldAttemptStaticPrefetch) === 0) {
-        // No static attempt: the head arrives via the runtime request instead.
-        addSpawnedRuntimePrefetch(task, route.metadata.requestKey);
-        return;
-    }
-    if (// If the head was inlined into a page's bundle (HeadOutlined is NOT set
-    // on the root), skip the standalone fetch — the head data will arrive
-    // as part of that page's response, and its runtime-completeness signal
-    // is carried by that page's own entries.
-    process.env.__NEXT_PREFETCH_INLINING && !(route.tree.prefetchHints & _approutertypes.PrefetchHint.HeadOutlined)) {
-        return;
-    }
-    const segments = {
-        tree: route.metadata,
-        entry: (0, _cache.readOrCreateSegmentCacheEntry)(now, task.segmentCacheMap, fetchStrategy, route.metadata),
-        parent: null
-    };
-    const needsRuntimeRequest = pingSegmentBundle(now, task, route, task.key, route.metadata, segments, fetchStrategy, true);
-    if (headRequiresRuntimeCompleteness && needsRuntimeRequest) {
-        // The static attempt was insufficient for the head. Deopt to a
-        // runtime prefetch. (Outside of runtime-completeness contexts the
-        // head's signal is unused — a partial static head is filled in by the
-        // navigation-time request, as with any other static segment.)
-        addSpawnedRuntimePrefetch(task, route.metadata.requestKey);
+ * This is true for every walk of a route that opts into Partial Prefetching
+ * (any segment with a partial-prefetching config, or the global `partialPrefetching`
+ * flag, indicated by `SubtreeHasPartialPrefetching` on the route root),
+ * in both the Shell and Speculative phases.
+ *
+ * Note that this does not mean that the route *will* use runtime requests --
+ * it might be optimized statically, either because it does not use runtime data
+ * in the shell/prefetch, or if it's forced to use static requests by
+ * `export const ensureStatic = "shell" | "prefetch" | "navigation"`.
+ *
+ * Routes without Partial Prefetching never use runtime requests for prefetches
+ * (excluding `Full` prefetches)
+ */ function walkCanUseRuntimeRequests(staticWalkStrategy, route) {
+    if (staticWalkStrategy === _types.FetchStrategy.StaticShell) {
+        // `FetchStrategy.StaticShell` is only used on PPF routes.
+        return true;
     }
+    // `FetchStrategy.PPR` can only use runtime requests if PPF is enabled on the route.
+    return (route.root.tree.prefetchHints & _approutertypes.PrefetchHint.SubtreeHasPartialPrefetching) !== 0;
 }
 /**
- * Whether the task needs a cache entry at least as complete as a runtime
- * response for every segment it walks before the prefetch counts as done.
- * Runtime completeness is the universal contract for Partial Prefetching,
- * so the predicate is per pass, not per segment:
- *
- * - Every walk of a route that opts into Partial Prefetching (any segment
- *   with a partial-prefetching config, or the global `partialPrefetching`
- *   flag — both surfaced as SubtreeHasPartialPrefetching on the route
- *   root), in both the Shell and Speculative phases.
- * - Every App Shell (StaticShell) walk, because the App Shell must be
- *   reusable across all params by definition. (In practice this is implied
- *   by the first case — the Shell phase only runs for Partial Prefetching
- *   routes.)
- *
- * Routes without Partial Prefetching keep the static-only contract: their
- * walks prefetch static data and partial entries are acceptable — the
- * dynamic holes are filled by the navigation-time request.
- *
- * Note that on a Partial Prefetching route, non-eager subtrees are still
- * skipped by the Speculative pass of a default (auto) link — eagerness is
- * unaffected by this predicate. But every segment the pass DOES walk (eager
- * segments, and everything on a `prefetch={true}` walk) is held to the
- * runtime-completeness contract. The contract is affordable because most
- * routes carry the ShouldAttemptStaticPrefetch hint: their segments are
- * prefetched statically and the responses' own sufficiency signal makes a
- * runtime request rare. On a hint-unset route, a walked segment deopts
- * directly to the batched runtime request — which then serves the segment's
- * whole subtree, so navigations into it are complete without a
- * navigation-time request.
+ * Whether a static request for this segment should be attempted.
+ * This may vary on the static walk's strategy, because we might e.g.
+ * have a shell that's static, but a prefetch that requires runtime requests.
  *
- * This is also the gate for the batched runtime request at the end of
- * pingRootRouteTree; requiring runtime completeness does not itself mean a
- * runtime request is issued for a given segment — see the decision point in
- * pingNewPartOfCacheComponentsTree.
- */ function walkRequiresRuntimeCompleteness(staticWalkStrategy, route) {
-    return staticWalkStrategy === _types.FetchStrategy.StaticShell || (route.tree.prefetchHints & _approutertypes.PrefetchHint.SubtreeHasPartialPrefetching) !== 0;
+ * NOTE: Should only be used on Partial Prefetching routes, where
+ * `walkCanUseRuntimeRequests` is true.
+ * */ function shouldSegmentAttemptStaticRequest(staticWalkStrategy, tree) {
+    const { prefetchHints } = tree;
+    switch(staticWalkStrategy){
+        case _types.FetchStrategy.StaticShell:
+            return (prefetchHints & _approutertypes.PrefetchHint.ShouldAttemptStaticShell) !== 0;
+        case _types.FetchStrategy.PPR:
+            return (prefetchHints & _approutertypes.PrefetchHint.ShouldAttemptStaticPrefetch) !== 0;
+        default:
+            staticWalkStrategy;
+            return false;
+    }
 }
 /**
  * The runtime counterpart of a pass's static walk strategy: the strategy the
  * batched runtime request uses if this walk deopts. Each phase has exactly one
- * — the Shell phase escalates to a runtime App Shell, the Speculative phase to
- * a per-link concrete runtime prefetch.
+ * — the Shell phase escalates to a shell-scoped runtime request
+ * (RuntimeShell), the Speculative phase to a per-link concrete
+ * runtime prefetch.
  */ function getRuntimeStrategyForWalk(staticWalkStrategy) {
     return staticWalkStrategy === _types.FetchStrategy.StaticShell ? _types.FetchStrategy.RuntimeShell : _types.FetchStrategy.PPRRuntime;
 }
@@ -752,8 +723,36 @@ fetchStrategy) {
     return (0, _cache.canNewFetchStrategyProvideMoreContent)(entry.fetchStrategy, getRuntimeStrategyForWalk(staticWalkStrategy));
 }
 /**
- * Register a subtree root (or the head's metadata key) for the batched
- * runtime request issued by the gate at the end of pingRootRouteTree.
+ * Whether a fulfilled shell-tier entry should take a static attempt (a
+ * spawned revalidation at the walk's static tier) before its position deopts
+ * to a runtime request. A shell-tier recorded entry (StaticShell or
+ * RuntimeShell) is not evidence that a static attempt would be pointless —
+ * unlike a concrete static (PPR) entry, where a static re-fetch would return
+ * the same bytes — so when the segment's hint says a static attempt is
+ * worthwhile (the build-time prerender accessed no runtime data), the
+ * attempt is taken and its response's own verdict decides whether to
+ * escalate afterward.
+ *
+ * Consults the revalidation slot so an attempt that already ran and settled
+ * without healing the entry (a rejected attempt: server miss or network
+ * error; a successful one upserts over the shell-tier entry, so the caller
+ * reads the healed entry instead) doesn't suppress the runtime deopt
+ * forever. The slot read creates an Empty placeholder on first evaluation —
+ * there is no read-only variant — which is harmless: when the entry is
+ * eligible, the spawn that follows claims the same slot.
+ */ function isShellEntryEligibleForStaticAttempt(now, map, entry, tree, fetchStrategy) {
+    if (!((entry.fetchStrategy === _types.FetchStrategy.StaticShell || entry.fetchStrategy === _types.FetchStrategy.RuntimeShell) && shouldSegmentAttemptStaticRequest(fetchStrategy, tree) && // if the `fetchStrategy` is `FetchStrategy.PPR`, it might provide more content
+    // (e.g. static params that this shell doesn't have)
+    (0, _cache.canNewFetchStrategyProvideMoreContent)(entry.fetchStrategy, fetchStrategy))) {
+        return false;
+    }
+    const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, map, fetchStrategy, tree);
+    return revalidatingEntry.status === _cache.EntryStatus.Empty || revalidatingEntry.status === _cache.EntryStatus.Pending;
+}
+/**
+ * Register a subtree root (the head is one, under its own request key) for
+ * the batched runtime request issued by the gate at the end of
+ * pingRootRouteTree.
  */ function addSpawnedRuntimePrefetch(task, requestKey) {
     if (task.spawnedRuntimePrefetches === null) {
         task.spawnedRuntimePrefetches = new Set([
@@ -763,70 +762,81 @@ fetchStrategy) {
         task.spawnedRuntimePrefetches.add(requestKey);
     }
 }
-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
-    // and LoadingBoundary
-    fetchStrategy === _types.FetchStrategy.LoadingBoundary ? _types.FetchStrategy.Full : fetchStrategy);
-}
 // TODO: Rename dynamic -> runtime throughout this module
-function pingSharedPartOfCacheComponentsTree(now, task, route, oldTree, newTree, parentBundle, // The per-pass static walk strategy; see pingRootRouteTree where
+/**
+ * The static walk over the part of the target route that also exists on the
+ * current page: the current page's node and the target route's node at the
+ * same position in the tree. It mirrors the navigation's traversal order (see
+ * updateRenderTreeOnNavigation in render-tree.ts): first whether the route
+ * position still matches — if not, this node begins the new part of the route
+ * (pingNewPartOfCacheComponentsTree) — and then whether any of the node's
+ * param values changed — if so, the node and everything below it begin the
+ * new part of the route too. The walk does not consult which params a
+ * segment read, so it prefetches more than the navigation replaces: the
+ * navigation keeps data whose read params did not change and decides each
+ * descendant on its own. A node the walk keeps is prefetched at the ordinary
+ * static tier.
+ * Its children continue here wherever the current page has a child in the
+ * same slot; a child in a slot the current page doesn't have enters the new
+ * part of the route directly.
+ *
+ * Bundle chains must not cross the strategy boundary: a kept node walks at
+ * PPR while a Shell-phase new part walks at StaticShell, and a chain spanning
+ * both would fulfill the kept node's concrete-path entry with shell-variant
+ * data. Nor may the chain be finished by fetching the new-part node at PPR
+ * — that would prefetch new-part segments at the concrete tier during the
+ * Shell phase, which only the Speculative phase is allowed to do. So the
+ * chain is dropped wherever the walk hands off to the new part during a
+ * StaticShell walk, exactly like the drop sites in
+ * pingSegmentInCacheComponentsTree: nothing in a dropped chain was upgraded
+ * to Pending, so no entry is stranded, and the inlined kept data is fetched
+ * by the Speculative pass whenever its walk of the new part permits the
+ * child fetch.
+ */ function pingSharedPartOfCacheComponentsTree(now, task, route, currentTree, newTree, parentBundle, // The per-pass static walk strategy; see pingRootRouteTree where
 // it's derived.
 fetchStrategy) {
-    // When Cache Components is enabled (or PPR, or a fully static route when PPR
-    // is disabled; those cases are treated equivalently to Cache Components), we
-    // start by prefetching each segment individually. Once we reach the "new"
-    // part of the tree — the part that doesn't exist on the current page — we
-    // may choose to switch to a runtime prefetch instead, based on the
-    // information sent by the server in the route tree.
-    //
-    // The traversal starts in the "shared" part of the tree. Once we reach the
-    // "new" part of the tree, we switch to a different traversal,
-    // pingNewPartOfCacheComponentsTree.
-    // The shared part of the tree always performs the ordinary static (PPR)
-    // prefetch, regardless of phase. Phase-specific strategies — the runtime
-    // shell request and the Shell phase's StaticShell walk — apply only to the
-    // new part of the tree, so the per-pass walk strategy is irrelevant here.
-    // (The needs-runtime signal is ignored: shared segments are already
-    // rendered on the current page, so a runtime prefetch has nothing to add.)
+    if (!(0, _cache.doesRouteStructureMatch)(currentTree, newTree)) {
+        // We're entering the part of the target route that doesn't exist on the
+        // current page.
+        return pingNewPartOfCacheComponentsTree(now, task, route, newTree, fetchStrategy === _types.FetchStrategy.StaticShell ? null : parentBundle, fetchStrategy);
+    }
+    if ((0, _varypath.compareParams)(currentTree.varyPath, newTree.varyPath) !== _varypath.ParamsChange.None) {
+        // A param changed. The navigation replaces only the data that read it and
+        // decides each descendant on its own (see updateRenderTreeOnNavigation in
+        // render-tree.ts); this walk doesn't know what each segment read, so it
+        // prefetches the whole subtree.
+        return pingNewPartOfCacheComponentsTree(now, task, route, newTree, fetchStrategy === _types.FetchStrategy.StaticShell ? null : parentBundle, fetchStrategy);
+    }
+    // The navigation keeps this segment's current data. A kept segment always
+    // performs the ordinary static (PPR) prefetch, regardless of phase.
+    // Phase-specific strategies — the runtime shell request and the Shell
+    // phase's StaticShell walk — apply only to the new part of the tree, so the
+    // per-pass walk strategy is irrelevant here. (The needs-runtime signal is
+    // ignored: kept segments are already rendered on the current page, so a
+    // runtime prefetch has nothing to add.)
     const bundleInProgress = accumulateSegmentBundle(now, task, route, newTree, parentBundle, _types.FetchStrategy.PPR, true).bundle;
-    // Recursively ping the children.
-    const oldTreeChildren = oldTree[1];
+    // Recursively ping the children, continuing in lockstep with the current
+    // page wherever it has a child in the same slot.
     const newTreeChildren = newTree.slots;
     if (newTreeChildren !== null) {
+        const currentSlots = currentTree.slots;
         for (const [parallelRouteKey, newTreeChild] of newTreeChildren){
             if (!hasNetworkBandwidth(task)) {
                 // Stop prefetching segments until there's more bandwidth.
                 return 0;
             }
-            const newTreeChildSegment = newTreeChild.segment;
-            const oldTreeChild = oldTreeChildren[parallelRouteKey];
-            const oldTreeChildSegment = oldTreeChild?.[0];
             // Only pass the bundle to the child that accepts it. A parent is
             // only ever bundled into one child.
             const bundleForChild = process.env.__NEXT_PREFETCH_INLINING && bundleInProgress !== null && newTreeChild.prefetchHints & _approutertypes.PrefetchHint.ParentInlinedIntoSelf ? bundleInProgress : null;
+            let currentTreeChild = undefined;
+            if (currentSlots !== null) {
+                currentTreeChild = currentSlots.get(parallelRouteKey);
+            }
             let childExitStatus;
-            if (oldTreeChildSegment !== undefined && doesCurrentSegmentMatchCachedSegment(route, newTreeChildSegment, oldTreeChildSegment)) {
-                // We're still in the "shared" part of the tree.
-                childExitStatus = pingSharedPartOfCacheComponentsTree(now, task, route, oldTreeChild, newTreeChild, bundleForChild, fetchStrategy);
+            if (currentTreeChild !== undefined) {
+                childExitStatus = pingSharedPartOfCacheComponentsTree(now, task, route, currentTreeChild, newTreeChild, bundleForChild, fetchStrategy);
             } else {
-                // We've entered the "new" part of the tree. Switch
-                // traversal functions.
-                //
-                // Bundle chains must not cross the strategy boundary: the shared
-                // part walks at PPR while a Shell-phase new part walks at
-                // StaticShell, and a chain spanning both would fulfill the shared
-                // parent's concrete-path entry with shell-variant data. Nor may we
-                // finish the chain by fetching the new-part child at PPR here —
-                // that would prefetch new-part segments at the concrete tier
-                // during the Shell phase, which only the Speculative phase is
-                // allowed to do. So drop the bundle instead, exactly like the
-                // Speculative walk's subtree bail does when a chain crosses into a
-                // subtree it skips: nothing in a dropped chain was upgraded to
-                // Pending, so no entry is stranded, and the inlined shared data is
-                // fetched by the Speculative pass whenever its walk of the new
-                // part permits the child fetch.
-                const bundleForNewPart = fetchStrategy === _types.FetchStrategy.StaticShell ? null : bundleForChild;
-                childExitStatus = pingNewPartOfCacheComponentsTree(now, task, route, newTreeChild, bundleForNewPart, fetchStrategy);
+                childExitStatus = pingNewPartOfCacheComponentsTree(now, task, route, newTreeChild, fetchStrategy === _types.FetchStrategy.StaticShell ? null : bundleForChild, fetchStrategy);
             }
             if (childExitStatus === 0) {
                 // Child yielded without finishing.
@@ -834,62 +844,94 @@ fetchStrategy) {
             }
         }
     }
+    // The static attempt was sufficient for this segment (each child is its
+    // own decision point) — or parts of it are still in flight, in which case
+    // the task is blocked and the decision re-runs against the received
+    // responses.
     return 2;
 }
-function pingNewPartOfCacheComponentsTree(now, task, route, tree, parentBundle, // The per-pass static walk strategy; see pingRootRouteTree where
+/**
+ * The static walk over the part of the target route that doesn't exist on
+ * the current page. Nothing here is compared against the current tree: every
+ * segment goes through the per-segment decision point.
+ */ function pingNewPartOfCacheComponentsTree(now, task, route, tree, parentBundle, // The per-pass static walk strategy; see pingRootRouteTree where
 // it's derived.
 fetchStrategy) {
-    // We're now prefetching in the "new" part of the tree, the part that
-    // doesn't exist on the current page. (In other words, we're deeper than
-    // the shared layouts.) Segments in here default to being prefetched
-    // statically, at the per-pass strategy derived in pingRootRouteTree.
-    //
-    // When the walk requires runtime completeness — an entry at least as
-    // complete as a runtime response for every segment before the prefetch
-    // can complete (see walkRequiresRuntimeCompleteness) — this function is
-    // also the per-segment decision point. If the segment's node carries the
-    // ShouldAttemptStaticPrefetch hint (the build-time prerender accessed no
-    // runtime data), its subtree is prefetched statically first,
-    // and the responses themselves decide whether that was enough: every
-    // fulfilled entry carries a needsRuntimeRequest signal. Pending responses
-    // block the task, so the attempt is serial, never raced: static attempt →
-    // observe → runtime only if needed. Without the hint, the segment deopts
-    // directly. Deopting registers the segment's request key in
-    // spawnedRuntimePrefetches; the runtime gate at the end of
-    // pingRootRouteTree issues a single batched runtime request for
-    // everything that accumulated, and that request re-fetches the whole
-    // subtree, so the walk stops descending at a deopt.
-    //
-    // Outside a runtime-completeness walk the same needsRuntimeRequest signal
-    // is routine and ignored — any partial entry of a page that accesses
-    // runtime data carries it, and the dynamic holes are filled by the
-    // navigation-time request.
-    if (// Only the Speculative pass skips subtrees with nothing to speculatively
-    // prefetch. (It's also the only pass that walks at FetchStrategy.PPR;
-    // the Shell phase walks at StaticShell and covers the whole new tree.)
-    fetchStrategy === _types.FetchStrategy.PPR && !subtreeHasSpeculativePrefetch(task.fetchStrategy, tree.prefetchHints)) {
-        // Nothing in the new part of the tree needs to be speculatively prefetched.
-        // Bail out.
+    const accumulation = pingSegmentInCacheComponentsTree(now, task, route, tree, parentBundle, fetchStrategy);
+    if (accumulation === null) {
         return 2;
     }
+    const bundleInProgress = accumulation.bundle;
+    // Recursively ping the children.
+    const treeChildren = tree.slots;
+    if (treeChildren !== null) {
+        for (const treeChild of treeChildren.values()){
+            if (!hasNetworkBandwidth(task)) {
+                // Stop prefetching segments until there's more bandwidth.
+                return 0;
+            }
+            // Only pass the bundle to the child that accepts it. A parent is
+            // only ever bundled into one child.
+            const bundleForChild = process.env.__NEXT_PREFETCH_INLINING && bundleInProgress !== null && treeChild.prefetchHints & _approutertypes.PrefetchHint.ParentInlinedIntoSelf ? bundleInProgress : null;
+            const childExitStatus = pingNewPartOfCacheComponentsTree(now, task, route, treeChild, bundleForChild, fetchStrategy);
+            if (childExitStatus === 0) {
+                // Child yielded without finishing.
+                return 0;
+            }
+        }
+    }
+    // The static attempt was sufficient for this segment (each child is its
+    // own decision point) — or parts of it are still in flight, in which case
+    // the task is blocked and the decision re-runs against the received
+    // responses.
+    return 2;
+}
+/**
+ * The per-segment decision point of the static walk: the one place that
+ * decides how a segment in the new part of the route — one the navigation
+ * won't keep — is prefetched (pingNewPartOfCacheComponentsTree).
+ *
+ * When Cache Components is enabled (or PPR, or a fully static route when PPR
+ * is disabled; those cases are treated equivalently to Cache Components), we
+ * prefetch each segment individually, statically, at the per-pass strategy
+ * derived in pingRootRouteTree.
+ *
+ * This is where we decide whether we should use runtime requests, if the walk
+ * is allowed to do so (see `walkCanUseRuntimeRequests`).
+ *
+ * If runtime requests are allowed, but the segment's node has one of the
+ * `ShouldAttemptStatic{Shell,Prefetch}` hints set (either because the build-time
+ * prerender accessed no runtime data, or because of `ensureStatic`), then its
+ * subtree should be prefetched statically first.
+ * However, the hint may be stale after a revalidation, so we'll also check the
+ * `needsRuntimeRequest` promise on the static response, and will follow up with
+ * a runtime request if needed.
+ * Pending responses block the task, so the attempt is serial, never raced:
+ * static attempt → observe → runtime (if needed).
+ *
+ * The static hints and `needsRuntimeRequest` have no effect if runtime requests
+ * are not allowed (i.e. outside of Partial Prefetching).
+ *
+ * Returns the segment's bundle accumulation when the walk should continue
+ * into its children, and null when the walk stops at this segment: the link
+ * needs no speculative prefetch, or the segment deopted and the batched
+ * runtime request covers the whole subtree.
+ */ function pingSegmentInCacheComponentsTree(now, task, route, tree, parentBundle, // The per-pass static walk strategy; see pingRootRouteTree where
+// it's derived.
+fetchStrategy) {
+    // In PPF, links may skip speculative prefetching if they only need a shell.
+    if (fetchStrategy === _types.FetchStrategy.PPR && !needsSpeculativePrefetch(task.fetchStrategy, route.root.tree.prefetchHints)) {
+        return null;
+    }
     // Constant for the whole pass; recomputed here only because the walk is
     // recursive and the check is cheap.
-    const segmentRequiresRuntimeCompleteness = walkRequiresRuntimeCompleteness(fetchStrategy, route);
-    // TODO: The static-attempt hint reflects the build-time prerender's whole
-    // runtime-data tracking, so a page that always accesses
-    // runtime data after the shell stage never attempts a static prefetch —
-    // even though its shell variant is rewindable at the shell boundary and
-    // perfectly reusable. The server could emit a second bit derived from the
-    // shell-stage value ("a static SHELL attempt is worthwhile even though
-    // the page accesses runtime data post-shell") to let such pages attempt
-    // static, too.
+    const canUseRuntimeRequests = walkCanUseRuntimeRequests(fetchStrategy, route);
     // A force-disabled segment deliberately does NOT deopt here: disabling
     // prefetch is passive. It never initiates a request — its accumulation
     // below contributes nothing — and must never be the reason a runtime
     // prefetch spawns, though it may ride along in a runtime response issued
     // on another segment's behalf.
-    const attemptStaticPrefetchOfSegment = (tree.prefetchHints & _approutertypes.PrefetchHint.ShouldAttemptStaticPrefetch) !== 0;
-    if (segmentRequiresRuntimeCompleteness && !attemptStaticPrefetchOfSegment) {
+    if (canUseRuntimeRequests && !shouldSegmentAttemptStaticRequest(fetchStrategy, tree)) {
         // Deopt directly to a runtime prefetch, without a static attempt.
         addSpawnedRuntimePrefetch(task, tree.requestKey);
         // If there's a pending static bundle from a parent, we need to finish
@@ -897,13 +939,12 @@ fetchStrategy) {
         if (parentBundle !== null) {
             finishStaticBundleOnRuntimeBailout(now, task, route, tree, parentBundle, fetchStrategy);
         }
-        return 2;
+        return null;
     }
     // Prefetch this segment and its subtree statically, using the normal
     // static bundling walk.
     const accumulation = accumulateSegmentBundle(now, task, route, tree, parentBundle, fetchStrategy, true);
-    const bundleInProgress = accumulation.bundle;
-    if (segmentRequiresRuntimeCompleteness && accumulation.needsRuntimeRequest) {
+    if (canUseRuntimeRequests && accumulation.needsRuntimeRequest) {
         // The static attempt for this segment was insufficient. Stop the walk
         // and deopt — the runtime prefetch covers the whole subtree. (Unlike the
         // direct deopt above, any open bundle is dropped rather than finished: a
@@ -912,112 +953,28 @@ fetchStrategy) {
         // upgraded to Pending, so no entry is stranded blocking the task, and
         // Empty entries in the dropped chain are re-fetched by a later pass.)
         addSpawnedRuntimePrefetch(task, tree.requestKey);
-        return 2;
-    }
-    if (tree.slots !== null) {
-        if (!hasNetworkBandwidth(task)) {
-            // Stop prefetching segments until there's more bandwidth.
-            return 0;
-        }
-        // Recursively ping the children.
-        for (const childTree of tree.slots.values()){
-            // Only pass the bundle to the child that accepts it. A parent is
-            // only ever bundled into one child.
-            const bundleForChild = process.env.__NEXT_PREFETCH_INLINING && bundleInProgress !== null && childTree.prefetchHints & _approutertypes.PrefetchHint.ParentInlinedIntoSelf ? bundleInProgress : null;
-            const childResult = pingNewPartOfCacheComponentsTree(now, task, route, childTree, bundleForChild, fetchStrategy);
-            if (childResult === 0) {
-                // Child yielded without finishing.
-                return 0;
-            }
-        }
+        return null;
     }
-    // The static attempt was sufficient for this segment (each child is its
-    // own decision point) — or parts of it are still in flight, in which case
-    // the task is blocked and the decision re-runs against the received
-    // responses.
-    return 2;
+    return accumulation;
 }
 function diffRouteTreeAgainstCurrent(now, task, route, oldTree, newTree, spawnedEntries, fetchStrategy) {
     // This is a single recursive traversal that does multiple things:
-    // - Finds the parts of the target route (newTree) that are not part of
-    //   of the current page (oldTree) by diffing them, using the same algorithm
-    //   as a real navigation.
+    // - Finds the segments that differ from the current route, comparing each
+    //   segment the same way the navigation will (see
+    //   updateRenderTreeOnNavigation in render-tree.ts): its route position,
+    //   then whether any of its param values changed.
     // - Constructs a request tree (FlightRouterState) that describes which
     //   segments need to be prefetched and which ones are already cached.
     // - Creates a set of pending cache entries for the segments that need to
     //   be prefetched, so that a subsequent prefetch task does not request the
     //   same segments again.
-    const oldTreeChildren = oldTree[1];
+    const oldSlots = oldTree.slots;
     const newTreeChildren = newTree.slots;
     let requestTreeChildren = {};
     if (newTreeChildren !== null) {
         for (const [parallelRouteKey, newTreeChild] of newTreeChildren){
-            const newTreeChildSegment = newTreeChild.segment;
-            const oldTreeChild = oldTreeChildren[parallelRouteKey];
-            const oldTreeChildSegment = oldTreeChild?.[0];
-            if (oldTreeChildSegment !== undefined && doesCurrentSegmentMatchCachedSegment(route, newTreeChildSegment, oldTreeChildSegment)) {
-                // This segment is already part of the current route. Keep traversing.
-                const requestTreeChild = diffRouteTreeAgainstCurrent(now, task, route, oldTreeChild, newTreeChild, spawnedEntries, fetchStrategy);
-                requestTreeChildren[parallelRouteKey] = requestTreeChild;
-            } else {
-                // This segment is not part of the current route. We're entering a
-                // part of the tree that we need to prefetch (unless everything is
-                // already cached).
-                switch(fetchStrategy){
-                    case _types.FetchStrategy.LoadingBoundary:
-                        {
-                            // When PPR is disabled, we can't prefetch per segment. We must
-                            // fallback to the old prefetch behavior and send a dynamic request.
-                            // Only routes that include a loading boundary can be prefetched in
-                            // this way.
-                            //
-                            // This is simlar to a "full" prefetch, but we're much more
-                            // conservative about which segments to include in the request.
-                            //
-                            // The server will only render up to the first loading boundary
-                            // 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.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;
-                        }
-                    case _types.FetchStrategy.PPRRuntime:
-                        {
-                            // This is a runtime prefetch. Fetch all cacheable data in the tree,
-                            // not just the static PPR shell.
-                            const requestTreeChild = pingRouteTreeAndIncludeDynamicData(now, task, route, newTreeChild, false, spawnedEntries, fetchStrategy);
-                            requestTreeChildren[parallelRouteKey] = requestTreeChild;
-                            break;
-                        }
-                    case _types.FetchStrategy.Full:
-                        {
-                            // This is a "full" prefetch. Fetch all the data in the tree, both
-                            // static and dynamic. We issue roughly the same request that we
-                            // would during a real navigation. The goal is that once the
-                            // navigation occurs, the router should not have to fetch any
-                            // additional data.
-                            //
-                            // Although the response will include dynamic data, opting into a
-                            // Full prefetch — via <Link prefetch={true}> — implicitly
-                            // instructs the cache to treat the response as "static", or non-
-                            // dynamic, since the whole point is to cache it for
-                            // future navigations.
-                            //
-                            // Construct a tree (currently a FlightRouterState) that represents
-                            // which segments need to be prefetched and which ones are already
-                            // cached. If the tree is empty, then we can exit. Otherwise, we'll
-                            // send the request tree to the server and use the response to
-                            // populate the segment cache.
-                            const requestTreeChild = pingRouteTreeAndIncludeDynamicData(now, task, route, newTreeChild, false, spawnedEntries, fetchStrategy);
-                            requestTreeChildren[parallelRouteKey] = requestTreeChild;
-                            break;
-                        }
-                    default:
-                        fetchStrategy;
-                }
-            }
+            const oldTreeChild = oldSlots?.get(parallelRouteKey);
+            requestTreeChildren[parallelRouteKey] = diffSegmentAgainstCurrent(now, task, route, oldTreeChild, newTreeChild, spawnedEntries, fetchStrategy);
         }
     }
     const requestTree = [
@@ -1031,6 +988,77 @@ function diffRouteTreeAgainstCurrent(now, task, route, oldTree, newTree, spawned
     }
     return requestTree;
 }
+/**
+ * The per-segment decision of a runtime request's tree walk
+ * (diffRouteTreeAgainstCurrent): the segment at this position of the target
+ * route, and the current page's segment at the same position, if it has one.
+ * A segment the navigation keeps — same route position, and none of its param
+ * values changed — is omitted from the request and the walk continues into
+ * its children. Otherwise this segment begins a part of the tree that needs
+ * to be prefetched (unless everything is already cached), requested according
+ * to the strategy.
+ */ function diffSegmentAgainstCurrent(now, task, route, oldTree, newTree, spawnedEntries, fetchStrategy) {
+    if (oldTree !== undefined && (0, _cache.doesRouteStructureMatch)(oldTree, newTree)) {
+        // This segment is already part of the current route.
+        if ((0, _varypath.compareParams)(oldTree.varyPath, newTree.varyPath) === _varypath.ParamsChange.None) {
+            // The navigation keeps its data. Keep traversing.
+            return diffRouteTreeAgainstCurrent(now, task, route, oldTree, newTree, spawnedEntries, fetchStrategy);
+        }
+    }
+    // This segment is not part of the current route, or the navigation
+    // replaces its data. We're entering a part of the tree that we need to
+    // prefetch (unless everything is already cached).
+    switch(fetchStrategy){
+        case _types.FetchStrategy.LoadingBoundary:
+            {
+                // When PPR is disabled, we can't prefetch per segment. We must
+                // fallback to the old prefetch behavior and send a runtime request.
+                // Only routes that include a loading boundary can be prefetched in
+                // this way.
+                //
+                // This is simlar to a "full" prefetch, but we're much more
+                // conservative about which segments to include in the request.
+                //
+                // The server will only render up to the first loading boundary
+                // 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 = (newTree.prefetchHints & (_approutertypes.PrefetchHint.SegmentHasLoadingBoundary | _approutertypes.PrefetchHint.SubtreeHasLoadingBoundary)) !== 0;
+                if (subtreeHasLoadingBoundary) {
+                    return pingPPRDisabledRouteTreeUpToLoadingBoundary(now, task, route, newTree, null, spawnedEntries);
+                }
+                // There's no loading boundary within this tree. Bail out.
+                return (0, _cache.convertRouteTreeToFlightRouterState)(newTree);
+            }
+        case _types.FetchStrategy.PPRRuntime:
+            {
+                // This is a runtime prefetch. Fetch all cacheable data in the tree,
+                // not just the static PPR shell.
+                return pingRouteTreeAndIncludeDynamicData(now, task, route, newTree, false, spawnedEntries, fetchStrategy);
+            }
+        case _types.FetchStrategy.Full:
+            {
+                // This is a "full" prefetch. Fetch all the data in the tree, both
+                // static and dynamic. We issue roughly the same request that we
+                // would during a real navigation. The goal is that once the
+                // navigation occurs, the router should not have to fetch any
+                // additional data.
+                //
+                // Although the response will include dynamic data, opting into a
+                // Full prefetch — via <Link prefetch={true}> — implicitly
+                // instructs the cache to treat the response as "static", or non-
+                // dynamic, since the whole point is to cache it for
+                // future navigations.
+                //
+                // Construct a tree (currently a FlightRouterState) that represents
+                // which segments need to be prefetched and which ones are already
+                // cached. If the tree is empty, then we can exit. Otherwise, we'll
+                // send the request tree to the server and use the response to
+                // populate the segment cache.
+                return pingRouteTreeAndIncludeDynamicData(now, task, route, newTree, false, spawnedEntries, fetchStrategy);
+            }
+    }
+}
 function pingPPRDisabledRouteTreeUpToLoadingBoundary(now, task, route, tree, refetchMarkerContext, spawnedEntries) {
     // This function is similar to pingRouteTreeAndIncludeDynamicData, except the
     // server is only going to return a minimal loading state — it will stop
@@ -1299,9 +1327,11 @@ function pingRuntimePrefetches(now, task, route, tree, spawnedRuntimePrefetches,
  * request would return more content than the entry contains
  * (needsRuntimeRequest, derived at write time from the response that
  * produced the entry). The callers surface this signal to the per-segment
- * decision point in pingNewPartOfCacheComponentsTree (and its analog for
- * the head in pingStaticHead), which uses it during a static attempt to
- * decide whether to fall back to a runtime prefetch.
+ * decision point in pingSegmentInCacheComponentsTree, which uses it during
+ * a static attempt to decide whether to fall back to a runtime prefetch. One
+ * exception withholds the signal: a shell-tier entry whose segment carries
+ * the static-attempt hint spawns a concrete static attempt first — see the
+ * Fulfilled case.
  */ function pingSegmentBundle(now, task, route, routeKey, tree, segments, // Per-pass static walk strategy; see pingRootRouteTree where it's derived.
 fetchStrategy, // False when finishing an open bundle chain on a runtime-prefetch bailout
 // (finishStaticBundleOnRuntimeBailout). The finish exists only to fetch
@@ -1310,15 +1340,17 @@ fetchStrategy, // False when finishing an open bundle chain on a runtime-prefetc
 // already settled or in flight: the chain's terminal segments are inside
 // the deopted subtree, and re-fetching their static bundle would at best
 // duplicate the runtime request and at worst replace a runtime-complete
-// entry (e.g. a runtime App Shell) with a less complete static fallback
-// response.
+// entry (e.g. a RuntimeShell-tier entry) with a less complete static
+// fallback response.
 spawnRevalidations) {
-    let segmentCount = 0;
-    let needsFetch = false;
     let needsRuntimeRequest = false;
+    // The pending entries this task owns — Empty entries upgraded here, plus
+    // any revalidations spawned here — keyed by segment request key. If any
+    // accumulate, a single fetch is spawned for the whole bundle, and the
+    // response fulfills them.
+    let spawnedEntries = null;
     let node = segments;
     while(node !== null){
-        segmentCount++;
         const nodeEntry = node.entry;
         const nodeTree = node.tree;
         if (nodeEntry === null || nodeTree === null) {
@@ -1327,12 +1359,17 @@ spawnRevalidations) {
         }
         switch(nodeEntry.status){
             case _cache.EntryStatus.Empty:
-                (0, _cache.upgradeToPendingSegment)(nodeEntry, fetchStrategy);
-                needsFetch = true;
-                // The pass blocks on every request it spawns, not just requests it
-                // finds already in flight.
-                blockTaskOnPendingResponse(task, nodeEntry);
-                break;
+                {
+                    const pendingEntry = (0, _cache.upgradeToPendingSegment)(nodeEntry, fetchStrategy);
+                    if (spawnedEntries === null) {
+                        spawnedEntries = new Map();
+                    }
+                    spawnedEntries.set(nodeTree.requestKey, pendingEntry);
+                    // The pass blocks on every request it spawns, not just requests it
+                    // finds already in flight.
+                    blockTaskOnPendingResponse(task, pendingEntry);
+                    break;
+                }
             case _cache.EntryStatus.Pending:
                 if (spawnRevalidations && // During a static shell attempt, never spawn revalidations — just
                 // wait for the in-flight response (blocked below); its sufficiency
@@ -1340,17 +1377,15 @@ spawnRevalidations) {
                 fetchStrategy === _types.FetchStrategy.PPR && (0, _cache.canNewFetchStrategyProvideMoreContent)(nodeEntry.fetchStrategy, fetchStrategy)) {
                     const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, task.segmentCacheMap, fetchStrategy, nodeTree);
                     if (revalidatingEntry.status === _cache.EntryStatus.Empty) {
-                        (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
-                        node.entry = revalidatingEntry;
-                        needsFetch = true;
+                        const pendingEntry = (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
+                        if (spawnedEntries === null) {
+                            spawnedEntries = new Map();
+                        }
+                        spawnedEntries.set(nodeTree.requestKey, pendingEntry);
                         // Block on the revalidation request we just spawned, in
                         // addition to the original in-flight entry (blocked below).
-                        blockTaskOnPendingResponse(task, revalidatingEntry);
-                    } else {
-                        node.entry = null;
+                        blockTaskOnPendingResponse(task, pendingEntry);
                     }
-                } else {
-                    node.entry = null;
                 }
                 blockTaskOnPendingResponse(task, nodeEntry);
                 break;
@@ -1367,53 +1402,65 @@ spawnRevalidations) {
                 fetchStrategy === _types.FetchStrategy.PPR && (0, _cache.canNewFetchStrategyProvideMoreContent)(nodeEntry.fetchStrategy, fetchStrategy)) {
                     const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, task.segmentCacheMap, fetchStrategy, nodeTree);
                     if (revalidatingEntry.status === _cache.EntryStatus.Empty) {
-                        (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
-                        node.entry = revalidatingEntry;
-                        needsFetch = true;
+                        const pendingEntry = (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
+                        if (spawnedEntries === null) {
+                            spawnedEntries = new Map();
+                        }
+                        spawnedEntries.set(nodeTree.requestKey, pendingEntry);
                         // Block on the retry revalidation we just spawned, like any
                         // other pending response. If the retry succeeds, its upsert
                         // evicts the rejected entry (see evictShadowingSegmentEntries
                         // in cache.ts) and the re-run pass reads the healed data. If it
                         // rejects too, the re-run observes a settled revalidation and
                         // moves on.
-                        blockTaskOnPendingResponse(task, revalidatingEntry);
-                    } else {
-                        node.entry = null;
+                        blockTaskOnPendingResponse(task, pendingEntry);
                     }
-                } else {
-                    node.entry = null;
                 }
                 break;
             case _cache.EntryStatus.Fulfilled:
                 {
-                    const runtimeWouldProvideMore = wouldRuntimeRequestProvideMore(nodeEntry, fetchStrategy);
-                    if (runtimeWouldProvideMore) {
-                        // A runtime request would return more content for this segment
-                        // than the entry contains. Surface it via the return value, so the
-                        // caller can deopt this subtree to a runtime prefetch.
-                        needsRuntimeRequest = true;
+                    let willBeSupersededByRuntimeRequest = false;
+                    if (walkCanUseRuntimeRequests(fetchStrategy, route)) {
+                        const runtimeWouldProvideMore = wouldRuntimeRequestProvideMore(nodeEntry, fetchStrategy);
+                        // An eligible shell-tier entry takes the static attempt path below
+                        // (the revalidation) instead of deopting straight to a runtime
+                        // request; see isShellEntryEligibleForStaticAttempt. The attempt
+                        // can't recur: its response records at least the concrete static
+                        // tier, which fails the shell-tier check on the re-run pass — and an
+                        // attempt that already settled without healing the entry reads as
+                        // ineligible, so the deopt proceeds after all.
+                        const shellEntryEligibleForStaticAttempt = isShellEntryEligibleForStaticAttempt(now, task.segmentCacheMap, nodeEntry, nodeTree, fetchStrategy);
+                        if (runtimeWouldProvideMore && !shellEntryEligibleForStaticAttempt) {
+                            // A runtime request would return more content for this segment
+                            // than the entry contains. Surface it via the return value, so the
+                            // caller can deopt this subtree to a runtime prefetch. (An
+                            // eligible shell-tier entry withholds the signal for this pass:
+                            // the static attempt spawned below blocks the task, and the re-run
+                            // pass reads the attempt's result instead.)
+                            needsRuntimeRequest = true;
+                            // If a runtime request would return more content skip the static path
+                            // entirely — unless the entry is an eligible shell-tier entry (see above),
+                            // whose static attempt IS this upgrade.
+                            // Otherwise the runtime request covers this segment and supersedes
+                            // anything a static fetch could add, so a static upgrade would at best
+                            // duplicate it — delivering the same content twice — and at worst replace
+                            // runtime content with static content.
+                            willBeSupersededByRuntimeRequest = true;
+                        }
                     }
+                    // If this is the speculative phase (not the shell phase), check if we
+                    // should attempt to upgrade a fallback ISR response to a concrete
+                    // version.
+                    //
                     // For entries below this phase's tier, upgrade during the phase
                     // itself — no background deferral, since the whole point of the
                     // Speculative phase is to bring the cache up to the
                     // per-link-concrete tier. `isPartial` ensures a complete entry isn't
                     // re-fetched.
                     //
-                    // Exception: when a runtime request would return more AND this walk
-                    // permits one, skip the static path entirely. The runtime request
-                    // covers this segment and supersedes anything a static fetch could
-                    // add, so a static upgrade would at best duplicate it — delivering
-                    // the same content twice — and at worst replace runtime content with
-                    // static content.
-                    //
-                    // When no runtime request is permitted, the signal is irrelevant:
-                    // nothing can act on it, so it must not suppress the static upgrade.
-                    // That's what keeps a link prefetching static content on top of a
-                    // cached shell.
-                    const willBeSupersededByRuntimeRequest = runtimeWouldProvideMore && walkRequiresRuntimeCompleteness(fetchStrategy, route);
-                    // Check if we should attempt to upgrade a fallback ISR response to
-                    // a concrete version.
-                    const isUpgradeableISRFallbackRetry = nodeEntry.isUpgradeableISRFallback && // If the status is empty, then we haven't yet attempted to upgrade
+                    // If we can use runtime requests and a runtime request would provide more
+                    // data, we also skip the upgrade (see `willBeSupersededByRuntimeRequest`)
+                    const isUpgradeableISRFallbackRetry = fetchStrategy === _types.FetchStrategy.PPR && nodeEntry.isUpgradeableISRFallback && // If the status is empty, then we haven't yet attempted to upgrade
                     // the fallback.
                     //
                     // If the status is fulfilled, then the fallback was
@@ -1424,29 +1471,32 @@ spawnRevalidations) {
                     if (spawnRevalidations && !willBeSupersededByRuntimeRequest && (nodeEntry.isPartial && (0, _cache.canNewFetchStrategyProvideMoreContent)(nodeEntry.fetchStrategy, fetchStrategy) || isUpgradeableISRFallbackRetry)) {
                         const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, task.segmentCacheMap, fetchStrategy, nodeTree);
                         if (revalidatingEntry.status === _cache.EntryStatus.Empty) {
-                            (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
-                            node.entry = revalidatingEntry;
-                            needsFetch = true;
+                            const pendingEntry = (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
+                            if (spawnedEntries === null) {
+                                spawnedEntries = new Map();
+                            }
+                            spawnedEntries.set(nodeTree.requestKey, pendingEntry);
                             // The pass blocks on every request it spawns, including
                             // revalidations of an already-fulfilled entry.
-                            blockTaskOnPendingResponse(task, revalidatingEntry);
+                            blockTaskOnPendingResponse(task, pendingEntry);
                         } else {
                             // A non-empty revalidating entry means a request is already in
                             // flight (or recently settled), so we dedupe and don't issue a
                             // competing one — including for ISR-fallback upgrades, which then
                             // share the same revalidation across tasks.
-                            node.entry = null;
                             if (revalidatingEntry.status === _cache.EntryStatus.Pending) {
                                 // The deduped-against revalidation is still in flight, and this
                                 // pass depends on its response. Wait for it before the phase
                                 // can complete. (A settled revalidation we chose not to use
                                 // needs no waiting and is not a prefetch failure — the base
-                                // entry here is already Fulfilled.)
+                                // entry here is already Fulfilled. A settled revalidation
+                                // can't strand an eligible shell-tier entry either:
+                                // isShellEntryEligibleForStaticAttempt reads the slot, so a
+                                // settled attempt makes the entry ineligible and the runtime
+                                // deopt proceeds above.)
                                 blockTaskOnPendingResponse(task, revalidatingEntry);
                             }
                         }
-                    } else {
-                        node.entry = null;
                     }
                     break;
                 }
@@ -1455,8 +1505,8 @@ spawnRevalidations) {
         }
         node = node.parent;
     }
-    if (needsFetch) {
-        spawnPrefetchSubtask((0, _cache.fetchSegmentsOnCacheMiss)(task, route, routeKey, tree, segments, segmentCount, fetchStrategy));
+    if (spawnedEntries !== null) {
+        spawnPrefetchSubtask((0, _cache.fetchSegmentPrefetchesUsingStaticRequest)(task, route, routeKey, tree, spawnedEntries, fetchStrategy));
     }
     return needsRuntimeRequest;
 }
@@ -1469,14 +1519,15 @@ spawnRevalidations) {
  * bundle ping, if one happened (always false otherwise).
  */ function accumulateSegmentBundle(now, task, route, tree, parentBundle, // Per-pass static walk strategy; see pingRootRouteTree where it's derived.
 // PPR for the normal static bundling walk; StaticShell during the Shell
-// phase's static App Shell attempt, whose entries are keyed at the shell
+// phase's static shell attempt, whose entries are keyed at the shell
 // vary paths.
 fetchStrategy, // False when finishing a chain on a runtime-prefetch bailout; see
 // pingSegmentBundle.
 spawnRevalidations) {
     // Prefetching is disabled for this segment (prefetch: 'force-disabled'):
-    // the server emits null for its slot, and it participates in the bundle
-    // chain with null tree/entry so the null-slot positions line up.
+    // the server emits identity only for its response node, and it
+    // participates in the bundle chain with null tree/entry — no cache entry
+    // is created for it.
     // (Partial Prefetching segments are NOT in this mask — the server emits
     // static data for them unconditionally.) Intentionally not gated by the
     // prefetch inlining flag: we never statically prefetch unprefetchable
@@ -1495,7 +1546,7 @@ spawnRevalidations) {
     if (process.env.__NEXT_PREFETCH_INLINING && tree.prefetchHints & _approutertypes.PrefetchHint.InlinedIntoChild) {
         if (segment.status === _cache.EntryStatus.Pending) {
             // The chain this entry joins may be dropped before it's ever pinged
-            // (see the drop sites in pingNewPartOfCacheComponentsTree), and only
+            // (see the drop sites in pingSegmentInCacheComponentsTree), and only
             // the ping blocks on Pending entries. Register on the in-flight
             // response at read time instead, so the pass observes it before the
             // phase can complete even if the chain is dropped. When the chain does
@@ -1513,8 +1564,12 @@ spawnRevalidations) {
             // ping only reaches the terminal descendant, and if that descendant is
             // itself a decision point it consumes the signal for its own subtree,
             // leaving this ancestor's insufficiency invisible to the decision
-            // point above it.
-            needsRuntimeRequest: segment.status === _cache.EntryStatus.Fulfilled && wouldRuntimeRequestProvideMore(segment, fetchStrategy)
+            // point above it. An eligible shell-tier entry withholds the signal,
+            // the same exception the bundle ping applies: deopting here would
+            // pre-empt the static attempt the chain ping spawns for this node when
+            // it reaches the terminal descendant (its Fulfilled case runs for
+            // every node in the chain).
+            needsRuntimeRequest: segment.status === _cache.EntryStatus.Fulfilled && wouldRuntimeRequestProvideMore(segment, fetchStrategy) && !isShellEntryEligibleForStaticAttempt(now, task.segmentCacheMap, segment, tree, fetchStrategy)
         };
     }
     // Not bundled. Build a single-node bundle and ping it. If this page
@@ -1523,8 +1578,8 @@ spawnRevalidations) {
     let effectiveParent = parentBundle;
     if (process.env.__NEXT_PREFETCH_INLINING && tree.prefetchHints & _approutertypes.PrefetchHint.HeadInlinedIntoSelf) {
         effectiveParent = {
-            tree: route.metadata,
-            entry: (0, _cache.readOrCreateSegmentCacheEntry)(now, task.segmentCacheMap, fetchStrategy, route.metadata),
+            tree: route.root.head,
+            entry: (0, _cache.readOrCreateSegmentCacheEntry)(now, task.segmentCacheMap, fetchStrategy, route.root.head),
             parent: parentBundle
         };
     }
@@ -1562,14 +1617,14 @@ fetchStrategy) {
 function pingFullSegmentRevalidation(now, task, tree, fetchStrategy) {
     const revalidatingSegment = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, task.segmentCacheMap, 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
-        // returning a pending entry from this function, it signals to the caller
-        // that this segment should be included in the request that's sent to
-        // the server.
+        // During a Full/PPRRuntime prefetch, a single runtime request is made for
+        // all the segments that we need. So we don't initiate a request here
+        // directly. By returning a pending entry from this function, it signals
+        // to the caller that this segment should be included in the request
+        // that's sent to the server.
         const pendingSegment = (0, _cache.upgradeToPendingSegment)(revalidatingSegment, fetchStrategy);
-        // The upsert is handled by fulfillEntrySpawnedByRuntimePrefetch
-        // when the dynamic prefetch response is written into the cache.
+        // The upsert is handled by writeSegmentDataIntoCache
+        // when the runtime request's response is written into the cache.
         return pendingSegment;
     } else {
         // There's already a revalidation in progress.
@@ -1579,8 +1634,8 @@ function pingFullSegmentRevalidation(now, task, tree, fetchStrategy) {
             // Reset it and start a new revalidation.
             const emptySegment = (0, _cache.overwriteRevalidatingSegmentCacheEntry)(now, task.segmentCacheMap, fetchStrategy, tree);
             const pendingSegment = (0, _cache.upgradeToPendingSegment)(emptySegment, fetchStrategy);
-            // The upsert is handled by fulfillEntrySpawnedByRuntimePrefetch
-            // when the dynamic prefetch response is written into the cache.
+            // The upsert is handled by writeSegmentDataIntoCache
+            // when the runtime request's response is written into the cache.
             return pendingSegment;
         }
         switch(nonEmptyRevalidatingSegment.status){
@@ -1602,30 +1657,14 @@ function pingFullSegmentRevalidation(now, task, tree, fetchStrategy) {
         }
     }
 }
-function doesCurrentSegmentMatchCachedSegment(route, currentSegment, cachedSegment) {
-    if (cachedSegment === _segment.PAGE_SEGMENT_KEY) {
-        // In the FlightRouterState stored by the router, the page segment has the
-        // rendered search params appended to the name of the segment. In the
-        // prefetch cache, however, this is stored separately. So, when comparing
-        // the router's current FlightRouterState to the cached FlightRouterState,
-        // we need to make sure we compare both parts of the segment.
-        // TODO: This is not modeled clearly. We use the same type,
-        // FlightRouterState, for both the CacheNode tree _and_ the prefetch cache
-        // _and_ the server response format, when conceptually those are three
-        // different things and treated in different ways. We should encode more of
-        // this information into the type design so mistakes are less likely.
-        return currentSegment === (0, _segment.addSearchParamsIfPageSegment)(_segment.PAGE_SEGMENT_KEY, (0, _routeparams.urlSearchParamsToParsedUrlQuery)(new URLSearchParams(route.renderedSearch)));
+function needsSpeculativePrefetch(taskfetchStrategy, rootPrefetchHints) {
+    if ((rootPrefetchHints & _approutertypes.PrefetchHint.SubtreeHasPartialPrefetching) !== 0) {
+        // PPF - only needs a speculative prefetch if this is a `<Link prefetch={true}>`.
+        return taskfetchStrategy === _types.FetchStrategy.Full;
+    } else {
+        // non-PPF -- all prefetches are speculative.
+        return true;
     }
-    // Non-page segments are compared using the same function as the server
-    return (0, _matchsegments.matchSegment)(cachedSegment, currentSegment);
-}
-function subtreeHasSpeculativePrefetch(fetchStrategy, prefetchHints) {
-    return(// Check if this is a "full" prefetch (<Link prefetch={true}>).
-    fetchStrategy === _types.FetchStrategy.Full || // Check if something in this subtree is configured to be eagerly
-    // prefetched at the route level. Segments that don't opt into Partial
-    // Prefetching are marked eager, so a route without any Partial Prefetching
-    // still speculatively prefetches everything.
-    (prefetchHints & _approutertypes.PrefetchHint.SubtreeHasEagerPrefetch) !== 0);
 }
 // -----------------------------------------------------------------------------
 // The remainder of the module is a MinHeap implementation. Try not to put any