@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/client/components/error-boundary.js

@@ -21,21 +21,30 @@ _export(exports, {
         return ErrorBoundaryHandler;
     }
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _jsxruntime = require("react/jsx-runtime");
-const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _navigationuntracked = require("./navigation-untracked");
 const _isnextroutererror = require("./is-next-router-error");
 const _navfailurehandler = require("./nav-failure-handler");
 const _handleisrerror = require("./handle-isr-error");
 const _isbot = require("../../shared/lib/router/utils/is-bot");
+const _approutercontextsharedruntime = require("../../shared/lib/app-router-context.shared-runtime");
 const isBotUserAgent = typeof window !== 'undefined' && (0, _isbot.isBot)(window.navigator.userAgent);
 class ErrorBoundaryHandler extends _react.default.Component {
+    static{
+        this.contextType = _approutercontextsharedruntime.AppRouterContext;
+    }
     constructor(props){
         super(props), this.reset = ()=>{
             this.setState({
                 error: null
             });
+        }, this.unstable_retry = ()=>{
+            (0, _react.startTransition)(()=>{
+                this.context?.refresh();
+                this.reset();
+            });
         };
         this.state = {
             error: null,
@@ -88,16 +97,17 @@ class ErrorBoundaryHandler extends _react.default.Component {
         //When it's bot request, segment level error boundary will keep rendering the children,
         // the final error will be caught by the root error boundary and determine wether need to apply graceful degrade.
         if (this.state.error && !isBotUserAgent) {
+            (0, _handleisrerror.handleISRError)({
+                error: this.state.error
+            });
             return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
                 children: [
-                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_handleisrerror.HandleISRError, {
-                        error: this.state.error
-                    }),
                     this.props.errorStyles,
                     this.props.errorScripts,
                     /*#__PURE__*/ (0, _jsxruntime.jsx)(this.props.errorComponent, {
                         error: this.state.error,
-                        reset: this.reset
+                        reset: this.reset,
+                        unstable_retry: this.unstable_retry
                     })
                 ]
             });

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

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

package/standalone/node_modules/next/dist/client/components/handle-isr-error.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "HandleISRError", {
+Object.defineProperty(exports, "handleISRError", {
     enumerable: true,
     get: function() {
-        return HandleISRError;
+        return handleISRError;
     }
 });
 const workAsyncStorage = typeof window === 'undefined' ? require('../../server/app-render/work-async-storage.external').workAsyncStorage : undefined;
-function HandleISRError({ error }) {
+function handleISRError({ error }) {
     if (workAsyncStorage) {
         const store = workAsyncStorage.getStore();
         if (store?.isStaticGeneration) {
@@ -19,7 +19,6 @@ function HandleISRError({ error }) {
             throw error;
         }
     }
-    return null;
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     IDLE_LINK_STATUS: null,
     PENDING_LINK_STATUS: null,
+    getLinkForCurrentNavigation: null,
     mountFormInstance: null,
     mountLinkInstance: null,
     onLinkVisibilityChanged: null,
@@ -27,6 +28,9 @@ _export(exports, {
     PENDING_LINK_STATUS: function() {
         return PENDING_LINK_STATUS;
     },
+    getLinkForCurrentNavigation: function() {
+        return getLinkForCurrentNavigation;
+    },
     mountFormInstance: function() {
         return mountFormInstance;
     },
@@ -77,6 +81,9 @@ function unmountLinkForCurrentNavigation(link) {
         linkForMostRecentNavigation = null;
     }
 }
+function getLinkForCurrentNavigation() {
+    return linkForMostRecentNavigation;
+}
 // Use a WeakMap to associate a Link instance with its DOM element. This is
 // used by the IntersectionObserver to track the link's visibility.
 const prefetchable = typeof WeakMap === 'function' ? new WeakMap() : new Map();

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

@@ -26,6 +26,7 @@ const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-
             case 'prerender':
             case 'prerender-client':
             case 'prerender-ppr':
+            case 'validation-client':
                 const fallbackParams = workUnitStore.fallbackRouteParams;
                 return fallbackParams ? fallbackParams.size > 0 : false;
             case 'prerender-legacy':
@@ -34,6 +35,7 @@ const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
+            case 'generate-static-params':
                 break;
             default:
                 workUnitStore;

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

@@ -92,6 +92,7 @@ const _unrecognizedactionerror = require("./unrecognized-action-error");
 const _navigationreactserver = require("./navigation.react-server");
 const useDynamicRouteParams = typeof window === 'undefined' ? require('../../server/app-render/dynamic-rendering').useDynamicRouteParams : undefined;
 const useDynamicSearchParams = typeof window === 'undefined' ? require('../../server/app-render/dynamic-rendering').useDynamicSearchParams : undefined;
+const { instrumentParamsForClientValidation, instrumentSearchParamsForClientValidation, expectCompleteParamsInClientValidation } = typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS ? require('../../server/app-render/instant-validation/instant-samples-client') : {};
 function useSearchParams() {
     useDynamicSearchParams?.('useSearchParams()');
     const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);
@@ -108,6 +109,11 @@ function useSearchParams() {
     }, [
         searchParams
     ]);
+    // During build-time instant validation, wrap with an proxy
+    // so that accessing undeclared search params throws an error.
+    if (typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS && readonlySearchParams) {
+        return instrumentSearchParamsForClientValidation(readonlySearchParams);
+    }
     // Instrument with Suspense DevTools (dev-only)
     if (process.env.NODE_ENV !== 'production' && 'use' in _react.default) {
         const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
@@ -122,6 +128,12 @@ function usePathname() {
     // In the case where this is `null`, the compat types added in `next-env.d.ts`
     // will add a new overload that changes the return type to include `null`.
     const pathname = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
+    // During build-time instant validation, error if fallback params exist
+    // because usePathname() can't return a sensible value without all params.
+    if (typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS && pathname) {
+        expectCompleteParamsInClientValidation('usePathname()');
+        return pathname;
+    }
     // Instrument with Suspense DevTools (dev-only)
     if (process.env.NODE_ENV !== 'production' && 'use' in _react.default) {
         const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
@@ -145,6 +157,11 @@ function useRouter() {
 function useParams() {
     useDynamicRouteParams?.('useParams()');
     const params = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
+    // During build-time instant validation, wrap with a proxy
+    // so that accessing undeclared params throws an error.
+    if (typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS && params) {
+        return instrumentParamsForClientValidation(params);
+    }
     // Instrument with Suspense DevTools (dev-only)
     if (process.env.NODE_ENV !== 'production' && 'use' in _react.default) {
         const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
@@ -159,6 +176,11 @@ function useSelectedLayoutSegments(parallelRouteKey = 'children') {
     const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
     // @ts-expect-error This only happens in `pages`. Type is overwritten in navigation.d.ts
     if (!context) return null;
+    // During build-time instant validation, error if fallback params exist
+    // because useSelectedLayoutSegments() can't return a sensible value without all params.
+    if (typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS && context) {
+        expectCompleteParamsInClientValidation('useSelectedLayoutSegments()');
+    }
     // Instrument with Suspense DevTools (dev-only)
     if (process.env.NODE_ENV !== 'production' && 'use' in _react.default) {
         const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
@@ -177,6 +199,11 @@ function useSelectedLayoutSegment(parallelRouteKey = 'children') {
     useDynamicRouteParams?.('useSelectedLayoutSegment()');
     const navigationPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
     const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
+    // During build-time instant validation, error if fallback params exist
+    // because useSelectedLayoutSegment() can't return a sensible value without all params.
+    if (typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS) {
+        expectCompleteParamsInClientValidation('useSelectedLayoutSegment()');
+    }
     // Instrument with Suspense DevTools (dev-only)
     if (process.env.NODE_ENV !== 'production' && navigationPromises && 'use' in _react.default) {
         const promise = navigationPromises.selectedLayoutSegmentPromises?.get(parallelRouteKey);

package/standalone/node_modules/next/dist/client/components/navigation.react-server.js

@@ -24,7 +24,7 @@ _export(exports, {
         return _readonlyurlsearchparams.ReadonlyURLSearchParams;
     },
     RedirectType: function() {
-        return _redirecterror.RedirectType;
+        return RedirectType;
     },
     forbidden: function() {
         return _forbidden.forbidden;
@@ -50,7 +50,6 @@ _export(exports, {
 });
 const _readonlyurlsearchparams = require("./readonly-url-search-params");
 const _redirect = require("./redirect");
-const _redirecterror = require("./redirect-error");
 const _notfound = require("./not-found");
 const _forbidden = require("./forbidden");
 const _unauthorized = require("./unauthorized");
@@ -62,6 +61,10 @@ function unstable_isUnrecognizedActionError() {
         configurable: true
     });
 }
+const RedirectType = {
+    push: 'push',
+    replace: 'replace'
+};
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });

package/standalone/node_modules/next/dist/client/components/not-found.js

@@ -25,7 +25,7 @@ const _httpaccessfallback = require("./http-access-fallback/http-access-fallback
  */ const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};404`;
 function notFound() {
     const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
-        value: "E394",
+        value: "E1041",
         enumerable: false,
         configurable: true
     });

package/standalone/node_modules/next/dist/client/components/redirect-boundary.js

@@ -31,7 +31,7 @@ function HandleRedirect({ redirect, reset, redirectType }) {
     const router = (0, _navigation.useRouter)();
     (0, _react.useEffect)(()=>{
         _react.default.startTransition(()=>{
-            if (redirectType === _redirecterror.RedirectType.push) {
+            if (redirectType === 'push') {
                 router.push(redirect, {});
             } else {
                 router.replace(redirect, {});

package/standalone/node_modules/next/dist/client/components/redirect-error.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     REDIRECT_ERROR_CODE: null,
-    RedirectType: null,
     isRedirectError: null
 });
 function _export(target, all) {
@@ -17,20 +16,12 @@ _export(exports, {
     REDIRECT_ERROR_CODE: function() {
         return REDIRECT_ERROR_CODE;
     },
-    RedirectType: function() {
-        return RedirectType;
-    },
     isRedirectError: function() {
         return isRedirectError;
     }
 });
 const _redirectstatuscode = require("./redirect-status-code");
 const REDIRECT_ERROR_CODE = 'NEXT_REDIRECT';
-var RedirectType = /*#__PURE__*/ function(RedirectType) {
-    RedirectType["push"] = "push";
-    RedirectType["replace"] = "replace";
-    return RedirectType;
-}({});
 function isRedirectError(error) {
     if (typeof error !== 'object' || error === null || !('digest' in error) || typeof error.digest !== 'string') {
         return false;

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

@@ -49,10 +49,10 @@ function getRedirectError(url, type, statusCode = _redirectstatuscode.RedirectSt
     return error;
 }
 function redirect(/** The URL to redirect to */ url, type) {
-    type ??= actionAsyncStorage?.getStore()?.isAction ? _redirecterror.RedirectType.push : _redirecterror.RedirectType.replace;
+    type ??= actionAsyncStorage?.getStore()?.isAction ? 'push' : 'replace';
     throw getRedirectError(url, type, _redirectstatuscode.RedirectStatusCode.TemporaryRedirect);
 }
-function permanentRedirect(/** The URL to redirect to */ url, type = _redirecterror.RedirectType.replace) {
+function permanentRedirect(/** The URL to redirect to */ url, type = 'replace') {
     throw getRedirectError(url, type, _redirectstatuscode.RedirectStatusCode.PermanentRedirect);
 }
 function getURLFromRedirectError(error) {

package/standalone/node_modules/next/dist/client/components/router-reducer/compute-changed-path.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     computeChangedPath: null,
     extractPathFromFlightRouterState: null,
+    extractSourcePageFromFlightRouterState: null,
     getSelectedParams: null
 });
 function _export(target, all) {
@@ -20,6 +21,9 @@ _export(exports, {
     extractPathFromFlightRouterState: function() {
         return extractPathFromFlightRouterState;
     },
+    extractSourcePageFromFlightRouterState: function() {
+        return extractSourcePageFromFlightRouterState;
+    },
     getSelectedParams: function() {
         return getSelectedParams;
     }
@@ -39,6 +43,41 @@ const segmentToPathname = (segment)=>{
     }
     return segment[1];
 };
+const segmentToSourcePagePathname = (segment)=>{
+    if (typeof segment === 'string') {
+        if (segment === 'children') return '';
+        if (segment.startsWith(_segment.PAGE_SEGMENT_KEY)) return 'page';
+        return segment;
+    }
+    const [paramName, , dynamicParamType] = segment;
+    switch(dynamicParamType){
+        case 'c':
+            return `[...${paramName}]`;
+        case 'ci(..)(..)':
+            return `(..)(..)[...${paramName}]`;
+        case 'ci(.)':
+            return `(.)[...${paramName}]`;
+        case 'ci(..)':
+            return `(..)[...${paramName}]`;
+        case 'ci(...)':
+            return `(...)[...${paramName}]`;
+        case 'oc':
+            return `[[...${paramName}]]`;
+        case 'd':
+            return `[${paramName}]`;
+        case 'di(..)(..)':
+            return `(..)(..)[${paramName}]`;
+        case 'di(.)':
+            return `(.)[${paramName}]`;
+        case 'di(..)':
+            return `(..)[${paramName}]`;
+        case 'di(...)':
+            return `(...)[${paramName}]`;
+        default:
+            dynamicParamType;
+            return `[${paramName}]`;
+    }
+};
 function normalizeSegments(segments) {
     return segments.reduce((acc, segment)=>{
         segment = removeLeadingSlash(segment);
@@ -70,6 +109,40 @@ function extractPathFromFlightRouterState(flightRouterState) {
     }
     return normalizeSegments(segments);
 }
+function extractSourcePageSegmentsFromFlightRouterState(flightRouterState) {
+    const segment = segmentToSourcePagePathname(flightRouterState[0]);
+    if (segment === _segment.DEFAULT_SEGMENT_KEY) {
+        return undefined;
+    }
+    if (segment === 'page') {
+        return [
+            segment
+        ];
+    }
+    const parallelRoutes = flightRouterState[1] ?? {};
+    const childrenPath = parallelRoutes.children ? extractSourcePageSegmentsFromFlightRouterState(parallelRoutes.children) : undefined;
+    if (childrenPath !== undefined) {
+        return segment === '' ? childrenPath : [
+            removeLeadingSlash(segment),
+            ...childrenPath
+        ];
+    }
+    for (const [key, value] of Object.entries(parallelRoutes)){
+        if (key === 'children') continue;
+        const childPath = extractSourcePageSegmentsFromFlightRouterState(value);
+        if (childPath !== undefined) {
+            return segment === '' ? childPath : [
+                removeLeadingSlash(segment),
+                ...childPath
+            ];
+        }
+    }
+    return undefined;
+}
+function extractSourcePageFromFlightRouterState(flightRouterState) {
+    const sourcePageSegments = extractSourcePageSegmentsFromFlightRouterState(flightRouterState);
+    return sourcePageSegments ? `/${sourcePageSegments.join('/')}` : undefined;
+}
 function computeChangedPathImpl(treeA, treeB) {
     const [segmentA, parallelRoutesA] = treeA;
     const [segmentB, parallelRoutesB] = treeB;

package/standalone/node_modules/next/dist/client/components/router-reducer/create-initial-router-state.js

@@ -12,7 +12,13 @@ const _createhreffromurl = require("./create-href-from-url");
 const _computechangedpath = require("./compute-changed-path");
 const _flightdatahelpers = require("../../flight-data-helpers");
 const _pprnavigations = require("./ppr-navigations");
-function createInitialRouterState({ navigatedAt, initialFlightData, initialCanonicalUrlParts, initialRenderedSearch, location }) {
+const _cache = require("../segment-cache/cache");
+const _types = require("../segment-cache/types");
+const _bfcache = require("../segment-cache/bfcache");
+const _fetchserverresponse = require("./fetch-server-response");
+const _optimisticroutes = require("../segment-cache/optimistic-routes");
+function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFlightStreamForCache, location }) {
+    const { c: initialCanonicalUrlParts, f: initialFlightData, q: initialRenderedSearch, i: initialCouldBeIntercepted, S: initialSupportsPerSegmentPrefetching, s: initialStaleTime, l: initialStaticStageByteLength, h: initialHeadVaryParams, p: initialRuntimePrefetchStream, d: initialDynamicStaleTimeSeconds } = initialRSCPayload;
     // When initialized on the server, the canonical URL is provided as an array of parts.
     // This is to ensure that when the RSC payload streamed to the client, crawlers don't interpret it
     // as a URL that should be crawled.
@@ -24,9 +30,97 @@ function createInitialRouterState({ navigatedAt, initialFlightData, initialCanon
     const canonicalUrl = // location.href is read as the initial value for canonicalUrl in the browser
     // This is safe to do as canonicalUrl can't be rendered, it's only used to control the history updates in the useEffect further down in this file.
     location ? (0, _createhreffromurl.createHrefFromUrl)(location) : initialCanonicalUrl;
+    // Convert the initial FlightRouterState into the RouteTree type.
+    // NOTE: The metadataVaryPath isn't used for anything currently because the
+    // head is embedded into the CacheNode tree, but eventually we'll lift it out
+    // and store it on the top-level state object.
+    //
+    // TODO: For statically-generated-at-build-time HTML pages, the
+    // FlightRouterState baked into the initial RSC payload won't have the
+    // correct segment inlining hints (ParentInlinedIntoSelf, InlinedIntoChild)
+    // because those are computed after the pre-render. The client will need to
+    // fetch the correct hints from the route tree prefetch (/_tree) response
+    // before acting on inlining decisions.
+    const acc = {
+        metadataVaryPath: null
+    };
+    const initialRouteTree = (0, _cache.convertRootFlightRouterStateToRouteTree)(initialTree, initialRenderedSearch, acc);
+    const metadataVaryPath = acc.metadataVaryPath;
+    const initialTask = (0, _pprnavigations.createInitialCacheNodeForHydration)(navigatedAt, initialRouteTree, initialSeedData, initialHead, (0, _bfcache.computeDynamicStaleAt)(navigatedAt, initialDynamicStaleTimeSeconds ?? _bfcache.UnknownDynamicStaleTime));
+    // The following only applies in the browser (location !== null) since neither
+    // route learning nor segment cache state persists from SSR to client.
+    if (location !== null && metadataVaryPath !== null) {
+        // Learn the route pattern so we can predict it for future navigations.
+        (0, _optimisticroutes.discoverKnownRoute)(Date.now(), location.pathname, null, null, initialRouteTree, metadataVaryPath, initialCouldBeIntercepted, canonicalUrl, initialSupportsPerSegmentPrefetching, false // hasDynamicRewrite
+        );
+        // Write the initial seed data into the segment cache so subsequent
+        // navigations to the initial page can serve cached segments instantly.
+        if (initialSeedData !== null && initialStaleTime !== undefined) {
+            if (initialStaticStageByteLength !== undefined && initialFlightStreamForCache != null) {
+                // Partially static page — truncate the cloned Flight stream at the
+                // static stage byte boundary, decode, and cache the static subset.
+                (0, _fetchserverresponse.decodeStaticStage)(initialFlightStreamForCache, initialStaticStageByteLength, undefined).then(async (staticStageResponse)=>{
+                    const now = Date.now();
+                    const staleAt = await (0, _cache.getStaleAt)(now, staticStageResponse.s);
+                    (0, _cache.writeStaticStageResponseIntoCache)(now, staticStageResponse.f, undefined, staticStageResponse.h, staleAt, initialTree, initialRenderedSearch, true // isResponsePartial
+                    );
+                }).catch(()=>{
+                // The static stage processing failed. Not fatal — the page
+                // rendered normally, we just won't write into the cache.
+                });
+            } else {
+                // Fully static page — cache the entire decoded seed data as-is. We're
+                // not using the initial response here (which would allow us to combine
+                // the two branches) to avoid unnecessary decoding of the Flight data,
+                // since we can just take the seed data that we already decoded during
+                // hydration and write it into the cache directly.
+                const now = Date.now();
+                (0, _cache.getStaleAt)(now, initialStaleTime).then((staleAt)=>{
+                    (0, _cache.writeStaticStageResponseIntoCache)(now, initialFlightData, undefined, initialHeadVaryParams, staleAt, initialTree, initialRenderedSearch, false // isResponsePartial
+                    );
+                }).catch(()=>{
+                // The static stage processing failed. Not fatal — the page
+                // rendered normally, we just won't write into the cache.
+                });
+                // Cancel the stream clone — fully static path doesn't need it.
+                initialFlightStreamForCache?.cancel();
+            }
+        } else {
+            // No caching — cancel the unused stream clone.
+            initialFlightStreamForCache?.cancel();
+        }
+        // If the initial RSC payload includes an embedded runtime prefetch stream,
+        // decode it and write the runtime data into the segment cache. This allows
+        // subsequent navigations to serve runtime-prefetchable content from cache
+        // without a separate prefetch request.
+        if (initialRuntimePrefetchStream != null) {
+            (0, _cache.processRuntimePrefetchStream)(Date.now(), initialRuntimePrefetchStream, initialTree, initialRenderedSearch).then((processed)=>{
+                if (processed !== null) {
+                    (0, _cache.writeDynamicRenderResponseIntoCache)(Date.now(), _types.FetchStrategy.PPRRuntime, processed.flightDatas, processed.buildId, processed.isResponsePartial, processed.headVaryParams, processed.staleAt, processed.navigationSeed, null);
+                }
+            }).catch(()=>{
+            // Runtime prefetch cache write failed. Not fatal — the page rendered
+            // normally, we just won't cache runtime data.
+            });
+        }
+    }
+    // NOTE: We intentionally don't check if any data needs to be fetched from the
+    // server. We assume the initial hydration payload is sufficient to render
+    // the page.
+    //
+    // The completeness of the initial data is an important property that we rely
+    // on as a last-ditch mechanism for recovering the app; we must always be able
+    // to reload a fresh HTML document to get to a consistent state.
+    //
+    // In the future, there may be cases where the server intentionally sends
+    // partial data and expects the client to fill in the rest, in which case this
+    // logic may change. (There already is a similar case where the server sends
+    // _no_ hydration data in the HTML document at all, and the client fetches it
+    // separately, but that's different because we still end up hydrating with a
+    // complete tree.)
     const initialState = {
-        tree: initialTree,
-        cache: (0, _pprnavigations.createInitialCacheNodeForHydration)(navigatedAt, initialTree, initialSeedData, initialHead),
+        tree: initialTask.route,
+        cache: initialTask.node,
         pushRef: {
             pendingPush: false,
             mpaNavigation: false,
@@ -35,15 +129,15 @@ function createInitialRouterState({ navigatedAt, initialFlightData, initialCanon
             preserveCustomHistoryState: true
         },
         focusAndScrollRef: {
-            apply: false,
+            scrollRef: null,
+            forceScroll: false,
             onlyHashChange: false,
-            hashFragment: null,
-            segmentPaths: []
+            hashFragment: null
         },
         canonicalUrl,
         renderedSearch: initialRenderedSearch,
-        nextUrl: // the || operator is intentional, the pathname can be an empty string
-        ((0, _computechangedpath.extractPathFromFlightRouterState)(initialTree) || location?.pathname) ?? null,
+        // the || operator is intentional, the pathname can be an empty string
+        nextUrl: ((0, _computechangedpath.extractPathFromFlightRouterState)(initialTree) || location?.pathname) ?? null,
         previousNextUrl: null,
         debugInfo: null
     };