failproofai 1.0.11-beta.1 → 1.0.11-beta.2

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

@@ -34,7 +34,6 @@ _export(exports, {
 });
 const _interceptionroutes = require("../../../shared/lib/router/utils/interception-routes");
 const _segment = require("../../../shared/lib/segment");
-const _matchsegments = require("../match-segments");
 const removeLeadingSlash = (segment)=>{
     return segment[0] === '/' ? segment.slice(1) : segment;
 };
@@ -50,7 +49,7 @@ const segmentToPathname = (segment)=>{
 const segmentToSourcePagePathname = (segment)=>{
     if (typeof segment === 'string') {
         if (segment === 'children') return '';
-        if (segment.startsWith(_segment.PAGE_SEGMENT_KEY)) return 'page';
+        if (segment === _segment.PAGE_SEGMENT_KEY) return 'page';
         return segment;
     }
     const [paramName, , dynamicParamType] = segment;
@@ -94,7 +93,7 @@ function normalizeSegments(segments) {
 function extractPathFromFlightRouterState(flightRouterState) {
     const segment = Array.isArray(flightRouterState[0]) ? flightRouterState[0][1] : flightRouterState[0];
     if (segment === _segment.DEFAULT_SEGMENT_KEY || _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m)=>segment.startsWith(m))) return undefined;
-    if (segment.startsWith(_segment.PAGE_SEGMENT_KEY)) return '';
+    if (segment === _segment.PAGE_SEGMENT_KEY) return '';
     const segments = [
         segmentToPathname(segment)
     ];
@@ -155,7 +154,16 @@ function computeChangedPathImpl(treeA, treeB) {
     if (_interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m)=>normalizedSegmentA.startsWith(m) || normalizedSegmentB.startsWith(m))) {
         return '';
     }
-    if (!(0, _matchsegments.matchSegment)(segmentA, segmentB)) {
+    // Param types and static sibling hints don't affect the resulting pathname,
+    // so only compare the segment name and param value.
+    // TODO: computeChangedPath is only used to compute the Next-Url header.
+    // We should refactor this data structure to be lower cardinality. For example
+    // it doesn't need to include any of the concrete param values, just the
+    // route structure.
+    const didPathChange = typeof segmentA === 'string' || typeof segmentB === 'string' ? segmentA !== segmentB : segmentA[0] !== segmentB[0] || segmentA[1] !== segmentB[1];
+    if (didPathChange || // A change to the page's search params counts, too. (They used to be part
+    // of the page segment string.)
+    segmentA === _segment.PAGE_SEGMENT_KEY && treeA[5] !== treeB[5]) {
         // once we find where the tree changed, we compute the rest of the path by traversing the tree
         return extractPathFromFlightRouterState(treeB) ?? '';
     }
@@ -183,7 +191,7 @@ function getSelectedParams(currentTree, params = {}) {
         const segment = parallelRoute[0];
         const isDynamicParameter = Array.isArray(segment);
         const segmentValue = isDynamicParameter ? segment[1] : segment;
-        if (!segmentValue || segmentValue.startsWith(_segment.PAGE_SEGMENT_KEY)) continue;
+        if (!segmentValue || segmentValue === _segment.PAGE_SEGMENT_KEY) continue;
         // Ensure catchAll and optional catchall are turned into an array
         const isCatchAll = isDynamicParameter && (segment[2] === 'c' || segment[2] === 'oc');
         if (isCatchAll) {

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

@@ -10,85 +10,102 @@ Object.defineProperty(exports, "createInitialRouterState", {
 });
 const _createhreffromurl = require("./create-href-from-url");
 const _computechangedpath = require("./compute-changed-path");
-const _flightdatahelpers = require("../../flight-data-helpers");
-const _pprnavigations = require("./ppr-navigations");
+const _rsctransport = require("../../../shared/lib/rsc-transport");
+const _rendertree = require("../render-tree");
 const _cache = require("../segment-cache/cache");
-const _types = require("../segment-cache/types");
+const _decodeserverresponse = require("../segment-cache/decode-server-response");
 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, r: initialRootVaryParams, p: initialRuntimePrefetchStream, d: initialDynamicStaleTimeSeconds } = initialRSCPayload;
+    const { c: initialCanonicalUrlParts, t: initialTransportData, q: initialRenderedSearch, i: initialCouldBeIntercepted, S: initialSupportsPerSegmentPrefetching, s: initialStaleTime, l: initialStaticStageByteLength, r: initialRootVaryParams, 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.
     const initialCanonicalUrl = initialCanonicalUrlParts.join('/');
-    const normalizedFlightData = (0, _flightdatahelpers.getFlightDataPartsFromPath)(initialFlightData[0]);
-    const { tree: initialTree, seedData: initialSeedData, head: initialHead } = normalizedFlightData;
-    // For the SSR render, seed data should always be available (we only send back a `null` response
-    // in the case of a `loading` segment, pre-PPR.)
+    // The initial router state tree, derived from the transport tree.
+    const initialTree = (0, _rsctransport.transportNodeToFlightRouterState)(initialTransportData.t, initialRenderedSearch);
     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.
+    // Decode the initial transport data into the RouteTree type, with the
+    // payload's render output embedded on each node and the head as its own
+    // one-node tree. (discoverKnownRoute below stores the route tree in the
+    // route cache, which strips the data on write — see stripDataFromRouteTree.)
     //
-    // For statically-generated-at-build-time HTML pages, the FlightRouterState
-    // baked into the initial RSC payload won't have the correct segment inlining
-    // hints because those are computed after the pre-render. The server marks
-    // these trees with InliningHintsStale, which causes the route cache entry
-    // to be immediately expired. The next prefetch will re-fetch the tree with
+    // For statically-generated-at-build-time HTML pages, the tree baked into
+    // the initial RSC payload won't have the correct segment inlining hints
+    // because those are computed after the pre-render. The server marks these
+    // trees with InliningHintsStale, which causes the route cache entry to be
+    // immediately expired. The next prefetch will re-fetch the tree with
     // correct hints from the /_tree response.
-    const acc = {
-        metadataVaryPath: null,
-        treeDivergedFromBase: false
-    };
-    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));
+    const initialSeed = (0, _decodeserverresponse.createNavigationSeed)(navigatedAt, // There's no base tree to overlay onto; the initial payload is a full
+    // render from the root.
+    null, initialTransportData, // The initial payload may still be streaming in while we hydrate, so its
+    // vary params can't be drained here; they decode as null. The
+    // segment-cache write below re-decodes the transport data with the
+    // payload's root params once the stale time has resolved.
+    null, // Same for partiality: only segment-cache writes consume it, and the
+    // write below re-decodes with the payload's actual response-level value.
+    // Pass the conservative value here.
+    true, // The initial payload always includes the param values in the tree
+    // (fallback shells are patched with the parsed values before this runs —
+    // see createInitialRSCPayloadFromFallbackPrerender), so there's no
+    // pathname to parse them from.
+    null, initialRenderedSearch, null, initialDynamicStaleTimeSeconds ?? _bfcache.UnknownDynamicStaleTime);
+    const initialRoot = initialSeed.root;
+    const initialNavigation = (0, _rendertree.createInitialRenderTreeForHydration)(navigatedAt, initialRoot, initialSeed.dynamicStaleAt);
     // 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) {
+    if (location !== null) {
         // Learn the route pattern so we can predict it for future navigations.
-        (0, _optimisticroutes.discoverKnownRoute)(Date.now(), location.pathname, location.search, null, null, initialRouteTree, metadataVaryPath, initialCouldBeIntercepted, canonicalUrl, initialSupportsPerSegmentPrefetching, false // hasDynamicRewrite
+        (0, _optimisticroutes.discoverKnownRoute)(Date.now(), location.pathname, location.search, null, null, initialRoot, initialCouldBeIntercepted, canonicalUrl, initialSeed.renderedSearch, initialSupportsPerSegmentPrefetching, false // hasDynamicRewrite
         );
         // TODO: Implement Shell extraction as part of Cached Navigations.
         // Intentionally holding off on doing this until we decide how the Cached
         // Navigations behavior should work in combination with App Shells.
-        // 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) {
+        // Write the initial payload's segment data into the segment cache so
+        // subsequent navigations to the initial page can serve cached
+        // segments instantly.
+        if (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.
                 // Promise.resolve wraps the Flight-deserialized thenable into a
                 // native Promise so we can chain `.then` on it safely.
                 Promise.resolve(initialStaticStageByteLength).then(async (byteLength)=>{
+                    if (byteLength === 0) {
+                        initialFlightStreamForCache.cancel();
+                        return;
+                    }
                     const staticStageResponse = await (0, _fetchserverresponse.decodeStageUntilBoundary)(initialFlightStreamForCache, byteLength, undefined);
-                    const now = Date.now();
-                    const staleAt = await (0, _cache.resolveStaleAt)(now, staticStageResponse.s);
-                    (0, _cache.writePrerenderResponseIntoCache)(now, _types.FetchStrategy.PPR, staticStageResponse.f, undefined, staticStageResponse.h, staticStageResponse.r ?? null, staleAt, initialTree, initialRenderedSearch, true, _cache // hydration writes are bound to the shared map
+                    if (staticStageResponse === null) {
+                        return;
+                    }
+                    (0, _cache.spawnStaticStageCacheWrite)(Date.now(), staticStageResponse, true, null, initialTree, initialRenderedSearch, _cache // hydration writes are bound to the shared map
                     .segmentCacheMap);
                 }).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.resolveStaleAt)(now, initialStaleTime).then((staleAt)=>{
-                    (0, _cache.writePrerenderResponseIntoCache)(now, _types.FetchStrategy.PPR, initialFlightData, undefined, initialHeadVaryParams, initialRootVaryParams ?? null, staleAt, initialTree, initialRenderedSearch, false, _cache // hydration writes are bound to the shared map
-                    .segmentCacheMap);
-                }).catch(()=>{
-                // The static stage processing failed. Not fatal — the page
-                // rendered normally, we just won't write into the cache.
-                });
+                // Fully static page — cache the initial payload's segment 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 segment data that we
+                // already decoded during hydration and write it into the
+                // cache directly.
+                (0, _cache.spawnStaticStageCacheWrite)(Date.now(), // The transport subset of the initial payload, already decoded
+                // during hydration. `u` (the runtime-data verdict) is deliberately
+                // omitted from this synthesized subset — its writes record their
+                // strategy unrefined — while the truncated branch above forwards
+                // the decoded payload's own `u`.
+                {
+                    t: initialTransportData,
+                    r: initialRootVaryParams,
+                    s: initialStaleTime
+                }, false, null, initialTree, initialRenderedSearch, _cache // hydration writes are bound to the shared map
+                .segmentCacheMap);
                 // Cancel the stream clone — fully static path doesn't need it.
                 initialFlightStreamForCache?.cancel();
             }
@@ -101,12 +118,8 @@ function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFligh
         // 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.rootVaryParamsIterable, processed.staleAt, processed.navigationSeed, null, _cache // hydration writes are bound to the shared map
-                    .segmentCacheMap);
-                }
-            }).catch(()=>{
+            (0, _cache.writeRuntimePrefetchStreamIntoCache)(Date.now(), initialRuntimePrefetchStream, initialTree, initialRenderedSearch, _cache // hydration writes are bound to the shared map
+            .segmentCacheMap).catch(()=>{
             // Runtime prefetch cache write failed. Not fatal — the page rendered
             // normally, we just won't cache runtime data.
             });
@@ -127,8 +140,8 @@ function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFligh
     // separately, but that's different because we still end up hydrating with a
     // complete tree.)
     const initialState = {
-        tree: initialTask.route,
-        cache: initialTask.node,
+        tree: initialNavigation.tree.route,
+        root: (0, _cache.createRootRouteTree)(initialNavigation.tree.node, initialNavigation.head.node),
         pushRef: {
             pendingPush: false,
             mpaNavigation: false,
@@ -136,7 +149,7 @@ function createInitialRouterState({ navigatedAt, initialRSCPayload, initialFligh
             // to avoid it being overwritten on navigation back/forward with MPA Navigation.
             preserveCustomHistoryState: true
         },
-        focusAndScrollRef: {
+        scrollRef: {
             scrollRef: null,
             forceScroll: false,
             onlyHashChange: false,

package/.next/standalone/node_modules/next/dist/client/components/router-reducer/create-router-cache-key.js

@@ -8,18 +8,12 @@ Object.defineProperty(exports, "createRouterCacheKey", {
         return createRouterCacheKey;
     }
 });
-const _segment = require("../../../shared/lib/segment");
-function createRouterCacheKey(segment, withoutSearchParameters = false) {
+function createRouterCacheKey(segment) {
     // if the segment is an array, it means it's a dynamic segment
     // for example, ['lang', 'en', 'd']. We need to convert it to a string to store it as a cache node key.
     if (Array.isArray(segment)) {
         return `${segment[0]}|${segment[1]}|${segment[2]}`;
     }
-    // Page segments might have search parameters, ie __PAGE__?foo=bar
-    // When `withoutSearchParameters` is true, we only want to return the page segment
-    if (withoutSearchParameters && segment.startsWith(_segment.PAGE_SEGMENT_KEY)) {
-        return _segment.PAGE_SEGMENT_KEY;
-    }
     return segment;
 }
 

package/.next/standalone/node_modules/next/dist/client/components/router-reducer/create-segment-key.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createHeadKey: null,
+    createSegmentKey: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createHeadKey: function() {
+        return createHeadKey;
+    },
+    createSegmentKey: function() {
+        return createSegmentKey;
+    }
+});
+const _createroutercachekey = require("./create-router-cache-key");
+function createSegmentKey(segment) {
+    if (Array.isArray(segment)) {
+        return `${segment[0]}|${segment[2]}`;
+    }
+    return (0, _createroutercachekey.createRouterCacheKey)(segment);
+}
+function createHeadKey(varyPath) {
+    // The head's vary path starts with its request key: the route structure,
+    // with param names but no values.
+    return varyPath.value;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=create-segment-key.js.map

package/.next/standalone/node_modules/next/dist/client/components/router-reducer/fetch-server-response.js

@@ -10,8 +10,7 @@ Object.defineProperty(exports, "__esModule", {
     decodeStageUntilBoundary: null,
     fetchServerResponse: null,
     processFetch: null,
-    resolveShellStageData: null,
-    resolveStaticStageData: null
+    resolveShellStageResponse: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -38,11 +37,8 @@ _export(exports, {
     processFetch: function() {
         return processFetch;
     },
-    resolveShellStageData: function() {
-        return resolveShellStageData;
-    },
-    resolveStaticStageData: function() {
-        return resolveStaticStageData;
+    resolveShellStageResponse: function() {
+        return resolveShellStageResponse;
     }
 });
 const _client = require("react-server-dom-webpack/client");
@@ -113,12 +109,12 @@ async function fetchServerResponse(url, options) {
                 }
             }
         }
-        // Typically, during a navigation, we decode the response using Flight's
-        // `createFromFetch` API, which accepts a `fetch` promise.
-        // TODO: Remove this check once the old PPR flag is removed
-        const isLegacyPPR = process.env.__NEXT_PPR && !process.env.__NEXT_CACHE_COMPONENTS;
-        const shouldImmediatelyDecode = !isLegacyPPR;
-        const res = await createFetch(url, headers, 'auto', shouldImmediatelyDecode, options.signal);
+        // During a navigation, we decode the response using Flight's
+        // `createFromFetch` API, which accepts a `fetch` promise. Navigations
+        // only ever receive live-render responses (per-segment prefetch
+        // responses, which omit some fields, are decoded by the segment cache
+        // instead), so the decode is typed as the live-render variant.
+        const res = await createFetch(url, headers, 'auto', true, options.signal);
         // If the fetch succeeds while we're in the offline state, notify the
         // offline module so it can short-circuit the polling loop.
         if (process.env.__NEXT_USE_OFFLINE) {
@@ -157,17 +153,9 @@ async function fetchServerResponse(url, options) {
         if (process.env.NODE_ENV !== 'production' && !process.env.TURBOPACK) {
             await require('../../dev/hot-reloader/app/hot-reloader-app').waitForWebpackRuntimeHotUpdate();
         }
-        let flightResponsePromise = res.flightResponsePromise;
-        if (flightResponsePromise === null) {
-            // Typically, `createFetch` would have already started decoding the
-            // Flight response. If it hasn't, though, we need to decode it now.
-            // TODO: This should only be reachable if legacy PPR is enabled (i.e. PPR
-            // without Cache Components). Remove this branch once legacy PPR
-            // is deleted.
-            flightResponsePromise = createFromNextReadableStream(res.body, headers, {
-                allowPartialStream: postponed
-            });
-        }
+        // This request passed `true` to `shouldImmediatelyDecode`, so the Flight
+        // response promise is always initialized.
+        const flightResponsePromise = res.flightResponsePromise;
         const [flightResponse, cacheData] = await Promise.all([
             flightResponsePromise,
             res.cacheData
@@ -176,13 +164,14 @@ async function fetchServerResponse(url, options) {
             // The server build does not match the client build.
             return doMpaNavigation(res.url);
         }
-        const normalizedFlightData = (0, _flightdatahelpers.normalizeFlightData)(flightResponse.f);
-        if (typeof normalizedFlightData === 'string') {
-            return doMpaNavigation(normalizedFlightData);
+        if (flightResponse.n !== undefined) {
+            // The server responded with an MPA navigation URL instead of a
+            // SPA payload.
+            return doMpaNavigation(flightResponse.n);
         }
-        const staticStageData = cacheData !== null ? await resolveStaticStageData(cacheData, flightResponse, headers) : null;
+        const staticStageResponse = cacheData !== null ? await resolveStaticStageResponse(cacheData, flightResponse, headers) : null;
         return {
-            flightData: normalizedFlightData,
+            transportData: flightResponse.t ?? null,
             canonicalUrl: canonicalUrl,
             // TODO: We should be able to read this from the rewrite header, not the
             // Flight response. Theoretically they should always agree, but there are
@@ -200,7 +189,8 @@ async function fetchServerResponse(url, options) {
             // When absent (UnknownDynamicStaleTime), the client falls back to the
             // global DYNAMIC_STALETIME_MS. The value is in seconds.
             dynamicStaleTime: flightResponse.d ?? _bfcache.UnknownDynamicStaleTime,
-            staticStageData,
+            isResponsePartial: cacheData !== null ? cacheData.isResponsePartial : false,
+            staticStageResponse,
             runtimePrefetchStream: flightResponse.p ?? null,
             responseHeaders: res.headers,
             debugInfo: flightResponsePromise._debugInfo ?? null,
@@ -245,11 +235,7 @@ async function fetchServerResponse(url, options) {
 async function processFetch(response) {
     if (process.env.__NEXT_CACHE_COMPONENTS) {
         if (!response.body) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('Expected RSC navigation response to have a body'), "__NEXT_ERROR_CODE", {
-                value: "E1088",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('Expected RSC navigation response to have a body');
         }
         const { stream, isPartial } = await (0, _cache.stripIsPartialByte)(response.body);
         let responseStream;
@@ -295,52 +281,87 @@ async function processFetch(response) {
         cacheData: null
     };
 }
-async function resolveStaticStageData(cacheData, flightResponse, headers) {
+/**
+ * Resolves the static stage response from the raw `processFetch` outputs and
+ * the decoded flight response, for writing into the segment cache. The
+ * resolved response's partiality is the whole response's partiality
+ * (`cacheData.isResponsePartial`): a complete response is resolved whole, a
+ * partial one as its truncated static-stage prefix.
+ *
+ * - Fully static: use the decoded flight response as-is, no truncation needed.
+ * - Not fully static + `l` field: truncate the body clone at the static stage
+ *   byte boundary and decode.
+ * - Otherwise: no cache-worthy data.
+ */ async function resolveStaticStageResponse(cacheData, flightResponse, headers) {
     const { isResponsePartial, staticBodyClone } = cacheData;
     if (staticBodyClone) {
         if (!isResponsePartial) {
             // Fully static — cache the entire decoded response as-is.
             staticBodyClone.cancel();
-            return {
-                response: flightResponse,
-                isResponsePartial: false
-            };
+            return flightResponse;
         }
         if (flightResponse.l !== undefined) {
             // Partially static — truncate the body clone at the byte boundary and
             // decode it.
             const staticStageByteLength = await flightResponse.l;
-            const response = await decodeStageUntilBoundary(staticBodyClone, staticStageByteLength, headers);
-            return {
-                response,
-                isResponsePartial: true
-            };
+            if (staticStageByteLength === 0) {
+                staticBodyClone.cancel();
+                return null;
+            }
+            return decodeStageUntilBoundary(staticBodyClone, staticStageByteLength, headers);
         }
         // No caching — cancel the unused clone.
         staticBodyClone.cancel();
     }
     return null;
 }
-async function resolveShellStageData(cacheData, flightResponse, headers) {
+async function resolveShellStageResponse(cacheData, flightResponse, headers) {
     const { shellBodyClone } = cacheData;
     if (!shellBodyClone) {
         return null;
     }
     if (flightResponse.a === undefined) {
+        // The render wasn't staged — no shell exists.
         shellBodyClone.cancel();
         return null;
     }
     const shellByteLength = await flightResponse.a;
-    if (shellByteLength === null) {
-        // Shell == main response — caller reuses the existing flightResponse.
+    if (shellByteLength === 0) {
         shellBodyClone.cancel();
         return null;
     }
+    if (shellByteLength === null) {
+        // The shell IS the full response (no shell/full split). Return the full
+        // response itself — callers detect this case by reference equality —
+        // rather than collapsing it into null, which would lose the distinction
+        // from "no shell exists". This mirrors the convention of the per-segment
+        // prefetch fetch (see fetchAndWritePerSegmentPrefetchResponse in cache.ts).
+        shellBodyClone.cancel();
+        return flightResponse;
+    }
     return decodeStageUntilBoundary(shellBodyClone, shellByteLength, headers);
 }
 async function decodeStageUntilBoundary(responseBodyClone, byteLength, headers) {
-    const { buffer } = await (0, _cache.createNonTaskyPrefetchResponseStream)(responseBodyClone, byteLength);
-    return decodeBufferedStage(buffer, headers);
+    try {
+        const buffer = await (0, _cache.bufferPrefetchResponseBody)(responseBodyClone, byteLength);
+        const response = decodeBufferedStage(buffer, headers);
+        // The caller already has the full response root, but this prefix may omit
+        // rows that the root needs. Bound this optional extraction so it cannot
+        // hold up the full response. This deadline applies to the outer root, not
+        // to Client Components that continue loading through lazy references.
+        return await new Promise((resolve)=>{
+            const timeout = setTimeout(()=>resolve(null), 0);
+            response.then((root)=>{
+                clearTimeout(timeout);
+                resolve(root);
+            }, ()=>{
+                clearTimeout(timeout);
+                resolve(null);
+            });
+        });
+    } catch  {
+        return null;
+    }
 }
 function decodeBufferedStage(buffer, headers) {
     const stream = new ReadableStream({

package/.next/standalone/node_modules/next/dist/client/components/router-reducer/is-navigating-to-new-root-layout.js

@@ -19,7 +19,7 @@ function isNavigatingToNewRootLayout(currentTree, nextTree) {
     // layout prefixes are structurally identical — same segments (ignoring
     // dynamic param *values*) for the same depth. So we walk the prefix in
     // lockstep and report a change as soon as the prefixes diverge.
-    const currentInPrefix = ((currentTree[4] ?? 0) & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0;
+    const currentInPrefix = (currentTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0;
     const nextInPrefix = (nextTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayoutOrAbove) !== 0;
     // Both trees have descended past the root layout with everything above
     // matching — same root layout.
@@ -37,7 +37,7 @@ function isNavigatingToNewRootLayout(currentTree, nextTree) {
     // (e.g. /[name] for slug1 vs slug2) still resolve to the same /[name]/layout.
     // E.g. /same/(group1)/layout.js -> /same/(group2)/layout.js: (group1) changed
     // to (group2) inside the prefix, so the root layout changed.
-    const currentTreeSegment = currentTree[0];
+    const currentTreeSegment = currentTree.segment;
     const nextTreeSegment = nextTree.segment;
     if (Array.isArray(currentTreeSegment) && Array.isArray(nextTreeSegment)) {
         if (currentTreeSegment[0] !== nextTreeSegment[0] || currentTreeSegment[2] !== nextTreeSegment[2]) {
@@ -49,10 +49,10 @@ function isNavigatingToNewRootLayout(currentTree, nextTree) {
     // Keep walking the prefix. (Above the root layout there is only a `children`
     // slot, but we traverse all slots defensively.)
     const slots = nextTree.slots;
-    const currentTreeChildren = currentTree[1];
+    const currentTreeChildren = currentTree.slots;
     if (slots !== null) {
         for (const [slot, nextTreeChild] of slots){
-            const currentTreeChild = currentTreeChildren[slot];
+            const currentTreeChild = currentTreeChildren?.get(slot);
             if (currentTreeChild === undefined || isNavigatingToNewRootLayout(currentTreeChild, nextTreeChild)) {
                 return true;
             }

package/.next/standalone/node_modules/next/dist/client/components/router-reducer/reducers/hmr-refresh-reducer.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "hmrRefreshReducer", {
     }
 });
 const _refreshreducer = require("./refresh-reducer");
-const _pprnavigations = require("../ppr-navigations");
+const _rendertree = require("../../render-tree");
 function hmrRefreshReducer(state, action) {
     // HMR actions may wait behind a Server Action in the router queue. If a newer
     // generation superseded this one before it started, don't install a refresh
@@ -17,7 +17,7 @@ function hmrRefreshReducer(state, action) {
     if (action.signal?.aborted) {
         return state;
     }
-    return (0, _refreshreducer.refreshDynamicData)(state, _pprnavigations.FreshnessPolicy.HMRRefresh, action.signal);
+    return (0, _refreshreducer.refreshDynamicData)(state, _rendertree.FreshnessPolicy.HMRRefresh, action.signal);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

package/.next/standalone/node_modules/next/dist/client/components/router-reducer/reducers/navigate-reducer.js

@@ -24,27 +24,27 @@ _export(exports, {
         return navigateReducer;
     }
 });
-const _navigation = require("../../segment-cache/navigation");
+const _approuterstate = require("../../app-router-state");
 const _cache = require("../../segment-cache/cache");
-const _pprnavigations = require("../ppr-navigations");
+const _rendertree = require("../../render-tree");
 const DYNAMIC_STALETIME_MS = Number(process.env.__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME) * 1000;
 const STATIC_STALETIME_MS = (0, _cache.getStaleTimeMs)(Number(process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME));
 function navigateReducer(state, action) {
     const { url, isExternalUrl, navigateType, scrollBehavior } = action;
     if (isExternalUrl) {
-        return (0, _navigation.completeHardNavigation)(state, url, navigateType);
+        return (0, _approuterstate.completeHardNavigation)(state, url, navigateType);
     }
     // Handles case where `<meta http-equiv="refresh">` tag is present,
     // which will trigger an MPA navigation.
     if (document.getElementById('__next-page-redirect')) {
-        return (0, _navigation.completeHardNavigation)(state, url, navigateType);
+        return (0, _approuterstate.completeHardNavigation)(state, url, navigateType);
     }
     // Temporary glue code between the router reducer and the new navigation
     // implementation. Eventually we'll rewrite the router reducer to a
     // state machine.
     const currentUrl = new URL(state.canonicalUrl, location.origin);
     const currentRenderedSearch = state.renderedSearch;
-    return (0, _navigation.navigate)(state, url, currentUrl, currentRenderedSearch, state.cache, state.tree, state.nextUrl, _pprnavigations.FreshnessPolicy.Default, scrollBehavior, navigateType);
+    return (0, _approuterstate.navigate)(state, url, currentUrl, currentRenderedSearch, state.root, state.tree, state.nextUrl, _rendertree.FreshnessPolicy.Default, scrollBehavior, navigateType);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {