@semiont/frontend 0.3.3 → 0.3.4

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

@@ -3,9 +3,12 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    completeHardNavigation: null,
+    completeSoftNavigation: null,
+    completeTraverseNavigation: null,
     convertServerPatchToFullTree: null,
     navigate: null,
-    navigateToSeededRoute: null
+    navigateToKnownRoute: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -14,67 +17,67 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    completeHardNavigation: function() {
+        return completeHardNavigation;
+    },
+    completeSoftNavigation: function() {
+        return completeSoftNavigation;
+    },
+    completeTraverseNavigation: function() {
+        return completeTraverseNavigation;
+    },
     convertServerPatchToFullTree: function() {
         return convertServerPatchToFullTree;
     },
     navigate: function() {
         return navigate;
     },
-    navigateToSeededRoute: function() {
-        return navigateToSeededRoute;
+    navigateToKnownRoute: function() {
+        return navigateToKnownRoute;
     }
 });
 const _fetchserverresponse = require("../router-reducer/fetch-server-response");
 const _pprnavigations = require("../router-reducer/ppr-navigations");
 const _createhreffromurl = require("../router-reducer/create-href-from-url");
+const _constants = require("../../../lib/constants");
 const _cache = require("./cache");
+const _optimisticroutes = require("./optimistic-routes");
 const _cachekey = require("./cache-key");
-const _segment = require("../../../shared/lib/segment");
+const _scheduler = require("./scheduler");
 const _types = require("./types");
-function navigate(url, currentUrl, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, shouldScroll, accumulation) {
+const _links = require("../links");
+const _routerreducertypes = require("../router-reducer/router-reducer-types");
+const _computechangedpath = require("../router-reducer/compute-changed-path");
+const _javascripturl = require("../../lib/javascript-url");
+const _bfcache = require("./bfcache");
+function navigate(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType) {
+    // Instant Navigation Testing API: when the lock is active, ensure a
+    // prefetch task has been initiated before proceeding with the navigation.
+    // This guarantees that segment data requests are at least pending, even
+    // for routes that already have a cached route tree. Without this, the
+    // static shell might be incomplete because some segments were never
+    // requested.
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        const { isNavigationLocked } = require('./navigation-testing-lock');
+        if (isNavigationLocked()) {
+            return ensurePrefetchThenNavigate(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType);
+        }
+    }
+    return navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType);
+}
+function navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType) {
     const now = Date.now();
     const href = url.href;
-    // We special case navigations to the exact same URL as the current location.
-    // It's a common UI pattern for apps to refresh when you click a link to the
-    // current page. So when this happens, we refresh the dynamic data in the page
-    // segments.
-    //
-    // Note that this does not apply if the any part of the hash or search query
-    // has changed. This might feel a bit weird but it makes more sense when you
-    // consider that the way to trigger this behavior is to click the same link
-    // multiple times.
-    //
-    // TODO: We should probably refresh the *entire* route when this case occurs,
-    // not just the page segments. Essentially treating it the same as a refresh()
-    // triggered by an action, which is the more explicit way of modeling the UI
-    // pattern described above.
-    //
-    // Also note that this only refreshes the dynamic data, not static/ cached
-    // data. If the page segment is fully static and prefetched, the request is
-    // skipped. (This is also how refresh() works.)
-    const isSamePageNavigation = href === currentUrl.href;
     const cacheKey = (0, _cachekey.createCacheKey)(href, nextUrl);
     const route = (0, _cache.readRouteCacheEntry)(now, cacheKey);
     if (route !== null && route.status === _cache.EntryStatus.Fulfilled) {
         // We have a matching prefetch.
-        const snapshot = readRenderSnapshotFromCache(now, route, route.tree);
-        const prefetchFlightRouterState = snapshot.flightRouterState;
-        const prefetchSeedData = snapshot.seedData;
-        const headSnapshot = readHeadSnapshotFromCache(now, route);
-        const prefetchHead = headSnapshot.rsc;
-        const isPrefetchHeadPartial = headSnapshot.isPartial;
-        // TODO: The "canonicalUrl" stored in the cache doesn't include the hash,
-        // because hash entries do not vary by hash fragment. However, the one
-        // we set in the router state *does* include the hash, and it's used to
-        // sync with the actual browser location. To make this less of a refactor
-        // hazard, we should always track the hash separately from the rest of
-        // the URL.
-        const newCanonicalUrl = route.canonicalUrl + url.hash;
-        const renderedSearch = route.renderedSearch;
-        return navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, newCanonicalUrl, renderedSearch, freshnessPolicy, shouldScroll);
+        return navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, route);
     }
     // There was no matching route tree in the cache. Let's see if we can
-    // construct an "optimistic" route tree.
+    // construct an "optimistic" route tree using the deprecated search-params
+    // based matching. This is only used when the new optimisticRouting flag is
+    // disabled.
     //
     // Do not construct an optimistic route tree if there was a cache hit, but
     // the entry has a rejected status, since it may have been rejected due to a
@@ -82,203 +85,85 @@ function navigate(url, currentUrl, currentCacheNode, currentFlightRouterState, n
     //
     // TODO: There are multiple reasons a prefetch might be rejected; we should
     // track them explicitly and choose what to do here based on that.
-    if (route === null || route.status !== _cache.EntryStatus.Rejected) {
-        const optimisticRoute = (0, _cache.requestOptimisticRouteCacheEntry)(now, url, nextUrl);
-        if (optimisticRoute !== null) {
-            // We have an optimistic route tree. Proceed with the normal flow.
-            const snapshot = readRenderSnapshotFromCache(now, optimisticRoute, optimisticRoute.tree);
-            const prefetchFlightRouterState = snapshot.flightRouterState;
-            const prefetchSeedData = snapshot.seedData;
-            const headSnapshot = readHeadSnapshotFromCache(now, optimisticRoute);
-            const prefetchHead = headSnapshot.rsc;
-            const isPrefetchHeadPartial = headSnapshot.isPartial;
-            const newCanonicalUrl = optimisticRoute.canonicalUrl + url.hash;
-            const newRenderedSearch = optimisticRoute.renderedSearch;
-            return navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, newCanonicalUrl, newRenderedSearch, freshnessPolicy, shouldScroll);
+    if (!process.env.__NEXT_OPTIMISTIC_ROUTING) {
+        if (route === null || route.status !== _cache.EntryStatus.Rejected) {
+            const optimisticRoute = (0, _cache.deprecated_requestOptimisticRouteCacheEntry)(now, url, nextUrl);
+            if (optimisticRoute !== null) {
+                // We have an optimistic route tree. Proceed with the normal flow.
+                return navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, optimisticRoute);
+            }
         }
     }
-    // There's no matching prefetch for this route in the cache.
-    let collectedDebugInfo = accumulation.collectedDebugInfo ?? [];
-    if (accumulation.collectedDebugInfo === undefined) {
-        collectedDebugInfo = accumulation.collectedDebugInfo = [];
-    }
-    return {
-        tag: _types.NavigationResultTag.Async,
-        data: navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, shouldScroll, collectedDebugInfo)
-    };
+    // There's no matching prefetch for this route in the cache. We must lazily
+    // fetch it from the server before we can perform the navigation.
+    //
+    // TODO: If this is a gesture navigation, instead of performing a
+    // dynamic request, we should do a runtime prefetch.
+    return navigateToUnknownRoute(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType).catch(()=>{
+        // If the navigation fails, return the current state
+        return state;
+    });
 }
-function navigateToSeededRoute(now, url, canonicalUrl, navigationSeed, currentUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, shouldScroll) {
+function navigateToKnownRoute(now, state, url, canonicalUrl, navigationSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, debugInfo, // The route cache entry used for this navigation, if it came from route
+// prediction. Passed through so it can be marked as having a dynamic rewrite
+// if the server returns a different pathname (indicating dynamic rewrite
+// behavior).
+//
+// When null, the navigation did not use route prediction - either because
+// the route was already fully cached, or it's a navigation that doesn't
+// involve prediction (refresh, history traversal, server action, etc.).
+// In these cases, if a mismatch occurs, we still mark the route as having a
+// dynamic rewrite by traversing the known route tree (see
+// dispatchRetryDueToTreeMismatch).
+routeCacheEntry) {
     // A version of navigate() that accepts the target route tree as an argument
     // rather than reading it from the prefetch cache.
     const accumulation = {
-        scrollableSegments: null,
-        separateRefreshUrls: null
+        separateRefreshUrls: null,
+        scrollRef: null
     };
+    // We special case navigations to the exact same URL as the current location.
+    // It's a common UI pattern for apps to refresh when you click a link to the
+    // current page. So when this happens, we refresh the dynamic data in the page
+    // segments.
+    //
+    // Note that this does not apply if the any part of the hash or search query
+    // has changed. This might feel a bit weird but it makes more sense when you
+    // consider that the way to trigger this behavior is to click the same link
+    // multiple times.
+    //
+    // TODO: We should probably refresh the *entire* route when this case occurs,
+    // not just the page segments. Essentially treating it the same as a refresh()
+    // triggered by an action, which is the more explicit way of modeling the UI
+    // pattern described above.
+    //
+    // Also note that this only refreshes the dynamic data, not static/ cached
+    // data. If the page segment is fully static and prefetched, the request is
+    // skipped. (This is also how refresh() works.)
     const isSamePageNavigation = url.href === currentUrl.href;
-    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentCacheNode, currentFlightRouterState, navigationSeed.tree, freshnessPolicy, navigationSeed.data, navigationSeed.head, null, null, false, isSamePageNavigation, accumulation);
-    if (task !== null) {
-        (0, _pprnavigations.spawnDynamicRequests)(task, url, nextUrl, freshnessPolicy, accumulation);
-        return navigationTaskToResult(task, canonicalUrl, navigationSeed.renderedSearch, accumulation.scrollableSegments, shouldScroll, url.hash);
-    }
-    // Could not perform a SPA navigation. Revert to a full-page (MPA) navigation.
-    return {
-        tag: _types.NavigationResultTag.MPA,
-        data: canonicalUrl
-    };
-}
-function navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, canonicalUrl, renderedSearch, freshnessPolicy, shouldScroll) {
-    // Recursively construct a prefetch tree by reading from the Segment Cache. To
-    // maintain compatibility, we output the same data structures as the old
-    // prefetching implementation: FlightRouterState and CacheNodeSeedData.
-    // TODO: Eventually updateCacheNodeOnNavigation (or the equivalent) should
-    // read from the Segment Cache directly. It's only structured this way for now
-    // so we can share code with the old prefetching implementation.
-    const accumulation = {
-        scrollableSegments: null,
-        separateRefreshUrls: null
-    };
-    const seedData = null;
-    const seedHead = null;
-    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, freshnessPolicy, seedData, seedHead, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, accumulation);
+    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, navigationSeed.routeTree, navigationSeed.metadataVaryPath, freshnessPolicy, navigationSeed.data, navigationSeed.head, navigationSeed.dynamicStaleAt, isSamePageNavigation, accumulation);
     if (task !== null) {
-        (0, _pprnavigations.spawnDynamicRequests)(task, url, nextUrl, freshnessPolicy, accumulation);
-        return navigationTaskToResult(task, canonicalUrl, renderedSearch, accumulation.scrollableSegments, shouldScroll, url.hash);
-    }
-    // Could not perform a SPA navigation. Revert to a full-page (MPA) navigation.
-    return {
-        tag: _types.NavigationResultTag.MPA,
-        data: canonicalUrl
-    };
-}
-function navigationTaskToResult(task, canonicalUrl, renderedSearch, scrollableSegments, shouldScroll, hash) {
-    return {
-        tag: _types.NavigationResultTag.Success,
-        data: {
-            flightRouterState: task.route,
-            cacheNode: task.node,
-            canonicalUrl,
-            renderedSearch,
-            scrollableSegments,
-            shouldScroll,
-            hash
-        }
-    };
-}
-function readRenderSnapshotFromCache(now, route, tree) {
-    let childRouterStates = {};
-    let childSeedDatas = {};
-    const slots = tree.slots;
-    if (slots !== null) {
-        for(const parallelRouteKey in slots){
-            const childTree = slots[parallelRouteKey];
-            const childResult = readRenderSnapshotFromCache(now, route, childTree);
-            childRouterStates[parallelRouteKey] = childResult.flightRouterState;
-            childSeedDatas[parallelRouteKey] = childResult.seedData;
+        if (freshnessPolicy !== _pprnavigations.FreshnessPolicy.Gesture) {
+            (0, _pprnavigations.spawnDynamicRequests)(task, url, nextUrl, freshnessPolicy, accumulation, routeCacheEntry, navigateType);
         }
+        return completeSoftNavigation(state, url, nextUrl, task.route, task.node, navigationSeed.renderedSearch, canonicalUrl, navigateType, scrollBehavior, accumulation.scrollRef, debugInfo);
     }
-    let rsc = null;
-    let loading = null;
-    let isPartial = true;
-    const segmentEntry = (0, _cache.readSegmentCacheEntry)(now, tree.varyPath);
-    if (segmentEntry !== null) {
-        switch(segmentEntry.status){
-            case _cache.EntryStatus.Fulfilled:
-                {
-                    // Happy path: a cache hit
-                    rsc = segmentEntry.rsc;
-                    loading = segmentEntry.loading;
-                    isPartial = segmentEntry.isPartial;
-                    break;
-                }
-            case _cache.EntryStatus.Pending:
-                {
-                    // We haven't received data for this segment yet, but there's already
-                    // an in-progress request. Since it's extremely likely to arrive
-                    // before the dynamic data response, we might as well use it.
-                    const promiseForFulfilledEntry = (0, _cache.waitForSegmentCacheEntry)(segmentEntry);
-                    rsc = promiseForFulfilledEntry.then((entry)=>entry !== null ? entry.rsc : null);
-                    loading = promiseForFulfilledEntry.then((entry)=>entry !== null ? entry.loading : null);
-                    // Because the request is still pending, we typically don't know yet
-                    // whether the response will be partial. We shouldn't skip this segment
-                    // during the dynamic navigation request. Otherwise, we might need to
-                    // do yet another request to fill in the remaining data, creating
-                    // a waterfall.
-                    //
-                    // The one exception is if this segment is being fetched with via
-                    // prefetch={true} (i.e. the "force stale" or "full" strategy). If so,
-                    // we can assume the response will be full. This field is set to `false`
-                    // for such segments.
-                    isPartial = segmentEntry.isPartial;
-                    break;
-                }
-            case _cache.EntryStatus.Empty:
-            case _cache.EntryStatus.Rejected:
-                break;
-            default:
-                segmentEntry;
-        }
-    }
-    // The navigation implementation expects the search params to be
-    // included in the segment. However, the Segment Cache tracks search
-    // params separately from the rest of the segment key. So we need to
-    // add them back here.
-    //
-    // See corresponding comment in convertFlightRouterStateToTree.
-    //
-    // TODO: What we should do instead is update the navigation diffing
-    // logic to compare search params explicitly. This is a temporary
-    // solution until more of the Segment Cache implementation has settled.
-    const segment = (0, _segment.addSearchParamsIfPageSegment)(tree.segment, Object.fromEntries(new URLSearchParams(route.renderedSearch)));
-    // We don't need this information in a render snapshot, so this can just be a placeholder.
-    const hasRuntimePrefetch = false;
-    return {
-        flightRouterState: [
-            segment,
-            childRouterStates,
-            null,
-            null,
-            tree.isRootLayout
-        ],
-        seedData: [
-            rsc,
-            childSeedDatas,
-            loading,
-            isPartial,
-            hasRuntimePrefetch
-        ]
-    };
+    // Could not perform a SPA navigation. Revert to a full-page (MPA) navigation.
+    return completeHardNavigation(state, url, navigateType);
 }
-function readHeadSnapshotFromCache(now, route) {
-    // Same as readRenderSnapshotFromCache, but for the head
-    let rsc = null;
-    let isPartial = true;
-    const segmentEntry = (0, _cache.readSegmentCacheEntry)(now, route.metadata.varyPath);
-    if (segmentEntry !== null) {
-        switch(segmentEntry.status){
-            case _cache.EntryStatus.Fulfilled:
-                {
-                    rsc = segmentEntry.rsc;
-                    isPartial = segmentEntry.isPartial;
-                    break;
-                }
-            case _cache.EntryStatus.Pending:
-                {
-                    const promiseForFulfilledEntry = (0, _cache.waitForSegmentCacheEntry)(segmentEntry);
-                    rsc = promiseForFulfilledEntry.then((entry)=>entry !== null ? entry.rsc : null);
-                    isPartial = segmentEntry.isPartial;
-                    break;
-                }
-            case _cache.EntryStatus.Empty:
-            case _cache.EntryStatus.Rejected:
-                break;
-            default:
-                segmentEntry;
-        }
-    }
-    return {
-        rsc,
-        isPartial
+function navigateUsingPrefetchedRouteTree(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType, route) {
+    const routeTree = route.tree;
+    const canonicalUrl = route.canonicalUrl + url.hash;
+    const renderedSearch = route.renderedSearch;
+    const prefetchSeed = {
+        renderedSearch,
+        routeTree,
+        metadataVaryPath: route.metadata.varyPath,
+        data: null,
+        head: null,
+        dynamicStaleAt: (0, _bfcache.computeDynamicStaleAt)(now, _bfcache.UnknownDynamicStaleTime)
     };
+    return navigateToKnownRoute(now, state, url, canonicalUrl, prefetchSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, null, route);
 }
 // Used to request all the dynamic data for a route, rather than just a subset,
 // e.g. during a refresh or a revalidation. Typically this gets constructed
@@ -291,7 +176,7 @@ const DynamicRequestTreeForEntireRoute = [
     null,
     'refetch'
 ];
-async function navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, shouldScroll, collectedDebugInfo) {
+async function navigateToUnknownRoute(now, state, url, currentUrl, currentRenderedSearch, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, scrollBehavior, navigateType) {
     // Runs when a navigation happens but there's no cached prefetch we can use.
     // Don't bother to wait for a prefetch response; go straight to a full
     // navigation that contains both static and dynamic data in a single stream.
@@ -307,6 +192,7 @@ async function navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl,
     switch(freshnessPolicy){
         case _pprnavigations.FreshnessPolicy.Default:
         case _pprnavigations.FreshnessPolicy.HistoryTraversal:
+        case _pprnavigations.FreshnessPolicy.Gesture:
             dynamicRequestTree = currentFlightRouterState;
             break;
         case _pprnavigations.FreshnessPolicy.Hydration:
@@ -326,23 +212,219 @@ async function navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl,
     const result = await promiseForDynamicServerResponse;
     if (typeof result === 'string') {
         // This is an MPA navigation.
-        const newUrl = result;
-        return {
-            tag: _types.NavigationResultTag.MPA,
-            data: newUrl
-        };
-    }
-    const { flightData, canonicalUrl, renderedSearch, debugInfo: debugInfoFromResponse } = result;
-    if (debugInfoFromResponse !== null) {
-        collectedDebugInfo.push(...debugInfoFromResponse);
+        const redirectUrl = new URL(result, location.origin);
+        return completeHardNavigation(state, redirectUrl, navigateType);
     }
+    const { flightData, canonicalUrl, renderedSearch, couldBeIntercepted, supportsPerSegmentPrefetching, dynamicStaleTime, staticStageData, runtimePrefetchStream, responseHeaders, debugInfo } = result;
     // Since the response format of dynamic requests and prefetches is slightly
     // different, we'll need to massage the data a bit. Create FlightRouterState
     // tree that simulates what we'd receive as the result of a prefetch.
-    const navigationSeed = convertServerPatchToFullTree(currentFlightRouterState, flightData, renderedSearch);
-    return navigateToSeededRoute(now, url, (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl), navigationSeed, currentUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, shouldScroll);
+    const navigationSeed = convertServerPatchToFullTree(now, currentFlightRouterState, flightData, renderedSearch, dynamicStaleTime);
+    // Learn the route pattern so we can predict it for future navigations.
+    // hasDynamicRewrite is false because this is a fresh navigation to an
+    // unknown route - any rewrite detection happens during the traversal inside
+    // discoverKnownRoute. The hasDynamicRewrite param is only set to true when
+    // retrying after a tree mismatch (see dispatchRetryDueToTreeMismatch).
+    const metadataVaryPath = navigationSeed.metadataVaryPath;
+    if (metadataVaryPath !== null) {
+        (0, _optimisticroutes.discoverKnownRoute)(now, url.pathname, nextUrl, null, navigationSeed.routeTree, metadataVaryPath, couldBeIntercepted, (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl), supportsPerSegmentPrefetching, false // hasDynamicRewrite - not a retry, rewrite detection happens during traversal
+        );
+        if (staticStageData !== null) {
+            const { response: staticStageResponse, isResponsePartial } = staticStageData;
+            // Write the static stage of the response into the segment cache so that
+            // subsequent navigations can serve cached static segments instantly.
+            (0, _cache.getStaleAt)(now, staticStageResponse.s).then((staleAt)=>{
+                const buildId = responseHeaders.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? staticStageResponse.b;
+                (0, _cache.writeStaticStageResponseIntoCache)(now, staticStageResponse.f, buildId, staticStageResponse.h, staleAt, currentFlightRouterState, renderedSearch, isResponsePartial);
+            }).catch(()=>{
+            // The static stage processing failed. Not fatal — the navigation
+            // completed normally, we just won't write into the cache.
+            });
+        }
+        if (runtimePrefetchStream !== null) {
+            (0, _cache.processRuntimePrefetchStream)(now, runtimePrefetchStream, currentFlightRouterState, renderedSearch).then((processed)=>{
+                if (processed !== null) {
+                    (0, _cache.writeDynamicRenderResponseIntoCache)(now, _types.FetchStrategy.PPRRuntime, processed.flightDatas, processed.buildId, processed.isResponsePartial, processed.headVaryParams, processed.staleAt, processed.navigationSeed, null);
+                }
+            }).catch(()=>{
+            // The runtime prefetch cache write failed. Not fatal — the
+            // navigation completed normally, we just won't cache runtime data.
+            });
+        }
+    }
+    return navigateToKnownRoute(now, state, url, (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl), navigationSeed, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, debugInfo, // Unknown route navigations don't use route prediction - the route tree
+    // came directly from the server. If a mismatch occurs during dynamic data
+    // fetch, the retry handler will traverse the known route tree to mark the
+    // entry as having a dynamic rewrite.
+    null);
 }
-function convertServerPatchToFullTree(currentTree, flightData, renderedSearch) {
+function completeHardNavigation(state, url, navigateType) {
+    if ((0, _javascripturl.isJavaScriptURLString)(url.href)) {
+        console.error('Next.js has blocked a javascript: URL as a security precaution.');
+        return state;
+    }
+    const newState = {
+        canonicalUrl: url.origin === location.origin ? (0, _createhreffromurl.createHrefFromUrl)(url) : url.href,
+        pushRef: {
+            pendingPush: navigateType === 'push',
+            mpaNavigation: true,
+            preserveCustomHistoryState: false
+        },
+        // TODO: None of the rest of these values are consistent with the incoming
+        // navigation. We rely on the fact that AppRouter will suspend and trigger
+        // a hard navigation before it accesses any of these values. But instead
+        // we should trigger the hard navigation and blocking any subsequent
+        // router updates without updating React.
+        renderedSearch: state.renderedSearch,
+        focusAndScrollRef: state.focusAndScrollRef,
+        cache: state.cache,
+        tree: state.tree,
+        nextUrl: state.nextUrl,
+        previousNextUrl: state.previousNextUrl,
+        debugInfo: null
+    };
+    return newState;
+}
+function completeSoftNavigation(oldState, url, referringNextUrl, tree, cache, renderedSearch, canonicalUrl, navigateType, scrollBehavior, scrollRef, collectedDebugInfo) {
+    // The "Next-Url" is a special representation of the URL that Next.js
+    // uses to implement interception routes.
+    // TODO: Get rid of this extra traversal by computing this during the
+    // same traversal that computes the tree itself. We should also figure out
+    // what is the minimum information needed for the server to correctly
+    // intercept the route.
+    const changedPath = (0, _computechangedpath.computeChangedPath)(oldState.tree, tree);
+    const nextUrlForNewRoute = changedPath ? changedPath : oldState.nextUrl;
+    // This value is stored on the state as `previousNextUrl`; the naming is
+    // confusing. What it represents is the "Next-Url" header that was used to
+    // fetch the incoming route. It's essentially the refererer URL, but in a
+    // Next.js specific format. During refreshes, this is sent back to the server
+    // instead of the current route's "Next-Url" so that the same interception
+    // logic is applied as during the original navigation.
+    const previousNextUrl = referringNextUrl;
+    // Check if the only thing that changed was the hash fragment.
+    const oldUrl = new URL(oldState.canonicalUrl, url);
+    const onlyHashChange = // We don't need to compare the origins, because client-driven
+    // navigations are always same-origin.
+    url.pathname === oldUrl.pathname && url.search === oldUrl.search && url.hash !== oldUrl.hash;
+    // Determine whether and how the page should scroll after this
+    // navigation.
+    //
+    // By default, we scroll to the segments that were navigated to — i.e.
+    // segments in the new part of the route, as opposed to shared segments
+    // that were already part of the previous route. All newly navigated
+    // segments share a single ScrollRef. When they mount, the first one
+    // to mount initiates the scroll. They share a ref so that only one
+    // scroll happens per navigation.
+    //
+    // If a subsequent navigation produces new segments, those supersede
+    // any pending scroll from the previous navigation by invalidating its
+    // ScrollRef. If a navigation doesn't produce any new segments (e.g.
+    // a refresh where the route structure didn't change), any pending
+    // scrolls from previous navigations are unaffected.
+    //
+    // The branches below handle special cases layered on top of this
+    // default model.
+    let activeScrollRef;
+    let forceScroll;
+    if (scrollBehavior === _routerreducertypes.ScrollBehavior.NoScroll) {
+        // The user explicitly opted out of scrolling (e.g. scroll={false}
+        // on a Link or router.push).
+        //
+        // If this navigation created new scroll targets (scrollRef !== null),
+        // neutralize them. If it didn't, any prior scroll targets carried
+        // forward on the cache nodes via reuseSharedCacheNode remain active.
+        if (scrollRef !== null) {
+            scrollRef.current = false;
+        }
+        activeScrollRef = oldState.focusAndScrollRef.scrollRef;
+        forceScroll = false;
+    } else if (onlyHashChange) {
+        // Hash-only navigations should scroll regardless of per-node state.
+        // Create a fresh ref so the first segment to scroll consumes it.
+        //
+        // Invalidate any scroll ref from a prior navigation that hasn't
+        // been consumed yet.
+        const oldScrollRef = oldState.focusAndScrollRef.scrollRef;
+        if (oldScrollRef !== null) {
+            oldScrollRef.current = false;
+        }
+        // Also invalidate any per-node refs that were accumulated during
+        // this navigation's tree construction — the hash-only ref
+        // supersedes them.
+        if (scrollRef !== null) {
+            scrollRef.current = false;
+        }
+        activeScrollRef = {
+            current: true
+        };
+        forceScroll = true;
+    } else {
+        // Default case. Use the accumulated scrollRef (may be null if no
+        // new segments were created). The handler checks per-node refs, so
+        // unchanged parallel route slots won't scroll.
+        activeScrollRef = scrollRef;
+        // If this navigation created new scroll targets, invalidate any
+        // pending scroll from a previous navigation.
+        if (scrollRef !== null) {
+            const oldScrollRef = oldState.focusAndScrollRef.scrollRef;
+            if (oldScrollRef !== null) {
+                oldScrollRef.current = false;
+            }
+        }
+        forceScroll = false;
+    }
+    const newState = {
+        canonicalUrl,
+        renderedSearch,
+        pushRef: {
+            pendingPush: navigateType === 'push',
+            mpaNavigation: false,
+            preserveCustomHistoryState: false
+        },
+        focusAndScrollRef: {
+            scrollRef: activeScrollRef,
+            forceScroll,
+            onlyHashChange,
+            hashFragment: // Remove leading # and decode hash to make non-latin hashes work.
+            //
+            // Empty hash should trigger default behavior of scrolling layout into
+            // view. #top is handled in layout-router.
+            //
+            // Refer to `ScrollAndFocusHandler` for details on how this is used.
+            scrollBehavior !== _routerreducertypes.ScrollBehavior.NoScroll && url.hash !== '' ? decodeURIComponent(url.hash.slice(1)) : oldState.focusAndScrollRef.hashFragment
+        },
+        cache,
+        tree,
+        nextUrl: nextUrlForNewRoute,
+        previousNextUrl,
+        debugInfo: collectedDebugInfo
+    };
+    return newState;
+}
+function completeTraverseNavigation(state, url, renderedSearch, cache, tree, nextUrl) {
+    return {
+        // Set canonical url
+        canonicalUrl: (0, _createhreffromurl.createHrefFromUrl)(url),
+        renderedSearch,
+        pushRef: {
+            pendingPush: false,
+            mpaNavigation: false,
+            // Ensures that the custom history state that was set is preserved when applying this update.
+            preserveCustomHistoryState: true
+        },
+        focusAndScrollRef: state.focusAndScrollRef,
+        cache,
+        // Restore provided tree
+        tree,
+        nextUrl,
+        // TODO: We need to restore previousNextUrl, too, which represents the
+        // Next-Url that was used to fetch the data. Anywhere we fetch using the
+        // canonical URL, there should be a corresponding Next-Url.
+        previousNextUrl: null,
+        debugInfo: null
+    };
+}
+function convertServerPatchToFullTree(now, currentTree, flightData, renderedSearch, dynamicStaleTimeSeconds) {
     // During a client navigation or prefetch, the server sends back only a patch
     // for the parts of the tree that have changed.
     //
@@ -361,22 +443,36 @@ function convertServerPatchToFullTree(currentTree, flightData, renderedSearch) {
     let baseTree = currentTree;
     let baseData = null;
     let head = null;
-    for (const { segmentPath, tree: treePatch, seedData: dataPatch, head: headPatch } of flightData){
-        const result = convertServerPatchToFullTreeImpl(baseTree, baseData, treePatch, dataPatch, segmentPath, 0);
-        baseTree = result.tree;
-        baseData = result.data;
-        // This is the same for all patches per response, so just pick an
-        // arbitrary one
-        head = headPatch;
+    if (flightData !== null) {
+        for (const { segmentPath, tree: treePatch, seedData: dataPatch, head: headPatch } of flightData){
+            const result = convertServerPatchToFullTreeImpl(baseTree, baseData, treePatch, dataPatch, segmentPath, renderedSearch, 0);
+            baseTree = result.tree;
+            baseData = result.data;
+            // This is the same for all patches per response, so just pick an
+            // arbitrary one
+            head = headPatch;
+        }
     }
+    const finalFlightRouterState = baseTree;
+    // Convert the final FlightRouterState into a RouteTree type.
+    //
+    // TODO: Eventually, FlightRouterState will evolve to being a transport format
+    // only. The RouteTree type will become the main type used for dealing with
+    // routes on the client, and we'll store it in the state directly.
+    const acc = {
+        metadataVaryPath: null
+    };
+    const routeTree = (0, _cache.convertRootFlightRouterStateToRouteTree)(finalFlightRouterState, renderedSearch, acc);
     return {
-        tree: baseTree,
+        routeTree,
+        metadataVaryPath: acc.metadataVaryPath,
         data: baseData,
         renderedSearch,
-        head
+        head,
+        dynamicStaleAt: (0, _bfcache.computeDynamicStaleAt)(now, dynamicStaleTimeSeconds)
     };
 }
-function convertServerPatchToFullTreeImpl(baseRouterState, baseData, treePatch, dataPatch, segmentPath, index) {
+function convertServerPatchToFullTreeImpl(baseRouterState, baseData, treePatch, dataPatch, segmentPath, renderedSearch, index) {
     if (index === segmentPath.length) {
         // We reached the part of the tree that we need to patch.
         return {
@@ -404,7 +500,7 @@ function convertServerPatchToFullTreeImpl(baseRouterState, baseData, treePatch,
         const childBaseRouterState = baseTreeChildren[parallelRouteKey];
         const childBaseSeedData = baseSeedDataChildren !== null ? baseSeedDataChildren[parallelRouteKey] ?? null : null;
         if (parallelRouteKey === updatedParallelRouteKey) {
-            const result = convertServerPatchToFullTreeImpl(childBaseRouterState, childBaseSeedData, treePatch, dataPatch, segmentPath, // Advance the index by two and keep cloning until we reach
+            const result = convertServerPatchToFullTreeImpl(childBaseRouterState, childBaseSeedData, treePatch, dataPatch, segmentPath, renderedSearch, // Advance the index by two and keep cloning until we reach
             // the end of the segment path.
             index + 2);
             newTreeChildren[parallelRouteKey] = result.tree;
@@ -427,7 +523,19 @@ function convertServerPatchToFullTreeImpl(baseRouterState, baseData, treePatch,
         newTreeChildren
     ];
     if (2 in baseRouterState) {
-        clonedTree[2] = baseRouterState[2];
+        const compressedRefreshState = baseRouterState[2];
+        if (compressedRefreshState !== undefined && compressedRefreshState !== null) {
+            // Since this part of the tree was patched with new data, any parent
+            // refresh states should be updated to reflect the new rendered search
+            // value. (The refresh state acts like a "context provider".) All pages
+            // within the same server response share the same renderedSearch value,
+            // but the same RouteTree could be composed from multiple different
+            // routes, and multiple responses.
+            clonedTree[2] = [
+                compressedRefreshState[0],
+                renderedSearch
+            ];
+        }
     }
     if (3 in baseRouterState) {
         clonedTree[3] = baseRouterState[3];
@@ -442,13 +550,43 @@ function convertServerPatchToFullTreeImpl(baseRouterState, baseData, treePatch,
         newSeedDataChildren,
         null,
         isEmptySeedDataPartial,
-        false
+        null
     ];
     return {
         tree: clonedTree,
         data: clonedSeedData
     };
 }
+/**
+ * Instant Navigation Testing API: ensures a prefetch task has been initiated
+ * and completed before proceeding with the navigation. This guarantees that
+ * segment data requests are at least pending, even for routes whose route
+ * tree is already cached.
+ *
+ * After the prefetch completes, delegates to the normal navigation flow.
+ */ async function ensurePrefetchThenNavigate(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType) {
+    const link = (0, _links.getLinkForCurrentNavigation)();
+    const fetchStrategy = link !== null ? link.fetchStrategy : _types.FetchStrategy.PPR;
+    // Transition the cookie to captured-SPA immediately, before waiting
+    // for the prefetch. This ensures the devtools panel can update its UI
+    // right away, even if the prefetch takes time (e.g. dev compilation).
+    // The "to" tree starts as null and is filled in after the prefetch
+    // resolves and the navigation produces a new router state.
+    const { transitionToCapturedSPA, updateCapturedSPAToTree } = require('./navigation-testing-lock');
+    transitionToCapturedSPA(currentFlightRouterState, null);
+    const cacheKey = (0, _cachekey.createCacheKey)(url.href, nextUrl);
+    await new Promise((resolve)=>{
+        (0, _scheduler.schedulePrefetchTask)(cacheKey, currentFlightRouterState, fetchStrategy, _types.PrefetchPriority.Default, null, resolve // _onComplete callback
+        );
+    });
+    // Prefetch is complete. Proceed with the normal navigation flow, which
+    // will now find the route in the cache.
+    const result = await navigateImpl(state, url, currentUrl, currentRenderedSearch, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType);
+    // Update the cookie with the resolved "to" tree so the devtools
+    // panel can display both routes immediately.
+    updateCapturedSPAToTree(currentFlightRouterState, result.tree);
+    return result;
+}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });