@claudeye/linux-arm64 1.0.6-beta.1 → 1.0.6-beta.3

package/assets/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/assets/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
     };

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

@@ -6,7 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     createFetch: null,
     createFromNextReadableStream: null,
-    fetchServerResponse: null
+    decodeStaticStage: null,
+    fetchServerResponse: null,
+    processFetch: null,
+    resolveStaticStageData: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -21,23 +24,36 @@ _export(exports, {
     createFromNextReadableStream: function() {
         return createFromNextReadableStream;
     },
+    decodeStaticStage: function() {
+        return decodeStaticStage;
+    },
     fetchServerResponse: function() {
         return fetchServerResponse;
+    },
+    processFetch: function() {
+        return processFetch;
+    },
+    resolveStaticStageData: function() {
+        return resolveStaticStageData;
     }
 });
 const _client = require("react-server-dom-webpack/client");
+const _invarianterror = require("../../../shared/lib/invariant-error");
 const _approuterheaders = require("../app-router-headers");
 const _appcallserver = require("../../app-call-server");
 const _appfindsourcemapurl = require("../../app-find-source-map-url");
 const _flightdatahelpers = require("../../flight-data-helpers");
-const _appbuildid = require("../../app-build-id");
 const _setcachebustingsearchparam = require("./set-cache-busting-search-param");
 const _routeparams = require("../../route-params");
 const _deploymentid = require("../../../shared/lib/deployment-id");
+const _navigationbuildid = require("../../navigation-build-id");
+const _constants = require("../../../lib/constants");
+const _cache = require("../segment-cache/cache");
+const _bfcache = require("../segment-cache/bfcache");
 const createFromReadableStream = _client.createFromReadableStream;
 const createFromFetch = _client.createFromFetch;
 let createDebugChannel;
-if (process.env.NODE_ENV !== 'production' && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
+if (process.env.__NEXT_DEV_SERVER && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
     createDebugChannel = require('../../dev/debug-channel').createDebugChannel;
 }
 function doMpaNavigation(url) {
@@ -99,8 +115,6 @@ async function fetchServerResponse(url, options) {
         const contentType = res.headers.get('content-type') || '';
         const interception = !!res.headers.get('vary')?.includes(_approuterheaders.NEXT_URL);
         const postponed = !!res.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER);
-        const staleTimeHeaderSeconds = res.headers.get(_approuterheaders.NEXT_ROUTER_STALE_TIME_HEADER);
-        const staleTime = staleTimeHeaderSeconds !== null ? parseInt(staleTimeHeaderSeconds, 10) * 1000 : -1;
         let isFlightResponse = contentType.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER);
         if (process.env.NODE_ENV === 'production') {
             if (process.env.__NEXT_CONFIG_OUTPUT === 'export') {
@@ -128,32 +142,52 @@ 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.flightResponse;
+        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.
-            const flightStream = postponed ? createUnclosingPrefetchStream(res.body) : res.body;
-            flightResponsePromise = createFromNextReadableStream(flightStream, headers);
+            flightResponsePromise = createFromNextReadableStream(res.body, headers, {
+                allowPartialStream: postponed
+            });
         }
-        const flightResponse = await flightResponsePromise;
-        if ((0, _appbuildid.getAppBuildId)() !== flightResponse.b) {
+        const [flightResponse, cacheData] = await Promise.all([
+            flightResponsePromise,
+            res.cacheData
+        ]);
+        if ((res.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? flightResponse.b) !== (0, _navigationbuildid.getNavigationBuildId)()) {
+            // 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);
         }
+        const staticStageData = cacheData !== null ? await resolveStaticStageData(cacheData, flightResponse, headers) : null;
         return {
             flightData: normalizedFlightData,
             canonicalUrl: canonicalUrl,
-            renderedSearch: (0, _routeparams.getRenderedSearch)(res),
+            // TODO: We should be able to read this from the rewrite header, not the
+            // Flight response. Theoretically they should always agree, but there are
+            // currently some cases where it's incorrect for interception routes. We
+            // can always trust the value in the response body. However, per-segment
+            // prefetch responses don't embed the value in the body; they rely on the
+            // header alone. So we need to investigate why the header is sometimes
+            // wrong for interception routes.
+            renderedSearch: flightResponse.q,
             couldBeIntercepted: interception,
-            prerendered: flightResponse.S,
+            supportsPerSegmentPrefetching: flightResponse.S,
             postponed,
-            staleTime,
+            // The dynamicStaleTime is only present in the response body when
+            // a page exports unstable_dynamicStaleTime and this is a dynamic render.
+            // When absent (UnknownDynamicStaleTime), the client falls back to the
+            // global DYNAMIC_STALETIME_MS. The value is in seconds.
+            dynamicStaleTime: flightResponse.d ?? _bfcache.UnknownDynamicStaleTime,
+            staticStageData,
+            runtimePrefetchStream: flightResponse.p ?? null,
+            responseHeaders: res.headers,
             debugInfo: flightResponsePromise._debugInfo ?? null
         };
     } catch (err) {
@@ -166,6 +200,87 @@ async function fetchServerResponse(url, options) {
         return originalUrl.toString();
     }
 }
+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
+            });
+        }
+        const { stream, isPartial } = await (0, _cache.stripIsPartialByte)(response.body);
+        let responseStream;
+        let cacheData;
+        if (process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS) {
+            const [stream1, stream2] = stream.tee();
+            responseStream = stream1;
+            cacheData = {
+                isResponsePartial: isPartial,
+                responseBodyClone: stream2
+            };
+        } else {
+            responseStream = stream;
+            cacheData = {
+                isResponsePartial: isPartial
+            };
+        }
+        const strippedResponse = new Response(responseStream, {
+            headers: response.headers,
+            status: response.status,
+            statusText: response.statusText
+        });
+        // The Response constructor doesn't preserve `url` or `redirected` from
+        // the original. We need both: `url` for React DevTools and `redirected`
+        // for the redirect replay logic below.
+        Object.defineProperty(strippedResponse, 'url', {
+            value: response.url
+        });
+        Object.defineProperty(strippedResponse, 'redirected', {
+            value: response.redirected
+        });
+        return {
+            response: strippedResponse,
+            cacheData
+        };
+    }
+    return {
+        response,
+        cacheData: null
+    };
+}
+async function resolveStaticStageData(cacheData, flightResponse, headers) {
+    const { isResponsePartial, responseBodyClone } = cacheData;
+    if (responseBodyClone) {
+        if (!isResponsePartial) {
+            // Fully static — cache the entire decoded response as-is.
+            responseBodyClone.cancel();
+            return {
+                response: flightResponse,
+                isResponsePartial: false
+            };
+        }
+        if (flightResponse.l !== undefined) {
+            // Partially static — truncate the body clone at the byte boundary and
+            // decode it.
+            const response = await decodeStaticStage(responseBodyClone, flightResponse.l, headers);
+            return {
+                response,
+                isResponsePartial: true
+            };
+        }
+        // No caching — cancel the unused clone.
+        responseBodyClone.cancel();
+    }
+    return null;
+}
+async function decodeStaticStage(responseBodyClone, staticStageByteLengthPromise, headers) {
+    const staticStageByteLength = await staticStageByteLengthPromise;
+    const truncatedStream = truncateStream(responseBodyClone, staticStageByteLength);
+    return createFromNextReadableStream(truncatedStream, headers, {
+        allowPartialStream: true
+    });
+}
 async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode, signal) {
     // TODO: In output: "export" mode, the headers do nothing. Omit them (and the
     // cache busting search param) from the request so they're
@@ -177,7 +292,7 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
     if (deploymentId) {
         headers['x-deployment-id'] = deploymentId;
     }
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.__NEXT_DEV_SERVER) {
         if (self.__next_r) {
             headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] = self.__next_r;
         }
@@ -198,17 +313,16 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
     // track them separately.
     let fetchUrl = new URL(url);
     (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, headers);
-    let fetchPromise = fetch(fetchUrl, fetchOptions);
+    let processed = fetch(fetchUrl, fetchOptions).then(processFetch);
+    let fetchPromise = processed.then(({ response })=>response);
     // Immediately pass the fetch promise to the Flight client so that the debug
     // info includes the latency from the client to the server. The internal timer
     // in React starts as soon as `createFromFetch` is called.
     //
-    // The only case where we don't do this is during a prefetch, because we have
-    // to do some extra processing of the response stream (see
-    // `createUnclosingPrefetchStream`). But this is fine, because a top-level
-    // prefetch response never blocks a navigation; if it hasn't already been
-    // written into the cache by the time the navigation happens, the router will
-    // go straight to a dynamic request.
+    // The only case where we don't do this is during a prefetch, because a
+    // top-level prefetch response never blocks a navigation; if it hasn't already
+    // been written into the cache by the time the navigation happens, the router
+    // will go straight to a dynamic request.
     let flightResponsePromise = shouldImmediatelyDecode ? createFromNextFetch(fetchPromise, headers) : null;
     let browserResponse = await fetchPromise;
     // If the server responds with a redirect (e.g. 307), and the redirected
@@ -254,7 +368,8 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
             // TODO: We should abort the previous request.
             fetchUrl = new URL(responseUrl);
             (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, headers);
-            fetchPromise = fetch(fetchUrl, fetchOptions);
+            processed = fetch(fetchUrl, fetchOptions).then(processFetch);
+            fetchPromise = processed.then(({ response })=>response);
             flightResponsePromise = shouldImmediatelyDecode ? createFromNextFetch(fetchPromise, headers) : null;
             browserResponse = await fetchPromise;
             // We just performed a manual redirect, so this is now true.
@@ -282,15 +397,17 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
         // This is the exact promise returned by `createFromFetch`. It contains
         // debug information that we need to transfer to any derived promises that
         // are later rendered by React.
-        flightResponse: flightResponsePromise
+        flightResponsePromise: flightResponsePromise,
+        cacheData: processed.then(({ cacheData })=>cacheData)
     };
     return rscResponse;
 }
-function createFromNextReadableStream(flightStream, requestHeaders) {
+function createFromNextReadableStream(flightStream, requestHeaders, options) {
     return createFromReadableStream(flightStream, {
         callServer: _appcallserver.callServer,
         findSourceMapURL: _appfindsourcemapurl.findSourceMapURL,
-        debugChannel: createDebugChannel && createDebugChannel(requestHeaders)
+        debugChannel: createDebugChannel && createDebugChannel(requestHeaders),
+        unstable_allowPartialStream: options?.allowPartialStream
     });
 }
 function createFromNextFetch(promiseForResponse, requestHeaders) {
@@ -300,33 +417,33 @@ function createFromNextFetch(promiseForResponse, requestHeaders) {
         debugChannel: createDebugChannel && createDebugChannel(requestHeaders)
     });
 }
-function createUnclosingPrefetchStream(originalFlightStream) {
-    // When PPR is enabled, prefetch streams may contain references that never
-    // resolve, because that's how we encode dynamic data access. In the decoded
-    // object returned by the Flight client, these are reified into hanging
-    // promises that suspend during render, which is effectively what we want.
-    // The UI resolves when it switches to the dynamic data stream
-    // (via useDeferredValue(dynamic, static)).
-    //
-    // However, the Flight implementation currently errors if the server closes
-    // the response before all the references are resolved. As a cheat to work
-    // around this, we wrap the original stream in a new stream that never closes,
-    // and therefore doesn't error.
-    const reader = originalFlightStream.getReader();
+function truncateStream(stream, byteLength) {
+    const reader = stream.getReader();
+    let remaining = byteLength;
     return new ReadableStream({
         async pull (controller) {
-            while(true){
-                const { done, value } = await reader.read();
-                if (!done) {
-                    // Pass to the target stream and keep consuming the Flight response
-                    // from the server.
-                    controller.enqueue(value);
-                    continue;
-                }
-                // The server stream has closed. Exit, but intentionally do not close
-                // the target stream.
+            if (remaining <= 0) {
+                reader.cancel();
+                controller.close();
                 return;
             }
+            const { done, value } = await reader.read();
+            if (done) {
+                controller.close();
+                return;
+            }
+            if (value.byteLength <= remaining) {
+                controller.enqueue(value);
+                remaining -= value.byteLength;
+            } else {
+                controller.enqueue(value.subarray(0, remaining));
+                remaining = 0;
+                reader.cancel();
+                controller.close();
+            }
+        },
+        cancel () {
+            reader.cancel();
         }
     });
 }

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

@@ -8,10 +8,11 @@ Object.defineProperty(exports, "isNavigatingToNewRootLayout", {
         return isNavigatingToNewRootLayout;
     }
 });
+const _approutertypes = require("../../../shared/lib/app-router-types");
 function isNavigatingToNewRootLayout(currentTree, nextTree) {
     // Compare segments
     const currentTreeSegment = currentTree[0];
-    const nextTreeSegment = nextTree[0];
+    const nextTreeSegment = nextTree.segment;
     // If any segment is different before we find the root layout, the root layout has changed.
     // E.g. /same/(group1)/layout.js -> /same/(group2)/layout.js
     // First segment is 'same' for both, keep looking. (group1) changed to (group2) before the root layout was found, it must have changed.
@@ -25,21 +26,28 @@ function isNavigatingToNewRootLayout(currentTree, nextTree) {
         return true;
     }
     // Current tree root layout found
-    if (currentTree[4]) {
+    const currentIsRootLayout = ((currentTree[4] ?? 0) & _approutertypes.PrefetchHint.IsRootLayout) !== 0;
+    const nextIsRootLayout = (nextTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayout) !== 0;
+    if (currentIsRootLayout) {
         // If the next tree doesn't have the root layout flag, it must have changed.
-        return !nextTree[4];
+        return !nextIsRootLayout;
     }
     // Current tree didn't have its root layout here, must have changed.
-    if (nextTree[4]) {
+    if (nextIsRootLayout) {
         return true;
     }
-    // We can't assume it's `parallelRoutes.children` here in case the root layout is `app/@something/layout.js`
-    // But it's not possible to be more than one parallelRoutes before the root layout is found
-    // TODO-APP: change to traverse all parallel routes
-    const currentTreeChild = Object.values(currentTree[1])[0];
-    const nextTreeChild = Object.values(nextTree[1])[0];
-    if (!currentTreeChild || !nextTreeChild) return true;
-    return isNavigatingToNewRootLayout(currentTreeChild, nextTreeChild);
+    const slots = nextTree.slots;
+    const currentTreeChildren = currentTree[1];
+    if (slots !== null) {
+        for(const slot in slots){
+            const nextTreeChild = slots[slot];
+            const currentTreeChild = currentTreeChildren[slot];
+            if (currentTreeChild === undefined || isNavigatingToNewRootLayout(currentTreeChild, nextTreeChild)) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {