@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/server/app-render/stream-ops.node.js

@@ -132,10 +132,11 @@ const _constants = require("../../shared/lib/errors/constants");
 const _htmlescape = require("../../shared/lib/htmlescape");
 const _useflightresponse = require("./use-flight-response");
 const _apprenderprerenderutils = require("./app-render-prerender-utils");
-const _detachedpromise = require("../../lib/detached-promise");
+const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
 const _tracer = require("../lib/trace/tracer");
 const _constants1 = require("../lib/trace/constants");
 const _scheduler = require("../../lib/scheduler");
+const _nextrequest = require("../web/spec-extension/adapters/next-request");
 const _streamopsweb = require("./stream-ops.web");
 function nodeReadableToWebReadableStream(stream) {
     if (stream instanceof ReadableStream) {
@@ -473,11 +474,7 @@ function createRootLayoutValidatorTransform() {
 }
 function renderToNodeFlightStream(ComponentMod, payload, clientModules, opts) {
     if (!ComponentMod.renderToPipeableStream) {
-        throw Object.defineProperty(new Error('renderToPipeableStream is not implemented'), "__NEXT_ERROR_CODE", {
-            value: "E1153",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('renderToPipeableStream is not implemented');
     }
     // `renderToPipeableStream` has no `signal` option (unlike the Web
     // `renderToReadableStream`), so pull `signal` out of the options and abort
@@ -487,6 +484,15 @@ function renderToNodeFlightStream(ComponentMod, payload, clientModules, opts) {
     const { signal, ...renderOptions } = opts ?? {};
     const pt = new _nodestream.PassThrough();
     const pipeable = ComponentMod.renderToPipeableStream(payload, clientModules, renderOptions);
+    // If the destination is destroyed before the render ended, React aborts with a
+    // generic "The destination stream closed early." error that `onError` can't
+    // tell apart from a real render error. Abort first with the reason we already
+    // know; the listener is registered before piping so it runs before React's.
+    pt.once('close', ()=>{
+        if (!pt.writableEnded) {
+            pipeable.abort(new _nextrequest.ResponseAborted());
+        }
+    });
     pipeable.pipe(pt);
     if (signal) {
         if (signal.aborted) {
@@ -503,8 +509,8 @@ function renderToNodeFlightStream(ComponentMod, payload, clientModules, opts) {
 }
 async function renderToNodeFizzStream(element, streamOptions, options) {
     const pt = new _nodestream.PassThrough();
-    const shellReady = new _detachedpromise.DetachedPromise();
-    const allReady = new _detachedpromise.DetachedPromise();
+    const shellReady = (0, _promisewithresolvers.createPromiseWithResolvers)();
+    const allReady = (0, _promisewithresolvers.createPromiseWithResolvers)();
     const deferPipe = (options == null ? void 0 : options.waitForAllReady) === true;
     const pipeable = (0, _tracer.getTracer)().trace(_constants1.AppRenderSpan.renderToReadableStream, ()=>(0, _server.renderToPipeableStream)(element, {
             ...streamOptions,
@@ -543,8 +549,8 @@ async function renderToNodeFizzStream(element, streamOptions, options) {
 async function resumeToFizzStream(element, postponedState, streamOptions, runInContext) {
     const run = runInContext ?? ((fn)=>fn());
     const pt = new _nodestream.PassThrough();
-    const shellReady = new _detachedpromise.DetachedPromise();
-    const allReady = new _detachedpromise.DetachedPromise();
+    const shellReady = (0, _promisewithresolvers.createPromiseWithResolvers)();
+    const allReady = (0, _promisewithresolvers.createPromiseWithResolvers)();
     const pipeable = await run(()=>(0, _server.resumeToPipeableStream)(element, postponedState, {
             ...streamOptions,
             onShellReady () {
@@ -579,10 +585,10 @@ async function resumeAndAbort(element, postponed, opts) {
     pipeable.abort(opts == null ? void 0 : (_opts_signal = opts.signal) == null ? void 0 : _opts_signal.reason);
     return pt;
 }
-async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, allReady, deploymentId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
+async function continueFizzStream(renderStream, { suffix, inlinedDataStream, waitForAllReady, allReady, deploymentId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
     // Suffix itself might contain close tags at the end, so we need to split it.
     const suffixUnclosed = suffix ? suffix.split(_nodewebstreamshelper.CLOSE_TAG, 1)[0] : null;
-    if (isStaticGeneration) {
+    if (waitForAllReady) {
         if (allReady) {
             await allReady;
         }

package/app/node_modules/next/dist/server/app-render/stream-ops.web.js

@@ -152,11 +152,7 @@ async function continueDynamicHTMLResumeWeb(renderStream, opts) {
     });
 }
 function continueDynamicHTMLResumeNode(_renderStream, _opts) {
-    throw Object.defineProperty(new Error('not implemented'), "__NEXT_ERROR_CODE", {
-        value: "E1154",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('not implemented');
 }
 async function streamToBuffer(stream) {
     return (0, _nodewebstreamshelper.streamToBuffer)(stream);
@@ -174,11 +170,7 @@ function createWebInlinedDataStream(source, nonce, formState) {
     return (0, _useflightresponse.createInlinedDataReadableStream)(source, nonce, formState);
 }
 function createNodeInlinedDataStream(_source, _nonce, _formState) {
-    throw Object.defineProperty(new Error('not implemented'), "__NEXT_ERROR_CODE", {
-        value: "E1154",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('not implemented');
 }
 function createPendingStream() {
     return new ReadableStream();
@@ -194,11 +186,7 @@ async function resumeAndAbort(element, postponed, opts) {
     return (0, _server.resume)(element, postponed, opts);
 }
 function renderToNodeFlightStream(_ComponentMod, _payload, _clientModules, _opts) {
-    throw Object.defineProperty(new Error('not implemented'), "__NEXT_ERROR_CODE", {
-        value: "E1154",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('not implemented');
 }
 function renderToWebFlightStream(ComponentMod, payload, clientModules, opts) {
     return ComponentMod.renderToReadableStream(payload, clientModules, opts);
@@ -221,11 +209,7 @@ async function renderToWebFizzStream(element, streamOptions, _options) {
     };
 }
 async function renderToNodeFizzStream(_element, _streamOptions, _options) {
-    throw Object.defineProperty(new Error('Not implemented'), "__NEXT_ERROR_CODE", {
-        value: "E1155",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('Not implemented');
 }
 async function resumeToFizzStream(element, postponedState, streamOptions) {
     const stream = await (0, _server.resume)(element, postponedState, streamOptions);

package/app/node_modules/next/dist/server/app-render/sync-io-messages.js

@@ -43,11 +43,7 @@ function elapsedTimeBullet(type) {
     return type === 'time' ? `\n  - [measure] If the value is for telemetry, use a timing API such as \`performance.now()\`` : '';
 }
 function createSyncIOErrorImpl(route, expression, type, docsUrl) {
-    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered the unstable value ${expression} while prerendering.\n\n` + `This value can change between renders, so it must be either prerendered or computed later.\n\n` + `Ways to fix this:\n` + `  - [dynamic] Render at request time by adding a dynamic data access (e.g. \`await connection()\`) before this call\n` + `  - [cache] Prerender and cache the value with \`"use cache"\`\n` + `  - [client] Render the value on the client with \`"use client"\`` + elapsedTimeBullet(type) + `\n\nLearn more: ${docsUrl}`), "__NEXT_ERROR_CODE", {
-        value: "E1432",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`Route "${route}": Next.js encountered the unstable value ${expression} while prerendering.\n\n` + `This value can change between renders, so it must be either prerendered or computed later.\n\n` + `Ways to fix this:\n` + `  - [dynamic] Render at request time by adding a dynamic data access (e.g. \`await connection()\`) before this call\n` + `  - [cache] Prerender and cache the value with \`"use cache"\`\n` + `  - [client] Render the value on the client with \`"use client"\`` + elapsedTimeBullet(type) + `\n\nLearn more: ${docsUrl}`);
 }
 function createSyncIOError(route, expression, type) {
     return createSyncIOErrorImpl(route, expression, type, SYNC_IO_DOCS[type]);
@@ -57,11 +53,7 @@ function createSyncIORuntimeError(route, expression, type) {
 }
 function createSyncIOClientError(route, expression, type) {
     const docsUrl = SYNC_IO_CLIENT_DOCS[type];
-    return Object.defineProperty(new Error(`Route "${route}": Next.js encountered the unstable value ${expression} in a Client Component.\n\n` + `This value would be evaluated during the prerender, instead of recomputed on each visit.\n\n` + `Ways to fix this:\n` + `  - [stream] Wrap the Client Component in \`<Suspense fallback={...}>\`\n` + `  - [defer] Move the read into a \`useEffect\` or event handler` + elapsedTimeBullet(type) + `\n\nLearn more: ${docsUrl}`), "__NEXT_ERROR_CODE", {
-        value: "E1434",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`Route "${route}": Next.js encountered the unstable value ${expression} in a Client Component.\n\n` + `This value would be evaluated during the prerender, instead of recomputed on each visit.\n\n` + `Ways to fix this:\n` + `  - [stream] Wrap the Client Component in \`<Suspense fallback={...}>\`\n` + `  - [defer] Move the read into a \`useEffect\` or event handler` + elapsedTimeBullet(type) + `\n\nLearn more: ${docsUrl}`);
 }
 
 //# sourceMappingURL=sync-io-messages.js.map

package/app/node_modules/next/dist/server/app-render/types.js

@@ -59,7 +59,8 @@ const flightRouterStateSchema = _superstruct.default.tuple([
         _superstruct.default.literal('inside-shared-layout'),
         _superstruct.default.literal('metadata-only')
     ]))),
-    _superstruct.default.optional(_superstruct.default.number())
+    _superstruct.default.optional(_superstruct.default.nullable(_superstruct.default.number())),
+    _superstruct.default.optional(_superstruct.default.string())
 ]);
 
 //# sourceMappingURL=types.js.map

package/app/node_modules/next/dist/server/app-render/use-flight-response.js

@@ -42,11 +42,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
     if (flightStream instanceof ReadableStream) {
         // The types of flightStream and debugStream should match.
         if (debugStream && !(debugStream instanceof ReadableStream)) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('Expected debug stream to be a ReadableStream'), "__NEXT_ERROR_CODE", {
-                value: "E939",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('Expected debug stream to be a ReadableStream');
         }
         // react-server-dom-webpack/client.edge must not be hoisted for require cache clearing to work correctly
         const { createFromReadableStream } = // eslint-disable-next-line import/no-extraneous-dependencies
@@ -66,11 +62,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
         });
     } else {
         if (process.env.NEXT_RUNTIME === 'edge') {
-            throw Object.defineProperty(new _invarianterror.InvariantError('getFlightStream should always receive a ReadableStream when using the edge runtime'), "__NEXT_ERROR_CODE", {
-                value: "E943",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('getFlightStream should always receive a ReadableStream when using the edge runtime');
         } else {
             const { Readable } = require('node:stream');
             // Convert debug stream to Readable if it's a ReadableStream.
@@ -104,11 +96,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
     if (process.env.NEXT_RUNTIME !== 'edge') {
         const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
         if (!workUnitStore) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.'), "__NEXT_ERROR_CODE", {
-                value: "E696",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.');
         }
         switch(workUnitStore.type){
             case 'prerender-client':
@@ -122,13 +110,12 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
                 return responseOnNextTick;
             case 'prerender':
             case 'prerender-runtime':
-            case 'prerender-ppr':
             case 'prerender-legacy':
             case 'request':
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;

package/app/node_modules/next/dist/server/app-render/vary-params.js

@@ -61,23 +61,24 @@ _export(exports, {
     }
 });
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
+const _varyparamsdecoding = require("../../shared/lib/segment-cache/vary-params-decoding");
 class VaryParamsAccumulator {
     /**
    * Records that a param was accessed. Yields the name into the stream the
    * first time it's seen; subsequent accesses of the same name are no-ops.
-   */ add(paramName) {
-        if (this._done || this._seen.has(paramName)) {
+   */ add(id) {
+        if (this._done || this._seen.has(id)) {
             return;
         }
-        this._seen.add(paramName);
+        this._seen.add(id);
         if (this._resolve !== null) {
             this._resolve({
-                value: paramName,
+                value: id,
                 done: false
             });
             this._resolve = null;
         } else {
-            this._buffer.push(paramName);
+            this._buffer.push(id);
         }
     }
     /** Ends the iteration. Best-effort: if skipped (e.g. on a sync-I/O abort),
@@ -168,8 +169,8 @@ function getRootParamsVaryParamsAccumulator() {
     }
     return ((_getVaryParamsAccumulator = (0, _workunitasyncstorageexternal.getVaryParamsAccumulator)(workUnitStore)) == null ? void 0 : _getVaryParamsAccumulator.rootParams) ?? null;
 }
-function accumulateVaryParam(accumulator, paramName) {
-    accumulator.add(paramName);
+function accumulateVaryParam(accumulator, id) {
+    accumulator.add(id);
 }
 function accumulateRootVaryParam(paramName) {
     const rootParamsAccumulator = getRootParamsVaryParamsAccumulator();
@@ -229,23 +230,23 @@ function createVaryingSearchParams(accumulator, originalSearchParamsObject) {
     // checks, or enumeration — must register as varying. A Proxy is required
     // (rather than per-property getters) so that enumeration of an empty
     // searchParams object still triggers a vary. All accesses bucket into the
-    // single sentinel '?'; the segment is keyed by the whole query string.
+    // single search params id; the segment is keyed by the whole query string.
     // TODO: Split into per-param tracking if the cache key evolves.
     return new Proxy(originalSearchParamsObject, {
         get (target, prop, receiver) {
             if (typeof prop === 'string') {
-                accumulateVaryParam(accumulator, '?');
+                accumulateVaryParam(accumulator, _varyparamsdecoding.SEARCH_PARAMS_VARY_ID);
             }
             return Reflect.get(target, prop, receiver);
         },
         has (target, prop) {
             if (typeof prop === 'string') {
-                accumulateVaryParam(accumulator, '?');
+                accumulateVaryParam(accumulator, _varyparamsdecoding.SEARCH_PARAMS_VARY_ID);
             }
             return Reflect.has(target, prop);
         },
         ownKeys (target) {
-            accumulateVaryParam(accumulator, '?');
+            accumulateVaryParam(accumulator, _varyparamsdecoding.SEARCH_PARAMS_VARY_ID);
             return Reflect.ownKeys(target);
         }
     });

package/app/node_modules/next/dist/server/app-render/walk-tree-with-flight-router-state.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    createFullTreeFlightDataForNavigation: null,
+    createFullTreeForNavigation: null,
     walkTreeWithFlightRouterState: null
 });
 function _export(target, all) {
@@ -13,28 +13,35 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    createFullTreeFlightDataForNavigation: function() {
-        return createFullTreeFlightDataForNavigation;
+    createFullTreeForNavigation: function() {
+        return createFullTreeForNavigation;
     },
     walkTreeWithFlightRouterState: function() {
         return walkTreeWithFlightRouterState;
     }
 });
-const _matchsegments = require("../../client/components/match-segments");
+const _segment = require("../../shared/lib/segment");
+const _querystring = require("../../shared/lib/router/utils/querystring");
+const _rsctransport = require("../../shared/lib/rsc-transport");
 const _getcssinlinedlinktags = require("./get-css-inlined-link-tags");
 const _getpreloadablefonts = require("./get-preloadable-fonts");
-const _createflightrouterstatefromloadertree = require("./create-flight-router-state-from-loader-tree");
+const _createtransporttreefromloadertree = require("./create-transport-tree-from-loader-tree");
 const _hasloadingcomponentintree = require("./has-loading-component-in-tree");
-const _segment = require("../../shared/lib/segment");
 const _createcomponenttree = require("./create-component-tree");
-const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
+function didRouteOrPathParamChange(actualSegment, requestedSegment) {
+    // The caller handles the page's search params separately.
+    if (typeof actualSegment === 'string' || typeof requestedSegment === 'string') {
+        // Static segments have to match exactly.
+        return actualSegment !== requestedSegment;
+    }
+    // Both segments are dynamic. Compare the param name, type, and value. The
+    // static sibling hints (index 3) aren't part of the segment's identity.
+    return actualSegment[0] !== requestedSegment[0] || actualSegment[2] !== requestedSegment[2] || actualSegment[1] !== requestedSegment[1];
+}
 async function walkTreeWithFlightRouterState({ loaderTreeToFilter, parentParams, flightRouterState, parentIsInsideSharedLayout, rscHead, injectedCSS, injectedJS, injectedFontPreloadTags, rootLayoutIncluded, ctx, preloadCallbacks, MetadataOutlet, hintTree }) {
-    const { renderOpts: { nextFontManifest, experimental }, query, isPrefetch, getDynamicParamFromSegment, parsedRequestHeaders, workStore } = ctx;
+    const { renderOpts: { nextFontManifest, experimental }, query, isPrefetch, getDynamicParamFromSegment, parsedRequestHeaders } = ctx;
     const prefetchInliningEnabled = Boolean(experimental.prefetchInlining);
-    const cacheComponents = ctx.renderOpts.cacheComponents;
-    const partialPrefetching = ctx.renderOpts.partialPrefetching;
-    const isStaticGeneration = workStore.isStaticGeneration;
-    const isBuildTimePrerendering = ctx.renderOpts.isBuildTimePrerendering ?? false;
+    const partialPrefetching = Boolean(ctx.renderOpts.partialPrefetching);
     const [segment, parallelRoutes, modules] = loaderTreeToFilter;
     const parallelRoutesKeys = Object.keys(parallelRoutes);
     const { layout } = modules;
@@ -52,12 +59,14 @@ async function walkTreeWithFlightRouterState({ loaderTreeToFilter, parentParams,
         ...parentParams,
         [segmentParam.param]: segmentParam.value
     } : parentParams;
-    const actualSegment = (0, _segment.addSearchParamsIfPageSegment)(segmentParam ? segmentParam.treeSegment : segment, query);
+    const actualSegment = segmentParam ? segmentParam.treeSegment : segment;
     /**
    * Decide if the current segment is where rendering has to start.
    */ const renderComponentsOnThisLevel = // No further router state available
-    !flightRouterState || // Segment in router state does not match current segment
-    !(0, _matchsegments.matchSegment)(actualSegment, flightRouterState[0]) || // Explicit refresh
+    !flightRouterState || // Route structure or path param changed
+    didRouteOrPathParamChange(actualSegment, flightRouterState[0]) || // Normal requests leave out the page's search params, so treat a missing
+    // value as empty. HMR requests include them.
+    actualSegment === _segment.PAGE_SEGMENT_KEY && (0, _querystring.getRenderedSearch)(query) !== (flightRouterState[5] === undefined ? '' : flightRouterState[5]) || // Explicit refresh
     flightRouterState[3] === 'refetch';
     // Pre-PPR, the `loading` component signals to the router how deep to render the component tree
     // to ensure prefetches are quick and inexpensive. If there's no `loading` component anywhere in the tree being rendered,
@@ -83,48 +92,30 @@ async function walkTreeWithFlightRouterState({ loaderTreeToFilter, parentParams,
         // because they do not contain any render data (neither segment data nor
         // the head). They can be made even more cacheable once we move the route
         // params into a separate data structure.
-        const overriddenSegment = flightRouterState && // TODO: Why does canSegmentBeOverridden exist? Why don't we always just
-        // use `actualSegment`? Is it to avoid overwriting some state that's
-        // tracked by the client? Dig deeper to see if we can simplify this.
-        canSegmentBeOverridden(actualSegment, flightRouterState[0]) ? flightRouterState[0] : actualSegment;
-        const routerState = parsedRequestHeaders.isRouteTreePrefetchRequest ? await (0, _createflightrouterstatefromloadertree.createRouteTreePrefetch)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, rootLayoutIncluded) : await (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, query, rootLayoutIncluded);
-        return [
-            [
-                overriddenSegment,
-                routerState,
+        const tree = parsedRequestHeaders.isRouteTreePrefetchRequest ? await (0, _createtransporttreefromloadertree.createRouteTreePrefetch)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, ctx.missingPrefetchHintPolicy, partialPrefetching, getDynamicParamFromSegment, ctx.renderOpts.notFoundParams, rootLayoutIncluded) : await (0, _createtransporttreefromloadertree.createTransportTreeFromLoaderTree)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, ctx.missingPrefetchHintPolicy, partialPrefetching, getDynamicParamFromSegment, ctx.renderOpts.notFoundParams, rootLayoutIncluded);
+        return {
+            tree,
+            head: [
                 null,
-                [
-                    null,
-                    null
-                ],
-                true
-            ]
-        ];
+                null
+            ],
+            isHeadPartial: true
+        };
     }
     // Similar to the previous branch. This flag is sent by the client to request
     // only the metadata for a page. No segment data.
     if (flightRouterState && flightRouterState[3] === 'metadata-only') {
-        const overriddenSegment = flightRouterState && canSegmentBeOverridden(actualSegment, flightRouterState[0]) ? flightRouterState[0] : actualSegment;
-        const routerState = parsedRequestHeaders.isRouteTreePrefetchRequest ? await (0, _createflightrouterstatefromloadertree.createRouteTreePrefetch)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment) : await (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, query, rootLayoutIncluded);
-        return [
-            [
-                overriddenSegment,
-                routerState,
-                null,
-                rscHead,
-                false
-            ]
-        ];
+        const tree = parsedRequestHeaders.isRouteTreePrefetchRequest ? await (0, _createtransporttreefromloadertree.createRouteTreePrefetch)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, ctx.missingPrefetchHintPolicy, partialPrefetching, getDynamicParamFromSegment, ctx.renderOpts.notFoundParams) : await (0, _createtransporttreefromloadertree.createTransportTreeFromLoaderTree)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, ctx.missingPrefetchHintPolicy, partialPrefetching, getDynamicParamFromSegment, ctx.renderOpts.notFoundParams, rootLayoutIncluded);
+        return {
+            tree,
+            head: rscHead,
+            isHeadPartial: false
+        };
     }
     if (renderComponentsOnThisLevel) {
-        const overriddenSegment = flightRouterState && // TODO: Why does canSegmentBeOverridden exist? Why don't we always just
-        // use `actualSegment`? Is it to avoid overwriting some state that's
-        // tracked by the client? Dig deeper to see if we can simplify this.
-        canSegmentBeOverridden(actualSegment, flightRouterState[0]) ? flightRouterState[0] : actualSegment;
-        const routerState = await (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(// Create router state using the slice of the loaderTree
-        loaderTreeToFilter, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, query, rootLayoutIncluded);
-        // Create component tree using the slice of the loaderTree
-        const seedData = await (0, _createcomponenttree.createComponentTree)(// This ensures flightRouterPath is valid and filters down the tree
+        // Render the component tree for this slice of the loaderTree, returned
+        // as the response's transport tree.
+        const tree = await (0, _createcomponenttree.createComponentTree)(// This ensures flightRouterPath is valid and filters down the tree
         {
             ctx,
             loaderTree: loaderTreeToFilter,
@@ -138,17 +129,15 @@ async function walkTreeWithFlightRouterState({ loaderTreeToFilter, parentParams,
             rootLayoutIncluded,
             preloadCallbacks,
             authInterrupts: experimental.authInterrupts,
-            MetadataOutlet
+            MetadataOutlet,
+            isPrerendering: false,
+            hintTree
         });
-        return [
-            [
-                overriddenSegment,
-                routerState,
-                seedData,
-                rscHead,
-                false
-            ]
-        ];
+        return {
+            tree,
+            head: rscHead,
+            isHeadPartial: false
+        };
     }
     // If we are not rendering on this level we need to check if the current
     // segment has a layout. If so, we need to track all the used CSS to make
@@ -161,12 +150,15 @@ async function walkTreeWithFlightRouterState({ loaderTreeToFilter, parentParams,
         (0, _getcssinlinedlinktags.getLinkAndScriptTags)(layoutPath, injectedCSSWithCurrentLayout, injectedJSWithCurrentLayout, true);
         (0, _getpreloadablefonts.getPreloadableFonts)(nextFontManifest, layoutPath, injectedFontPreloadTagsWithCurrentLayout);
     }
-    const paths = [];
-    // Walk through all parallel routes.
+    // Walk through all parallel routes, collecting the subtrees of the slots
+    // that produced output. A slot that produced nothing is omitted from the
+    // children map: the response carries no information about it.
+    let children;
+    let firstSubtree = null;
     for (const parallelRouteKey of parallelRoutesKeys){
         var _hintTree_slots;
         const parallelRoute = parallelRoutes[parallelRouteKey];
-        const subPaths = await walkTreeWithFlightRouterState({
+        const subtreeResult = await walkTreeWithFlightRouterState({
             ctx,
             loaderTreeToFilter: parallelRoute,
             parentParams: currentParams,
@@ -181,23 +173,43 @@ async function walkTreeWithFlightRouterState({ loaderTreeToFilter, parentParams,
             MetadataOutlet,
             hintTree: (hintTree == null ? void 0 : (_hintTree_slots = hintTree.slots) == null ? void 0 : _hintTree_slots[parallelRouteKey]) ?? null
         });
-        for (const subPath of subPaths){
-            paths.push([
-                actualSegment,
-                parallelRouteKey,
-                ...subPath
-            ]);
+        if (subtreeResult === null) {
+            continue;
         }
+        if (children === undefined) {
+            children = new Map();
+        }
+        children.set(parallelRouteKey, subtreeResult.tree);
+        if (firstSubtree === null) {
+            firstSubtree = subtreeResult;
+        }
+    }
+    if (children === undefined || firstSubtree === null) {
+        // Nothing below this segment produced output.
+        return null;
     }
-    return paths;
+    return {
+        // This segment is skipped: it's on the path from the root down to the
+        // rendered subtrees, so the client is expected to already have it.
+        tree: {
+            s: (0, _rsctransport.segmentToTransportSegment)(actualSegment),
+            // The UI is shared, but route-specific restrictions may have changed
+            // (e.g. an open sibling navigating to a dynamicParams=false page).
+            h: await (0, _createtransporttreefromloadertree.computeSegmentPrefetchHints)(loaderTreeToFilter, hintTree, prefetchInliningEnabled, ctx.missingPrefetchHintPolicy, partialPrefetching, !rootLayoutIncluded, ctx.renderOpts.notFoundParams),
+            d: (0, _rsctransport.createSkippedSegmentData)(),
+            c: children
+        },
+        // The head is identical across all the subtrees of a response; take the
+        // first one.
+        head: firstSubtree.head,
+        isHeadPartial: firstSubtree.isHeadPartial
+    };
 }
-async function createFullTreeFlightDataForNavigation({ loaderTree, rscHead, injectedCSS, injectedJS, injectedFontPreloadTags, ctx, preloadCallbacks, MetadataOutlet }) {
+async function createFullTreeForNavigation({ loaderTree, rscHead, injectedCSS, injectedJS, injectedFontPreloadTags, ctx, preloadCallbacks, MetadataOutlet }) {
     var _ctx_renderOpts_prefetchHints;
-    const { renderOpts: { experimental }, query, getDynamicParamFromSegment, pagePath, workStore: workStoreForInitialRender } = ctx;
+    const { renderOpts: { experimental }, pagePath } = ctx;
     const hintTreeForInitialRender = ((_ctx_renderOpts_prefetchHints = ctx.renderOpts.prefetchHints) == null ? void 0 : _ctx_renderOpts_prefetchHints[pagePath]) ?? null;
-    const routerState = await (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(loaderTree, hintTreeForInitialRender, Boolean(experimental.prefetchInlining), ctx.renderOpts.cacheComponents, ctx.renderOpts.partialPrefetching, workStoreForInitialRender.isStaticGeneration, ctx.renderOpts.isBuildTimePrerendering ?? false, getDynamicParamFromSegment, query);
-    const rootSegment = routerState[0];
-    const seedData = await (0, _createcomponenttree.createComponentTree)({
+    const tree = await (0, _createcomponenttree.createComponentTree)({
         ctx,
         loaderTree,
         parentParams: {},
@@ -209,29 +221,15 @@ async function createFullTreeFlightDataForNavigation({ loaderTree, rscHead, inje
         rootLayoutIncluded: false,
         preloadCallbacks,
         authInterrupts: experimental.authInterrupts,
-        MetadataOutlet
+        MetadataOutlet,
+        isPrerendering: false,
+        hintTree: hintTreeForInitialRender
     });
-    return [
-        [
-            // TODO: app-render slices this Segment off.
-            // why is that valid, and why are we including it in the first place?
-            rootSegment,
-            routerState,
-            seedData,
-            rscHead,
-            false
-        ]
-    ];
+    return {
+        tree,
+        head: rscHead,
+        isHeadPartial: false
+    };
 }
-/*
- * This function is used to determine if an existing segment can be overridden
- * by the incoming segment.
- */ const canSegmentBeOverridden = (existingSegment, segment)=>{
-    var _getSegmentParam;
-    if (Array.isArray(existingSegment) || !Array.isArray(segment)) {
-        return false;
-    }
-    return ((_getSegmentParam = (0, _getsegmentparam.getSegmentParam)(existingSegment)) == null ? void 0 : _getSegmentParam.paramName) === segment[0];
-};
 
 //# sourceMappingURL=walk-tree-with-flight-router-state.js.map

package/app/node_modules/next/dist/server/app-render/work-async-storage-instance.js

@@ -9,6 +9,6 @@ Object.defineProperty(exports, "workAsyncStorageInstance", {
     }
 });
 const _asynclocalstorage = require("./async-local-storage");
-const workAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+const workAsyncStorageInstance = (0, _asynclocalstorage.getOrCreateGlobalAsyncLocalStorage)('work-async-storage');
 
 //# sourceMappingURL=work-async-storage-instance.js.map

package/app/node_modules/next/dist/server/app-render/work-unit-async-storage-instance.js

@@ -9,6 +9,6 @@ Object.defineProperty(exports, "workUnitAsyncStorageInstance", {
     }
 });
 const _asynclocalstorage = require("./async-local-storage");
-const workUnitAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+const workUnitAsyncStorageInstance = (0, _asynclocalstorage.getOrCreateGlobalAsyncLocalStorage)('work-unit-async-storage');
 
 //# sourceMappingURL=work-unit-async-storage-instance.js.map