@aeolus-fleet/console 0.34.0 → 0.36.0

package/.next/standalone/node_modules/next/dist/server/app-render/collect-segment-data.js

@@ -33,6 +33,24 @@ const _segmentvalueencoding = require("../../shared/lib/segment-cache/segment-va
 const _createerrorhandler = require("./create-error-handler");
 const _prospectiverenderutils = require("./prospective-render-utils");
 const _workasyncstorageexternal = require("./work-async-storage.external");
+const _rsctransport = require("../../shared/lib/rsc-transport");
+/**
+ * Returns the wire identity for a segment in a per-segment prefetch
+ * response. When client param parsing is enabled (cacheComponents), the
+ * param value is omitted (`k: null`) so the response stays byte-identical —
+ * and therefore cacheable — across param values; the client parses the value
+ * from the rendered pathname instead.
+ */ function createPrefetchTransportSegment(segment, isClientParamParsingEnabled) {
+    if (typeof segment === 'string' || !isClientParamParsingEnabled || segment.k === null) {
+        return segment;
+    }
+    return {
+        n: segment.n,
+        t: segment.t,
+        k: null,
+        s: segment.s
+    };
+}
 const filterStackFrame = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').filterStackFrameDEV : undefined;
 const findSourceMapURL = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').findSourceMapURLDEV : undefined;
 function onSegmentPrerenderError(error) {
@@ -47,26 +65,6 @@ function onSegmentPrerenderError(error) {
         (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(error, (workStore == null ? void 0 : workStore.route) ?? 'unknown route', _prospectiverenderutils.Phase.SegmentCollection);
     }
 }
-/**
- * Extract the FlightRouterState, seed data, and head from a prerendered
- * InitialRSCPayload. Returns null if the payload doesn't match the expected
- * shape: a single root path with no segment prefix, which has 4 elements
- * ([tree, seedData, head, isHeadPartial], per getRSCPayload) or 3 when
- * reconstructed without the isHeadPartial flag (per instant-validation).
- */ function extractFlightData(initialRSCPayload) {
-    const flightDataPaths = initialRSCPayload.f;
-    // FlightDataPath is an unsound type, hence the additional checks.
-    if (flightDataPaths.length !== 1 || flightDataPaths[0].length !== 3 && flightDataPaths[0].length !== 4) {
-        console.error('Internal Next.js error: InitialRSCPayload does not match the expected ' + 'shape for a prerendered page during segment prefetch generation.');
-        return null;
-    }
-    return {
-        buildId: initialRSCPayload.b,
-        flightRouterState: flightDataPaths[0][0],
-        seedData: flightDataPaths[0][1],
-        head: flightDataPaths[0][2]
-    };
-}
 async function collectSegmentData(isCacheComponentsEnabled, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, prefetchInlining, hints, isUpgradeableISRFallback) {
     // Traverse the router tree and generate a prefetch response for each segment.
     // A mutable map to collect the results as we traverse the route tree.
@@ -101,7 +99,15 @@ async function collectSegmentData(isCacheComponentsEnabled, fullPageDataBuffer,
             pageShellByteLength = await pagePayload.a;
         }
         if (pagePayload.u !== undefined) {
-            runtimeDataAccessed = readRuntimeDataAccessed(pagePayload.u);
+            // Every byte of the page buffer is present, so the flag's row (if the
+            // render emitted one) is readable off its thenable status. A pending
+            // row reads as `false`: a successful render always settles the flag
+            // (prerender completion resolves `false`), so a pending row can only
+            // appear in an aborted render's buffer, where it means no access was
+            // recorded before the abort. A rejected row reads as `true`,
+            // conservatively — an abort errors rows that were still pending when
+            // it happened.
+            runtimeDataAccessed = (0, _rsctransport.readFulfilledValue)(pagePayload.u, false, true);
         }
     } catch  {}
     // All segment responses of a page share one decode of the page buffer, and
@@ -154,9 +160,10 @@ async function collectSegmentData(isCacheComponentsEnabled, fullPageDataBuffer,
     const segmentTasks = [];
     let treeStream;
     try {
-        const prerenderResult = await (0, _static.prerender)(// RootTreePrefetch is not a valid return type for a React component, but
-        // we need to use a component so that when we decode the original stream
-        // inside of it, the side effects are transferred to the new stream.
+        const prerenderResult = await (0, _static.prerender)(// PrefetchFlightResponse is not a valid return type for a React
+        // component, but we need to use a component so that when we decode the
+        // original stream inside of it, the side effects are transferred to the
+        // new stream.
         // @ts-expect-error
         /*#__PURE__*/ (0, _jsxruntime.jsx)(PrefetchTreeData, {
             isClientParamParsingEnabled: isCacheComponentsEnabled,
@@ -226,7 +233,7 @@ async function collectSegmentData(isCacheComponentsEnabled, fullPageDataBuffer,
     }
     return resultMap;
 }
-async function collectPrefetchHints(fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, inlining, shouldAttemptStaticPrefetch) {
+async function collectPrefetchHints(isCacheComponentsEnabled, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, inlining, shouldAttemptStaticShell, shouldAttemptStaticPrefetch) {
     // Warm up the module cache, same as collectSegmentData.
     try {
         await (0, _client.createFromReadableStream)((0, _nodewebstreamshelper.streamFromBuffer)(fullPageDataBuffer), {
@@ -240,25 +247,28 @@ async function collectPrefetchHints(fullPageDataBuffer, staleTime, clientModules
         findSourceMapURL,
         serverConsumerManifest
     });
-    const flightData = extractFlightData(initialRSCPayload);
-    if (flightData === null) {
-        return {
-            hints: 0,
-            slots: null
-        };
-    }
-    const { buildId, flightRouterState, seedData, head } = flightData;
-    // The hints every node starts from. The static-prefetch-attempt hint is
-    // page-global (the tracking that feeds it is), so it goes on every node,
+    const transportData = initialRSCPayload.t;
+    const rootNode = transportData.t;
+    const buildId = initialRSCPayload.b;
+    const head = transportData.h.r;
+    // The hints every node starts from. The static-prefetch-attempt hints are
+    // page-global (the tracking that creates them is), so they go on every node,
     // non-propagating — the client reads it per segment, and the runtime
     // hint merging walks the manifest tree node-by-node.
-    const baseHints = shouldAttemptStaticPrefetch ? _approutertypes.PrefetchHint.ShouldAttemptStaticPrefetch : 0;
+    // (NOTE: if the prefetch is static, then the shell must be as well)
+    let baseHints = 0;
+    if (shouldAttemptStaticShell) {
+        baseHints |= _approutertypes.PrefetchHint.ShouldAttemptStaticShell;
+    }
+    if (shouldAttemptStaticPrefetch) {
+        baseHints |= _approutertypes.PrefetchHint.ShouldAttemptStaticPrefetch;
+    }
     if (inlining === false) {
         // Prefetch inlining is disabled: nothing to measure, and no inlining
         // bits may be emitted (the client would act on them even though the
         // responses aren't bundled). Just mirror the route tree's shape with
         // the base hints on every node.
-        return createUniformHintTree(flightRouterState, baseHints);
+        return createUniformHintTree(rootNode, baseHints);
     }
     const { maxSize, maxBundleSize } = inlining;
     // Root params are forwarded once at the top level of each segment
@@ -278,9 +288,23 @@ async function collectPrefetchHints(fullPageDataBuffer, staleTime, clientModules
     // the responses are byte-identical in shape to the real ones — the point
     // of measuring. Pre-resolving false is the "nothing staged" release.
     const shellStageRelease = Promise.resolve(false);
+    // This is the pass that COMPUTES the hints, so the spine hints here can't
+    // be the final merged values the real pass emits — use the best available
+    // approximation (the payload's own hints plus the base hints) so the
+    // measured responses stay representative in size. The difference is at
+    // most a few bytes per spine node (the inlining bits, on the first build).
+    const rootSpine = {
+        segment: createPrefetchTransportSegment(rootNode.s, isCacheComponentsEnabled),
+        prefetchHints: ((rootNode.h ?? 0) | baseHints) & ~_approutertypes.PrefetchHint.InliningHintsStale,
+        parallelRouteKey: null,
+        parent: null
+    };
     // Measure the head (metadata/viewport) gzip size so the main traversal
     // can decide whether to inline it into a page's bundle.
-    const [, headBuffer] = await renderSegmentPrefetch(buildId, staleTimeIterable, head, _segmentvalueencoding.HEAD_REQUEST_KEY, initialRSCPayload.h, rootVaryParamsIterable, clientModules, null, // Fallback-ness doesn't affect size, so pass false.
+    const [, headBuffer] = await renderSegmentPrefetch(buildId, staleTimeIterable, null, _segmentvalueencoding.HEAD_REQUEST_KEY, rootSpine, null, {
+        rsc: head,
+        varyParams: initialRSCPayload.t.h.v
+    }, rootVaryParamsIterable, clientModules, // Fallback-ness doesn't affect size, so pass false.
     false, needsRuntimeRequest, shellStageRelease);
     const headGzipSize = await getGzipSize(headBuffer);
     // Mutable accumulator: the first segment that accepts the head sets this
@@ -289,7 +313,7 @@ async function collectPrefetchHints(fullPageDataBuffer, staleTime, clientModules
         inlined: false
     };
     // Walk the tree with the parent-first, child-decides algorithm.
-    const { node } = await collectPrefetchHintsImpl(flightRouterState, buildId, staleTimeIterable, seedData, clientModules, _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY, null, baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParamsIterable, needsRuntimeRequest, shellStageRelease);
+    const { node } = await collectPrefetchHintsImpl(isCacheComponentsEnabled, rootNode, buildId, staleTimeIterable, clientModules, _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY, rootSpine, null, baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParamsIterable, needsRuntimeRequest, shellStageRelease);
     if (!headInlineState.inlined) {
         // No page could accept the head. Set HeadOutlined on the root so the
         // client knows to fetch the head separately.
@@ -322,11 +346,11 @@ async function collectPrefetchHints(fullPageDataBuffer, staleTime, clientModules
 // the cumulative inlined bytes past maxBundleSize. This produces
 // both ParentInlinedIntoSelf (on the child) and InlinedIntoChild (on the
 // parent) in a single pass.
-async function collectPrefetchHintsImpl(route, buildId, staleTimeIterable, seedData, clientModules, // TODO: Consider persisting the computed requestKey into the hints output
+async function collectPrefetchHintsImpl(isClientParamParsingEnabled, node, buildId, staleTimeIterable, clientModules, // TODO: Consider persisting the computed requestKey into the hints output
 // so it doesn't need to be recomputed during the build. This might also
 // suggest renaming prefetch-hints.json to something like
 // segment-manifest.json, since it would contain more than just hints.
-requestKey, parentGzipSize, // Hints every node starts from (the page-global static-prefetch-attempt
+requestKey, spine, parentGzipSize, // Hints every node starts from (the page-global static-prefetch-attempt
 // hint); the inlining bits computed here are OR'd on top.
 baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParamsIterable, needsRuntimeRequest, shellStageRelease) {
     // Check if static prefetching is disabled for this segment
@@ -342,12 +366,16 @@ baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParams
     // the client can attempt a static prefetch before deciding whether the
     // runtime request is needed — and are measured and inlined like any other
     // segment.
-    const isStaticPrefetchDisabled = ((route[4] ?? 0) & _approutertypes.StaticPrefetchDisabled) !== 0;
+    const isStaticPrefetchDisabled = ((node.h ?? 0) & _approutertypes.StaticPrefetchDisabled) !== 0;
     // Render current segment and measure its gzip size. Skip measurement for
     // segments with static prefetching disabled since they contribute nothing.
+    const nodeRsc = node.d.r;
     let currentGzipSize = null;
-    if (!isStaticPrefetchDisabled && seedData !== null) {
-        const [, buffer] = await renderSegmentPrefetch(buildId, staleTimeIterable, seedData[0], requestKey, seedData[4], rootVaryParamsIterable, clientModules, null, // Size-measurement pass only; fallback-ness is irrelevant here.
+    if (!isStaticPrefetchDisabled && nodeRsc !== null) {
+        const [, buffer] = await renderSegmentPrefetch(buildId, staleTimeIterable, {
+            rsc: nodeRsc,
+            varyParams: node.d.v
+        }, requestKey, spine, null, null, rootVaryParamsIterable, clientModules, // Size-measurement pass only; fallback-ness is irrelevant here.
         false, needsRuntimeRequest, shellStageRelease);
         currentGzipSize = await getGzipSize(buffer);
     }
@@ -362,8 +390,7 @@ baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParams
     // accepts, we stop offering to remaining siblings — the parent is only
     // inlined into one child. In parallel routes, this avoids duplicating the
     // parent's data across multiple sibling responses.
-    const children = route[1];
-    const seedDataChildren = seedData !== null ? seedData[1] : null;
+    const children = node.c;
     let slots = null;
     let didInlineIntoChild = false;
     let acceptingChildInlinedBytes = 0;
@@ -372,43 +399,47 @@ baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParams
     // can accept its data, the parent's bytes would flow through to the child
     // with the most remaining headroom.
     let smallestChildInlinedBytes = Infinity;
-    let hasChildren = false;
-    for(const parallelRouteKey in children){
-        hasChildren = true;
-        const childRoute = children[parallelRouteKey];
-        const childSegment = childRoute[0];
-        const childSeedData = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] ?? null : null;
-        const childRequestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(requestKey, parallelRouteKey, (0, _segmentvalueencoding.createSegmentRequestKeyPart)(childSegment));
-        // Determine what size to offer children for inlining. Normally we offer
-        // our own size. But if static prefetching is disabled for this segment,
-        // it has no data of its own — instead it passes the parent's offer
-        // through to children. This allows a static grandparent to inline
-        // through a disabled intermediate segment into a static grandchild.
-        const sizeToOfferChild = isStaticPrefetchDisabled ? parentGzipSize : sizeToInline;
-        const childResult = await collectPrefetchHintsImpl(childRoute, buildId, staleTimeIterable, childSeedData, clientModules, childRequestKey, // Once a child has accepted us, stop offering to remaining siblings.
-        didInlineIntoChild ? null : sizeToOfferChild, baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParamsIterable, needsRuntimeRequest, shellStageRelease);
-        if (slots === null) {
-            slots = {};
-        }
-        slots[parallelRouteKey] = childResult.node;
-        if (childResult.node.hints & _approutertypes.PrefetchHint.ParentInlinedIntoSelf) {
-            // This child accepted our data — it will include our segment's
-            // response in its own. No need to track headroom anymore since
-            // we already know which child we're inlined into.
-            didInlineIntoChild = true;
-            acceptingChildInlinedBytes = childResult.inlinedBytes;
-        } else if (!didInlineIntoChild) {
-            // Track the child with the most remaining headroom. Used below
-            // when deciding whether to accept our own parent's data.
-            if (childResult.inlinedBytes < smallestChildInlinedBytes) {
-                smallestChildInlinedBytes = childResult.inlinedBytes;
+    if (children === undefined) {
+        // Leaf segment: no children have consumed any budget yet.
+        smallestChildInlinedBytes = 0;
+    } else {
+        for (const [parallelRouteKey, childNode] of children){
+            const childRequestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(requestKey, parallelRouteKey, (0, _segmentvalueencoding.createSegmentRequestKeyPart)((0, _rsctransport.transportSegmentToSegment)(childNode.s)));
+            // Determine what size to offer children for inlining. Normally we offer
+            // our own size. But if static prefetching is disabled for this segment,
+            // it has no data of its own — instead it passes the parent's offer
+            // through to children. This allows a static grandparent to inline
+            // through a disabled intermediate segment into a static grandchild.
+            const sizeToOfferChild = isStaticPrefetchDisabled ? parentGzipSize : sizeToInline;
+            const childResult = await collectPrefetchHintsImpl(isClientParamParsingEnabled, childNode, buildId, staleTimeIterable, clientModules, childRequestKey, {
+                segment: createPrefetchTransportSegment(childNode.s, isClientParamParsingEnabled),
+                // Best-available approximation of the merged hints, for
+                // representative sizes — see the root spine in
+                // collectPrefetchHints.
+                prefetchHints: ((childNode.h ?? 0) | baseHints) & ~_approutertypes.PrefetchHint.InliningHintsStale,
+                parallelRouteKey,
+                parent: spine
+            }, // Once a child has accepted us, stop offering to remaining siblings.
+            didInlineIntoChild ? null : sizeToOfferChild, baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParamsIterable, needsRuntimeRequest, shellStageRelease);
+            if (slots === null) {
+                slots = {};
+            }
+            slots[parallelRouteKey] = childResult.node;
+            if (childResult.node.hints & _approutertypes.PrefetchHint.ParentInlinedIntoSelf) {
+                // This child accepted our data — it will include our segment's
+                // response in its own. No need to track headroom anymore since
+                // we already know which child we're inlined into.
+                didInlineIntoChild = true;
+                acceptingChildInlinedBytes = childResult.inlinedBytes;
+            } else if (!didInlineIntoChild) {
+                // Track the child with the most remaining headroom. Used below
+                // when deciding whether to accept our own parent's data.
+                if (childResult.inlinedBytes < smallestChildInlinedBytes) {
+                    smallestChildInlinedBytes = childResult.inlinedBytes;
+                }
             }
         }
     }
-    // Leaf segment: no children have consumed any budget yet.
-    if (!hasChildren) {
-        smallestChildInlinedBytes = 0;
-    }
     // Mark this segment as InlinedIntoChild if one of its children accepted.
     // This means this segment doesn't need its own prefetch response — its
     // data is included in the accepting child's response instead.
@@ -443,8 +474,8 @@ baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParams
     // always be reachable through the static responses — inlined into one of
     // them, or outlined.
     const isBundleTerminal = !didInlineIntoChild && !isStaticPrefetchDisabled;
-    const segment = route[0];
-    const isPageSegment = typeof segment === 'string' ? segment === _segment.PAGE_SEGMENT_KEY : segment[0] === _segment.PAGE_SEGMENT_KEY;
+    const segment = node.s;
+    const isPageSegment = typeof segment === 'string' ? segment === _segment.PAGE_SEGMENT_KEY : segment.n === _segment.PAGE_SEGMENT_KEY;
     if (!headInlineState.inlined && isBundleTerminal && isPageSegment) {
         // The head counts against the bundle budget.
         if (inlinedBytes + headGzipSize < maxBundleSize) {
@@ -497,17 +528,19 @@ baseHints, maxSize, maxBundleSize, headGzipSize, headInlineState, rootVaryParams
 // collectPrefetchHints when prefetch inlining is disabled: there are no sizes
 // to measure, but the static-prefetch-attempt hint still needs a manifest
 // tree — the client reads the bit per node, and the runtime hint merging
-// (createFlightRouterStateFromLoaderTree) walks the manifest tree in parallel
+// (createTransportTreeFromLoaderTree) walks the manifest tree in parallel
 // with the loader tree, so a bit that's missing from a node never reaches the
 // corresponding segment.
-function createUniformHintTree(route, hints) {
+function createUniformHintTree(node, hints) {
     let slots = null;
-    const children = route[1];
-    for(const parallelRouteKey in children){
-        if (slots === null) {
-            slots = {};
+    const children = node.c;
+    if (children !== undefined) {
+        for (const [parallelRouteKey, childNode] of children){
+            if (slots === null) {
+                slots = {};
+            }
+            slots[parallelRouteKey] = createUniformHintTree(childNode, hints);
         }
-        slots[parallelRouteKey] = createUniformHintTree(children[parallelRouteKey], hints);
     }
     return {
         hints,
@@ -538,17 +571,17 @@ async function PrefetchTreeData({ isClientParamParsingEnabled, pageDataStream, s
     // This is the decode that everything downstream reads from: the route tree
     // walk below and, through it, every segment task. When staged, the values
     // extracted here hold pending references at the param-dependent holes; the
-    // shell byte prefix carries the full router tree and seed-data skeleton, so
-    // the root resolves from the prefix alone (the rest arrives at the release).
+    // shell byte prefix carries the full router tree and the skeleton of every
+    // segment's data, so the root resolves from the prefix alone (the rest
+    // arrives at the release).
     const initialRSCPayload = await (0, _client.createFromReadableStream)(pageDataStream, {
         findSourceMapURL,
         serverConsumerManifest
     });
-    const flightData = extractFlightData(initialRSCPayload);
-    if (flightData === null) {
-        return null;
-    }
-    const { buildId, flightRouterState, seedData, head } = flightData;
+    const transportData = initialRSCPayload.t;
+    const rootNode = transportData.t;
+    const buildId = initialRSCPayload.b;
+    const head = transportData.h.r;
     // Root params are forwarded once at the top level of each segment
     // response, same as the page response's own root vary params; the client
     // unions them into each segment's set at read time.
@@ -564,65 +597,80 @@ async function PrefetchTreeData({ isClientParamParsingEnabled, pageDataStream, s
     // Only applies when prefetch inlining is enabled — the client doesn't
     // know to look for the head inside a page's response otherwise.
     const headIsInlined = prefetchInlining && hints !== null && !(hints.hints & _approutertypes.PrefetchHint.HeadOutlined);
-    // Compute the route metadata tree by traversing the FlightRouterState. As we
-    // walk the tree, we will also spawn a task to produce a prefetch response for
-    // each segment. When prefetch inlining is enabled, small segments are bundled
-    // into their children's responses based on the hint bits.
-    const headBundle = headIsInlined ? {
+    // Compute the route metadata tree by traversing the page payload's
+    // transport tree. As we walk the tree, we will also spawn a task to produce
+    // a prefetch response for each segment. When prefetch inlining is enabled,
+    // small segments are bundled into their children's responses based on the
+    // hint bits.
+    const headData = {
         rsc: head,
-        varyParams: initialRSCPayload.h,
-        next: null
-    } : null;
-    const tree = collectSegmentDataImpl(isClientParamParsingEnabled, flightRouterState, buildId, staleTimeIterable, seedData, clientModules, _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY, segmentTasks, prefetchInlining, hints, null, headBundle, rootVaryParamsIterable, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease);
+        varyParams: initialRSCPayload.t.h.v
+    };
+    const rootSpine = {
+        segment: createPrefetchTransportSegment(rootNode.s, isClientParamParsingEnabled),
+        prefetchHints: 0,
+        parallelRouteKey: null,
+        parent: null
+    };
+    const tree = collectSegmentDataImpl(isClientParamParsingEnabled, rootNode, buildId, staleTimeIterable, clientModules, _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY, rootSpine, segmentTasks, prefetchInlining, hints, null, headIsInlined ? headData : null, rootVaryParamsIterable, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease);
     // Spawn a task to produce a prefetch response for the "head" segment,
     // unless it was inlined into a page's bundle.
     if (!headIsInlined) {
-        segmentTasks.push((0, _scheduler.waitAtLeastOneReactRenderTask)().then(()=>renderSegmentPrefetch(buildId, staleTimeIterable, head, _segmentvalueencoding.HEAD_REQUEST_KEY, initialRSCPayload.h, rootVaryParamsIterable, clientModules, null, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease)));
+        segmentTasks.push((0, _scheduler.waitAtLeastOneReactRenderTask)().then(()=>renderSegmentPrefetch(buildId, staleTimeIterable, null, _segmentvalueencoding.HEAD_REQUEST_KEY, rootSpine, null, headData, rootVaryParamsIterable, clientModules, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease)));
     }
     // Notify the abort controller that we're done processing the route tree.
     // Anything async that happens after this point must be due to hanging
     // promises in the original stream.
     onCompletedProcessingRouteTree();
-    // Render the route tree to a special `/_tree` segment.
-    const treePrefetch = {
-        tree,
-        staleTime
+    // Render the route tree to a special `/_tree` segment. The response is an
+    // ordinary PrefetchFlightResponse carrying only a buildId and a
+    // structure-only tree.
+    return buildId ? {
+        b: buildId,
+        t: {
+            t: tree
+        }
+    } : {
+        t: {
+            t: tree
+        }
     };
-    if (buildId) {
-        treePrefetch.buildId = buildId;
-    }
-    return treePrefetch;
 }
-function collectSegmentDataImpl(isClientParamParsingEnabled, route, buildId, staleTimeIterable, seedData, clientModules, requestKey, segmentTasks, prefetchInlining, hintTree, parentBundle, headBundle, rootVaryParamsIterable, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease) {
-    // Union the hints already embedded in the FlightRouterState with the
+function collectSegmentDataImpl(isClientParamParsingEnabled, node, buildId, staleTimeIterable, clientModules, requestKey, // The identity path from the root down to this segment, used by each
+// spawned segment response to emit a root-anchored tree.
+spine, segmentTasks, prefetchInlining, hintTree, parentBundle, headData, rootVaryParamsIterable, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease) {
+    // Union the hints already embedded in the page payload's tree with the
     // separately-computed build-time hints. During the initial build, the
-    // FlightRouterState was produced before collectPrefetchHints ran, so
-    // inlining hints (ParentInlinedIntoSelf, InlinedIntoChild) won't be in
-    // route[4] yet. On subsequent renders the hints are already in the
-    // FlightRouterState, so the union is idempotent.
+    // payload was produced before collectPrefetchHints ran, so inlining hints
+    // (ParentInlinedIntoSelf, InlinedIntoChild) won't be in the node's hints
+    // yet. On subsequent renders the hints are already there, so the union is
+    // idempotent.
     //
     // Always strip InliningHintsStale from the result. That bit is only
     // relevant for the initial RSC payload baked into HTML — the /_tree
     // response produced here always has correct hints, so the client should
     // never see InliningHintsStale in a /_tree response.
-    const prefetchHints = ((route[4] ?? 0) | (hintTree !== null ? hintTree.hints : 0)) & ~_approutertypes.PrefetchHint.InliningHintsStale;
+    const prefetchHints = ((node.h ?? 0) | (hintTree !== null ? hintTree.hints : 0)) & ~_approutertypes.PrefetchHint.InliningHintsStale;
+    // Record the merged hints on this segment's spine node, so every segment
+    // response whose tree passes through this position emits them (see
+    // SegmentSpine). Spawned response renders run after the walk, so the
+    // mutation is always visible to them.
+    spine.prefetchHints = prefetchHints;
     // The params this segment's own output varies on, forwarded into its
     // response as-is. Root params are forwarded separately, once per response.
-    const varyParams = seedData !== null ? seedData[4] : null;
-    // If static prefetching is disabled for this segment
-    // (prefetch: 'force-disabled' / instant = false), it still participates in
-    // the bundle chain but with null data. The client will skip creating a
-    // cache entry for it.
+    const varyParams = node.d.v;
+    // If static prefetching is disabled for this segment (prefetch: 'force-disabled'),
+    // it still participates in the bundle chain but with null data.
+    // Its node in the response tree carries identity only, so the client skips
+    // creating a cache entry for it.
     //
     // Partial Prefetching segments are NOT disabled even though they may need
-    // a runtime prefetch: their static data is emitted UNCONDITIONALLY — it
-    // can't be gated on the ShouldAttemptStaticPrefetch hint, because the
-    // client walks bundles positionally and the null-slot positions must be
-    // deterministic from build-time config alone. The client uses the data to
-    // attempt a static prefetch before deciding whether the segment's runtime
-    // request is actually needed.
+    // a runtime prefetch: their static data is emitted UNCONDITIONALLY, so the
+    // client can use it to attempt a static prefetch before deciding whether
+    // the segment's runtime request is actually needed.
     const staticPrefetchDisabled = (prefetchHints & _approutertypes.StaticPrefetchDisabled) !== 0;
-    const rsc = seedData !== null && !staticPrefetchDisabled ? seedData[0] : null;
+    const nodeRsc = node.d.r;
+    const rsc = !staticPrefetchDisabled ? nodeRsc : null;
     // Determine whether this segment's data should be accumulated into a
     // child's response (inlining) or spawned as its own task. When inlining
     // is disabled, the hint bits may still be set (they're computed at build
@@ -635,10 +683,12 @@ function collectSegmentDataImpl(isClientParamParsingEnabled, route, buildId, sta
         // of its children's responses. Don't spawn a separate task — prepend
         // this segment's data onto the linked list so the accepting child can
         // bundle it into its response.
-        if (seedData !== null) {
+        if (nodeRsc !== null) {
             childBundle = {
-                rsc,
-                varyParams,
+                data: rsc !== null ? {
+                    rsc,
+                    varyParams
+                } : null,
                 next: parentBundle
             };
         }
@@ -650,58 +700,53 @@ function collectSegmentDataImpl(isClientParamParsingEnabled, route, buildId, sta
         //
         // Skip spawning a task if rsc is null (disabled segment) — there's no
         // data to serve and the client won't request it.
-        if (seedData !== null && rsc !== null) {
-            let bundle = prefetchHints & _approutertypes.PrefetchHint.ParentInlinedIntoSelf ? parentBundle : null;
-            // If this page accepts the head, append it at the tail of the chain.
-            if (headBundle !== null && prefetchHints & _approutertypes.PrefetchHint.HeadInlinedIntoSelf) {
-                headBundle.next = bundle;
-                bundle = headBundle;
-            }
-            segmentTasks.push((0, _scheduler.waitAtLeastOneReactRenderTask)().then(()=>renderSegmentPrefetch(buildId, staleTimeIterable, rsc, requestKey, varyParams, rootVaryParamsIterable, clientModules, bundle, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease)));
+        if (rsc !== null) {
+            const bundle = prefetchHints & _approutertypes.PrefetchHint.ParentInlinedIntoSelf ? parentBundle : null;
+            // If this page accepts the head, include it in the response, where it
+            // rides on the envelope (a response's tree only carries route
+            // segments; the head has no tree position).
+            const headForResponse = headData !== null && prefetchHints & _approutertypes.PrefetchHint.HeadInlinedIntoSelf ? headData : null;
+            segmentTasks.push((0, _scheduler.waitAtLeastOneReactRenderTask)().then(()=>renderSegmentPrefetch(buildId, staleTimeIterable, {
+                    rsc,
+                    varyParams
+                }, requestKey, spine, bundle, headForResponse, rootVaryParamsIterable, clientModules, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease)));
         }
     // childBundle stays null — reset the accumulator for children.
     }
-    // Metadata about the segment. Sent as part of the tree prefetch. Null if
-    // there are no children.
-    let slotMetadata = null;
-    const children = route[1];
-    const seedDataChildren = seedData !== null ? seedData[1] : null;
-    for(const parallelRouteKey in children){
-        const childRoute = children[parallelRouteKey];
-        const childSegment = childRoute[0];
-        const childSeedData = seedDataChildren !== null ? seedDataChildren[parallelRouteKey] ?? null : null;
-        const childRequestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(requestKey, parallelRouteKey, (0, _segmentvalueencoding.createSegmentRequestKeyPart)(childSegment));
-        const childHintTree = hintTree !== null && hintTree.slots !== null ? hintTree.slots[parallelRouteKey] ?? null : null;
-        const childTree = collectSegmentDataImpl(isClientParamParsingEnabled, childRoute, buildId, staleTimeIterable, childSeedData, clientModules, childRequestKey, segmentTasks, prefetchInlining, childHintTree, childBundle, headBundle, rootVaryParamsIterable, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease);
-        if (slotMetadata === null) {
-            slotMetadata = {};
+    // The child nodes of the tree prefetch. Sent to the client as part of the
+    // /_tree response.
+    let slots;
+    const children = node.c;
+    if (children !== undefined) {
+        for (const [parallelRouteKey, childNode] of children){
+            const childRequestKey = (0, _segmentvalueencoding.appendSegmentRequestKeyPart)(requestKey, parallelRouteKey, (0, _segmentvalueencoding.createSegmentRequestKeyPart)((0, _rsctransport.transportSegmentToSegment)(childNode.s)));
+            const childHintTree = hintTree !== null && hintTree.slots !== null ? hintTree.slots[parallelRouteKey] ?? null : null;
+            const childTree = collectSegmentDataImpl(isClientParamParsingEnabled, childNode, buildId, staleTimeIterable, clientModules, childRequestKey, {
+                segment: createPrefetchTransportSegment(childNode.s, isClientParamParsingEnabled),
+                prefetchHints: 0,
+                parallelRouteKey,
+                parent: spine
+            }, segmentTasks, prefetchInlining, childHintTree, childBundle, headData, rootVaryParamsIterable, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease);
+            if (slots === undefined) {
+                slots = new Map();
+            }
+            slots.set(parallelRouteKey, childTree);
         }
-        slotMetadata[parallelRouteKey] = childTree;
     }
-    const segment = route[0];
-    let name;
-    let param;
-    if (typeof segment === 'string') {
-        name = segment;
-        param = null;
-    } else {
-        name = segment[0];
-        param = {
-            type: segment[2],
-            // This value is omitted from the prefetch response when cacheComponents
-            // is enabled.
-            key: isClientParamParsingEnabled ? null : segment[1],
-            siblings: segment[3]
-        };
-    }
-    // Metadata about the segment. Sent to the client as part of the
-    // tree prefetch.
-    return {
-        name,
-        param,
-        prefetchHints,
-        slots: slotMetadata
+    // Structure of the segment — identity and hints, no render output. Sent to
+    // the client as part of the /_tree response. The identity is shared with
+    // this segment's own spine node (same object), where it serves the same
+    // purpose for the per-segment responses.
+    const treeNode = {
+        s: spine.segment
     };
+    if (prefetchHints !== 0) {
+        treeNode.h = prefetchHints;
+    }
+    if (slots !== undefined) {
+        treeNode.c = slots;
+    }
+    return treeNode;
 }
 /**
  * Renders one segment prefetch response, and with it a shell byte boundary
@@ -719,67 +764,88 @@ function collectSegmentDataImpl(isClientParamParsingEnabled, route, buildId, sta
  *
  * Uses the streaming renderer, not `prerender`, because the boundary must be
  * observed mid-stream — `prerender` only exposes its prelude once finished.
- */ async function renderSegmentPrefetch(buildId, staleTime, rsc, requestKey, varyParams, rootVaryParams, clientModules, bundle, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease) {
+ */ async function renderSegmentPrefetch(buildId, staleTime, // Data for the requested (terminal) segment. Null for the standalone head
+// response, which has no tree position (its tree is the bare root
+// identity). Disabled segments are skipped by the caller.
+terminal, requestKey, // The identity path from the root to the terminal segment (the root
+// itself for the standalone head response).
+spine, // The data of the ancestors bundled into this response, nearest ancestor
+// first, aligned with the spine's innermost ancestors.
+bundle, // The head's data, when it's bundled into this response (or when this IS
+// the standalone head response).
+head, rootVaryParams, clientModules, isUpgradeableISRFallback, needsRuntimeRequest, shellStageRelease) {
     const streamInfoStage = (0, _promisewithresolvers.createPromiseWithResolvers)();
-    // Build the data array by walking the bundle list, terminal (requested)
-    // segment first. Always an array, even for a single segment; the terminal
-    // always has non-null rsc — disabled segments are skipped by the caller.
-    const data = [];
+    // Build the response's root-anchored tree: start at the terminal segment,
+    // which carries data (identity only for the standalone head response),
+    // then wrap upward along the identity spine. Ancestors carry data while
+    // the bundle chain lasts (it's contiguous and aligned with the innermost
+    // ancestors); a chain node with null data is a segment with static
+    // prefetching disabled, and it — like every ancestor above the chain —
+    // carries identity only, which the client treats as "no claim" (no cache
+    // entry is created). Every node carries the same prefetch hints the /_tree
+    // response emits for it, so the tree is decodable like any other transport
+    // tree (see SegmentSpine).
     let node = {
-        rsc,
-        varyParams,
-        next: bundle
+        s: spine.segment
     };
-    while(node !== null){
-        const elementRsc = node.rsc;
-        if (elementRsc === null) {
-            // Static prefetching disabled (prefetch: 'force-disabled'; Partial
-            // Prefetching segments carry real data): a null placeholder keeps the
-            // array aligned with the client's bundle list, which skips a cache
-            // entry for the slot.
-            data.push(null);
-        } else {
-            // We can determine if a segment contains only partial data if it takes
-            // longer than a task to encode, because dynamic data is encoded as an
-            // infinite promise. We must do this in a separate Flight prerender from
-            // the one that actually generates the prefetch stream because we need
-            // to include the result in the stream itself.
-            const contentIsComplete = new Promise(async (resolve)=>{
-                // Wait for the input stream to be fully unblocked before checking if
-                // the data can be decoded synchronously.
-                await streamInfoStage.promise;
-                // If the data is fully static, this will resolve synchronously.
-                // Otherwise, the promise stays unresolved forever, and so does
-                // whatever field it's encoded into in the outer response.
-                await (0, _static.prerender)(elementRsc, clientModules, {
-                    filterStackFrame,
-                    onError () {}
-                });
-                resolve();
-            });
-            data.push({
-                rsc: elementRsc,
-                isPartial: contentIsComplete,
-                staleTime,
-                varyParams: node.varyParams
-            });
+    if (spine.prefetchHints !== 0) {
+        node.h = spine.prefetchHints;
+    }
+    if (terminal !== null) {
+        node.d = createStagedSegmentData(terminal, staleTime, clientModules, streamInfoStage.promise);
+    }
+    let edgeParallelRouteKey = spine.parallelRouteKey;
+    let ancestor = spine.parent;
+    let bundleNode = bundle;
+    while(ancestor !== null && edgeParallelRouteKey !== null){
+        const parentNode = {
+            s: ancestor.segment
+        };
+        if (ancestor.prefetchHints !== 0) {
+            parentNode.h = ancestor.prefetchHints;
+        }
+        if (bundleNode !== null) {
+            if (bundleNode.data !== null) {
+                parentNode.d = createStagedSegmentData(bundleNode.data, staleTime, clientModules, streamInfoStage.promise);
+            }
+            bundleNode = bundleNode.next;
         }
-        node = node.next;
+        parentNode.c = new Map([
+            [
+                edgeParallelRouteKey,
+                node
+            ]
+        ]);
+        node = parentNode;
+        edgeParallelRouteKey = ancestor.parallelRouteKey;
+        ancestor = ancestor.parent;
+    }
+    const transportData = {
+        t: node
+    };
+    if (head !== null) {
+        transportData.h = createStagedSegmentData(head, staleTime, clientModules, streamInfoStage.promise);
     }
     const responseKey = requestKey === _segmentvalueencoding.ROOT_SEGMENT_REQUEST_KEY ? '/_index' : requestKey;
-    // `a` (see SegmentPrefetchResponse['a']) is resolved below, once the shell
-    // stage's bytes have been counted.
+    // `a` (see PrefetchFlightResponse['a']) is resolved below, once the
+    // shell stage's bytes have been counted.
     let totalByteLength = 0;
     const shellByteOffset = (0, _promisewithresolvers.createPromiseWithResolvers)();
-    // Wrap in the response envelope with the build ID at the top level.
+    // Wrap in the response envelope — an ordinary PrefetchFlightResponse.
     const payload = {
-        buildId: buildId ?? '',
-        data,
-        isUpgradeableISRFallback,
+        t: transportData,
         a: shellByteOffset.promise,
-        rootVaryParams,
-        needsRuntimeRequest
+        u: needsRuntimeRequest
     };
+    if (buildId) {
+        payload.b = buildId;
+    }
+    if (rootVaryParams !== null) {
+        payload.r = rootVaryParams;
+    }
+    if (isUpgradeableISRFallback) {
+        payload.f = true;
+    }
     const abortController = new AbortController();
     const segmentStream = (0, _server.renderToReadableStream)(payload, clientModules, {
         filterStackFrame,
@@ -862,35 +928,35 @@ function collectSegmentDataImpl(isClientParamParsingEnabled, route, buildId, sta
         Buffer.concat(await chunksPromise)
     ];
 }
-/**
- * Reads the page's runtime-data-access flag (the payload's `u`) from a decode
- * of the fully-settled page buffer. Because every byte is present, the
- * promise's row (if the render emitted one) is already visible on its
- * thenable status, so this never blocks — the same trick the client cache
- * uses to read staleTime from a buffered response.
- *
- * - fulfilled: the recorded flag.
- * - pending: `false`. A successful render always settles the flag (prerender
- *   completion resolves `false`), so a pending row can only appear in an
- *   aborted render's buffer, where it means no access was recorded before
- *   the abort.
- * - rejected: `true`, conservatively — an abort errors rows that were still
- *   pending when it happened.
- */ function readRuntimeDataAccessed(runtimeDataAccessed) {
-    const promise = runtimeDataAccessed;
-    // Force Flight to unwrap a received-but-not-yet-settled row.
-    promise.then(ignoreChunk, ignoreChunk);
-    switch(promise.status){
-        case 'fulfilled':
-            return promise.value === true;
-        case 'rejected':
-            return true;
-        case undefined:
-        default:
-            return false;
-    }
+// Attaches the staged per-segment fields to a segment's data. We can
+// determine if a segment contains only partial data if it takes longer
+// than a task to encode, because dynamic data is encoded as an infinite
+// promise. We must do this in a separate Flight prerender from the one
+// that actually generates the prefetch stream because we need to include
+// the result in the stream itself.
+function createStagedSegmentData(data, staleTime, clientModules, // The response's streamInfoStage gate; the completeness probe must not
+// start until it resolves, i.e. until the input stream is fully unblocked.
+streamInfoStage) {
+    const contentIsComplete = new Promise(async (resolve)=>{
+        // Wait for the input stream to be fully unblocked before checking if
+        // the data can be decoded synchronously.
+        await streamInfoStage;
+        // If the data is fully static, this will resolve synchronously.
+        // Otherwise, the promise stays unresolved forever, and so does
+        // whatever field it's encoded into in the outer response.
+        await (0, _static.prerender)(data.rsc, clientModules, {
+            filterStackFrame,
+            onError () {}
+        });
+        resolve();
+    });
+    return {
+        r: data.rsc,
+        p: contentIsComplete,
+        v: data.varyParams,
+        s: staleTime
+    };
 }
-function ignoreChunk() {}
 // Wraps a known staleTime value in the same async-iterable shape as the page
 // response's `s`, so segment responses carry staleTime uniformly (and
 // rewindably) whether or not Cache Components supplied a real `s` iterable.