failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/server/app-render/instant-validation/instant-validation.js

@@ -34,6 +34,7 @@ _export(exports, {
 });
 const _jsxruntime = require("react/jsx-runtime");
 const _invarianterror = require("../../../shared/lib/invariant-error");
+const _rsctransport = require("../../../shared/lib/rsc-transport");
 const _stagedrendering = require("../staged-rendering");
 const _manifestssingleton = require("../manifests-singleton");
 const _apprenderrenderutils = require("../app-render-render-utils");
@@ -53,30 +54,19 @@ const filterStackFrame = process.env.NODE_ENV !== 'production' ? require('../../
 const findSourceMapURL = process.env.NODE_ENV !== 'production' ? require('../../lib/source-maps').findSourceMapURLDEV : undefined;
 const debug = process.env.NEXT_PRIVATE_DEBUG_VALIDATION === '1' ? console.log : undefined;
 function traverseRootSeedDataSegments(initialRSCPayload, processSegment) {
-    const { flightRouterState, seedData } = getRootDataFromPayload(initialRSCPayload);
-    const [rootSegment] = flightRouterState;
-    const rootPath = stringifySegment(rootSegment);
-    return traverseCacheNodeSegments(rootPath, flightRouterState, seedData, processSegment);
+    const rootNode = initialRSCPayload.t.t;
+    const rootPath = stringifySegment((0, _rsctransport.transportSegmentToSegment)(rootNode.s));
+    return traverseTransportNodeSegments(rootPath, rootNode, processSegment);
 }
-function traverseCacheNodeSegments(path, route, seedData, processSegment) {
-    processSegment(path, seedData);
-    const [_segment, childRoutes] = route;
-    const [_node, parallelRoutesData, _loading, _isPartial] = seedData;
-    for(const parallelRouteKey in childRoutes){
-        const childSeedData = parallelRoutesData[parallelRouteKey];
-        if (!childSeedData) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Got unexpected empty seed data during instant validation`), "__NEXT_ERROR_CODE", {
-                value: "E992",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        const childRoute = childRoutes[parallelRouteKey];
-        // NOTE: if this is a __PAGE__ segment, it might have search params appended.
-        // Whoever reads from the cache needs to append them as well.
-        const [childSegment] = childRoute;
-        const childPath = createChildSegmentPath(path, parallelRouteKey, childSegment);
-        traverseCacheNodeSegments(childPath, childRoute, childSeedData, processSegment);
+function traverseTransportNodeSegments(path, node, processSegment) {
+    processSegment(path, node.d);
+    const children = node.c;
+    if (children === undefined) {
+        return;
+    }
+    for (const [parallelRouteKey, childNode] of children){
+        const childPath = createChildSegmentPath(path, parallelRouteKey, (0, _rsctransport.transportSegmentToSegment)(childNode.s));
+        traverseTransportNodeSegments(childPath, childNode, processSegment);
     }
 }
 function createChildSegmentPath(parentPath, parallelRouteKey, segment) {
@@ -90,11 +80,24 @@ async function collectStagedSegmentData(prefetchKind, ComponentMod, renderFlight
     const cache = createSegmentCache();
     let partialStages;
     switch(prefetchKind){
+        case 2:
+            {
+                partialStages = [
+                    _stagedrendering.RenderStage.ShellStatic,
+                    _stagedrendering.RenderStage.PrefetchStatic_prefetchApi,
+                    _stagedrendering.RenderStage.PrefetchStatic,
+                    _stagedrendering.RenderStage.NavigationStatic,
+                    _stagedrendering.RenderStage.PrefetchRuntime
+                ];
+                break;
+            }
         case 1:
             {
                 partialStages = [
                     _stagedrendering.RenderStage.ShellRuntime,
-                    _stagedrendering.RenderStage.Runtime
+                    _stagedrendering.RenderStage.PrefetchRuntime_prefetchApi,
+                    _stagedrendering.RenderStage.PrefetchRuntime,
+                    _stagedrendering.RenderStage.NavigationRuntime
                 ];
                 break;
             }
@@ -102,7 +105,7 @@ async function collectStagedSegmentData(prefetchKind, ComponentMod, renderFlight
             {
                 partialStages = [
                     _stagedrendering.RenderStage.Static,
-                    _stagedrendering.RenderStage.Runtime
+                    _stagedrendering.RenderStage.PrefetchRuntime
                 ];
                 break;
             }
@@ -136,20 +139,22 @@ async function collectSegmentDataForStage(ComponentMod, renderFlightStream, full
         const currentStage = controller.currentStage;
         switch(currentStage){
             case _stagedrendering.RenderStage.Before:
+            case _stagedrendering.RenderStage.ShellStatic:
+            case _stagedrendering.RenderStage.PrefetchStatic_prefetchApi:
+            case _stagedrendering.RenderStage.PrefetchStatic:
             case _stagedrendering.RenderStage.Static:
+            case _stagedrendering.RenderStage.NavigationStatic:
                 return 'Prerender';
             case _stagedrendering.RenderStage.ShellRuntime:
-            case _stagedrendering.RenderStage.Runtime:
+            case _stagedrendering.RenderStage.PrefetchRuntime_prefetchApi:
+            case _stagedrendering.RenderStage.PrefetchRuntime:
+            case _stagedrendering.RenderStage.NavigationRuntime:
                 return 'Prefetch';
             case _stagedrendering.RenderStage.Dynamic:
                 return 'Server';
             default:
                 currentStage;
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${currentStage}`), "__NEXT_ERROR_CODE", {
-                    value: "E881",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Invalid render stage: ${currentStage}`);
         }
     };
     // Deserialize the payload partially so that we can traverse the structure.
@@ -180,7 +185,7 @@ async function collectSegmentDataForStage(ComponentMod, renderFlightStream, full
     // Deconstruct the payload into separate streams per segment.
     // We have to preserve the stage information for each of them,
     // so that we can later render each segment in any stage we need.
-    const { head } = getRootDataFromPayload(payload);
+    const head = payload.t.h.r;
     const segments = new Map();
     traverseRootSeedDataSegments(payload, (segmentPath, seedData)=>{
         segments.set(segmentPath, createSegmentData(seedData));
@@ -200,11 +205,7 @@ async function collectSegmentDataForStage(ComponentMod, renderFlightStream, full
             (async ()=>{
                 for await (const chunk of itemStream){
                     if (controller.currentStage === _stagedrendering.RenderStage.Before) {
-                        throw Object.defineProperty(new _invarianterror.InvariantError('Unexpected chunk emitted in Before stage'), "__NEXT_ERROR_CODE", {
-                            value: "E1462",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new _invarianterror.InvariantError('Unexpected chunk emitted in Before stage');
                     }
                     writeChunk(stageEntry, controller.currentStage, targetStage, chunk);
                 }
@@ -275,7 +276,7 @@ function onFlightRenderError(error) {
  * */ function createStagedStreamFromChunks(stageChunks) {
     // The successive stages are supersets of one another,
     // so we can index into the dynamic chunks everywhere
-    // and just look at the lengths of the Static/Runtime arrays
+    // and just look at the lengths of the partial stage arrays
     const allChunks = stageChunks[_stagedrendering.RenderStage.Dynamic];
     let chunkIx = 0;
     let currentStage = _stagedrendering.RenderStage.Before;
@@ -379,38 +380,10 @@ async function createCombinedPayloadStream(ComponentMod, renderFlightStream, pay
         debugStream: debugChunks ? (0, _streamutils.createNodeStreamFromChunks)(debugChunks, renderSignal) : null
     };
 }
-function getRootDataFromPayload(initialRSCPayload) {
-    // FlightDataPath is an unsound type, hence the additional checks. The
-    // valid shapes are a single root path with no segment prefix: 4 elements
-    // ([tree, seedData, head, isHeadPartial], per getRSCPayload) or 3 when
-    // reconstructed without the isHeadPartial flag (see the payload literals
-    // in this module).
-    const flightDataPaths = initialRSCPayload.f;
-    if (flightDataPaths.length !== 1 || flightDataPaths[0].length !== 3 && flightDataPaths[0].length !== 4) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('InitialRSCPayload does not match the expected shape during instant validation.'), "__NEXT_ERROR_CODE", {
-            value: "E994",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const flightRouterState = flightDataPaths[0][0];
-    const seedData = flightDataPaths[0][1];
-    // TODO: handle head
-    const head = flightDataPaths[0][2];
-    return {
-        flightRouterState,
-        seedData,
-        head
-    };
-}
 async function createValidationHead(cache, releaseSignal, clientReferenceManifest, stage) {
     const segmentCacheItem = cache.head;
     if (!segmentCacheItem) {
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing segment data: <head>`), "__NEXT_ERROR_CODE", {
-            value: "E1072",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Missing segment data: <head>`);
     }
     const stageEntry = getStageEntry(segmentCacheItem, stage);
     return await deserializeFromChunks(stageEntry.chunks, stageEntry.allChunks, stageEntry.debugChunks, releaseSignal, clientReferenceManifest, // NOTE: We're not passing an endTime, because the debug info has already been
@@ -448,22 +421,48 @@ async function createValidationHead(cache, releaseSignal, clientReferenceManifes
         endTime: timings == null ? void 0 : timings.endTime
     });
 }
-function createSegmentData(seedData) {
-    const [node, _parallelRoutesData, _unused, isPartial, varyParams] = seedData;
+function createSegmentData(data) {
     return {
-        node,
-        isPartial,
-        varyParams
+        node: data.r,
+        // Page payloads always carry the boolean form of `p`; the promise
+        // encoding only appears in per-segment prefetch responses. Treat it
+        // conservatively as partial if it ever shows up here.
+        isPartial: typeof data.p === 'boolean' ? data.p : true,
+        varyParams: data.v
     };
 }
-function getCacheNodeSeedDataFromSegment(data, slots) {
-    return [
-        data.node,
-        slots,
-        /* unused (previously `loading`) */ null,
-        data.isPartial,
-        data.varyParams
-    ];
+/**
+ * Builds a node of the rebuilt transport tree: structure (identity and
+ * hints) comes from the original payload's node, render output from the
+ * validation segment cache.
+ */ function createTransportNodeFromSegment(original, data, children) {
+    const node = {
+        s: original.s,
+        d: {
+            r: data.node,
+            p: data.isPartial,
+            v: data.varyParams
+        }
+    };
+    if (original.h !== undefined) {
+        node.h = original.h;
+    }
+    if (children !== null) {
+        node.c = children;
+    }
+    return node;
+}
+/**
+ * The rebuild walks the loader tree and the original payload's transport
+ * tree in parallel; the two mirror each other because the payload was
+ * rendered from the same loader tree.
+ */ function getOriginalChildNode(original, parallelRouteKey) {
+    var _original_c;
+    const childNode = (_original_c = original.c) == null ? void 0 : _original_c.get(parallelRouteKey);
+    if (childNode === undefined) {
+        throw new _invarianterror.InvariantError(`The payload's transport tree is missing a slot that exists in the ` + `loader tree: ${parallelRouteKey}`);
+    }
+    return childNode;
 }
 function createSegmentCache() {
     return {
@@ -472,12 +471,11 @@ function createSegmentCache() {
     };
 }
 function createSegmentCacheItem() {
-    return {
-        [_stagedrendering.RenderStage.Static]: null,
-        [_stagedrendering.RenderStage.ShellRuntime]: null,
-        [_stagedrendering.RenderStage.Runtime]: null,
-        [_stagedrendering.RenderStage.Dynamic]: null
-    };
+    const result = {};
+    for (const stage of _stagedrendering.RENDER_STAGE_ADVANCE_ORDER){
+        result[stage] = null;
+    }
+    return result;
 }
 function createSegmentCacheItemStageEntry(withDebugChunks) {
     return {
@@ -498,11 +496,7 @@ function getStageEntry(segmentCacheItem, stage) {
     const data = segmentCacheItem[stage];
     if (!data) {
         // Indicates that we didn't fill the cache at this stage.
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Expected segment cache to have data for stage '${_stagedrendering.RenderStage[stage]}'`), "__NEXT_ERROR_CODE", {
-            value: "E1461",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Expected segment cache to have data for stage '${_stagedrendering.RenderStage[stage]}'`);
     }
     return data;
 }
@@ -518,7 +512,7 @@ function getStageEntry(segmentCacheItem, stage) {
     // Dynamic segments (tuples) always consume a URL depth.
     if (typeof segment !== 'string') return true;
     // Route groups, pages, defaults, and not-found don't consume a depth.
-    if (segment.startsWith(_segment.PAGE_SEGMENT_KEY) || (0, _segment.isGroupSegment)(segment) || segment === _segment.DEFAULT_SEGMENT_KEY || segment === _segment.NOT_FOUND_SEGMENT_KEY) {
+    if (segment === _segment.PAGE_SEGMENT_KEY || (0, _segment.isGroupSegment)(segment) || segment === _segment.DEFAULT_SEGMENT_KEY || segment === _segment.NOT_FOUND_SEGMENT_KEY) {
         return false;
     }
     // Everything else consumes a depth, including the root segment ''.
@@ -563,55 +557,38 @@ function discoverValidationDepths(loaderTree) {
     return groupDepthsByUrlDepth;
 }
 var ValidationPrefetchKind = /*#__PURE__*/ function(ValidationPrefetchKind) {
-    /** App Shells, for `<Link>` without `prefetch={true}` */ ValidationPrefetchKind[ValidationPrefetchKind["Shell"] = 1] = "Shell";
-    // TODO(app-shells): validate speculative prefetches
-    // Speculative = 2,
+    /** App Shells, for `<Link>` without `prefetch={true}`, including session data */ ValidationPrefetchKind[ValidationPrefetchKind["RuntimeAppShell"] = 1] = "RuntimeAppShell";
+    /** App Shells, for `<Link>` without `prefetch={true}`, only static data */ ValidationPrefetchKind[ValidationPrefetchKind["StaticAppShell"] = 2] = "StaticAppShell";
     /** Behavior when Partial Prefetching is not enabled. */ ValidationPrefetchKind[ValidationPrefetchKind["LegacySpeculative"] = 3] = "LegacySpeculative";
     return ValidationPrefetchKind;
 }({});
-async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cache, initialLoaderTree, getDynamicParamFromSegment, query, depth, groupDepth, releaseSignal, boundaryState, clientReferenceManifest, useRuntimeStageForPartialSegments) {
+async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cache, initialLoaderTree, getDynamicParamFromSegment, depth, groupDepth, releaseSignal, boundaryState, clientReferenceManifest, overrideStageForPartialSegments) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('createCombinedPayloadAtDepth must run inside a WorkStore'), "__NEXT_ERROR_CODE", {
-            value: "E1184",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('createCombinedPayloadAtDepth must run inside a WorkStore');
     }
     const { validationLevel, route } = workStore;
-    let hasStaticSegments = false;
-    let hasRuntimeSegments = false;
     // Index 0 is reserved for the root config. Slot markers start at 1.
     const slotStacks = [
         null
     ];
     /**
    * When a segment has multiple parallel routes (a fork), wrap each
-   * slot's seed data with a slot marker component. The marker's index
+   * slot's render output with a slot marker component. The marker's index
    * in the component stack maps to `slotStacks` for per-slot error
    * attribution. Slot markers start at index 1 (index 0 is root).
    */ function wrapSlotsWithMarkers(slots, results) {
-        const keys = Object.keys(slots);
-        if (keys.length <= 1) return;
-        for (const key of keys){
-            const slotSeedData = slots[key];
-            if (slotSeedData === null) continue;
+        if (slots === null || slots.size <= 1) return;
+        for (const [key, slotNode] of slots){
             const result = results.get(key);
             const markerIndex = slotStacks.length;
             slotStacks.push((result == null ? void 0 : result.createInstantStack) ?? null);
             const markerName = `${_boundaryconstants.INSTANT_SLOT_MARKER_PREFIX}${markerIndex - 1}${_boundaryconstants.INSTANT_SLOT_MARKER_SUFFIX}`;
-            const [node, parallelRoutesData, unused, isPartial, varyParams] = slotSeedData;
-            slots[key] = [
-                // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- bundled in the server layer
-                /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundary.SlotMarker, {
-                    name: markerName,
-                    children: node
-                }, "sm"),
-                parallelRoutesData,
-                unused,
-                isPartial,
-                varyParams
-            ];
+            slotNode.d.r = // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- bundled in the server layer
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundary.SlotMarker, {
+                name: markerName,
+                children: slotNode.d.r
+            }, "sm");
         }
     }
     function getSegment(loaderTree) {
@@ -619,21 +596,16 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
         if (dynamicParam) {
             return dynamicParam.treeSegment;
         }
-        const segment = loaderTree[0];
-        return query ? (0, _segment.addSearchParamsIfPageSegment)(segment, query) : segment;
+        return loaderTree[0];
     }
-    async function buildSharedTreeSeedData(loaderTree, parentPath, key, urlDepthConsumed, groupDepthConsumed) {
+    async function buildSharedTransportTree(loaderTree, originalNode, parentPath, key, urlDepthConsumed, groupDepthConsumed) {
         const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(loaderTree);
         const segment = getSegment(loaderTree);
         const path = parentPath === null ? stringifySegment(segment) : createChildSegmentPath(parentPath, key, segment);
         debug == null ? void 0 : debug(`    ${path || '/'} - Dynamic`);
         const segmentCacheItem = cache.segments.get(path);
         if (!segmentCacheItem) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Missing segment data: ${path}`), "__NEXT_ERROR_CODE", {
-                value: "E995",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Missing segment data: ${path}`);
         }
         const stageEntry = getStageEntry(segmentCacheItem, _stagedrendering.RenderStage.Dynamic);
         const dynamicChunks = stageEntry.chunks;
@@ -665,7 +637,7 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
                     children: segmentData.node
                 }, "c")
             };
-            const slots = {};
+            let slots = null;
             const slotResults = new Map();
             let requiresInstantUI = false;
             let createInstantStack = null;
@@ -677,9 +649,12 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
             const slotModFilePaths = [];
             let firstModFilePath = null;
             for(const parallelRouteKey in parallelRoutes){
-                const result = await buildNewTreeSeedData(parallelRoutes[parallelRouteKey], path, parallelRouteKey, 0 /* segmentDepth */ );
+                const result = await buildNewTransportTree(parallelRoutes[parallelRouteKey], getOriginalChildNode(originalNode, parallelRouteKey), path, parallelRouteKey, 0 /* segmentDepth */ );
                 slotResults.set(parallelRouteKey, result);
-                slots[parallelRouteKey] = result.seedData;
+                if (slots === null) {
+                    slots = new Map();
+                }
+                slots.set(parallelRouteKey, result.node);
                 if (result.firstModFilePath !== null) {
                     slotModFilePaths.push(result.firstModFilePath);
                     if (firstModFilePath === null) {
@@ -702,7 +677,7 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
             }
             wrapSlotsWithMarkers(slots, slotResults);
             return {
-                seedData: getCacheNodeSeedDataFromSegment(finalSegmentData, slots),
+                node: createTransportNodeFromSegment(originalNode, finalSegmentData, slots),
                 requiresInstantUI,
                 createInstantStack,
                 firstModFilePath,
@@ -710,16 +685,19 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
             };
         }
         // Not at the boundary yet — keep walking as shared.
-        const slots = {};
+        let slots = null;
         const slotResults = new Map();
         let requiresInstantUI = false;
         let createInstantStack = null;
         let bestConfigDepth = -1;
         let firstModFilePath = null;
         for(const parallelRouteKey in parallelRoutes){
-            const result = await buildSharedTreeSeedData(parallelRoutes[parallelRouteKey], path, parallelRouteKey, nextUrlDepth, currentGroupDepth);
+            const result = await buildSharedTransportTree(parallelRoutes[parallelRouteKey], getOriginalChildNode(originalNode, parallelRouteKey), path, parallelRouteKey, nextUrlDepth, currentGroupDepth);
             slotResults.set(parallelRouteKey, result);
-            slots[parallelRouteKey] = result.seedData;
+            if (slots === null) {
+                slots = new Map();
+            }
+            slots.set(parallelRouteKey, result.node);
             if (firstModFilePath === null) {
                 firstModFilePath = result.firstModFilePath;
             }
@@ -733,14 +711,14 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
         }
         wrapSlotsWithMarkers(slots, slotResults);
         return {
-            seedData: getCacheNodeSeedDataFromSegment(segmentData, slots),
+            node: createTransportNodeFromSegment(originalNode, segmentData, slots),
             requiresInstantUI,
             createInstantStack,
             firstModFilePath,
             configDepth: bestConfigDepth
         };
     }
-    async function buildNewTreeSeedData(lt, parentPath, key, segmentDepth) {
+    async function buildNewTransportTree(lt, originalNode, parentPath, key, segmentDepth) {
         const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(lt);
         const { mod: layoutOrPageMod, filePath: layoutOrPageFilePath } = await (0, _appdirmodule.getLayoutOrPageModule)(lt);
         const localModFilePath = layoutOrPageFilePath ?? null;
@@ -764,47 +742,24 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
         }
         const segmentCacheItem = cache.segments.get(path);
         if (!segmentCacheItem) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Missing segment data: ${path}`), "__NEXT_ERROR_CODE", {
-                value: "E995",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Missing segment data: ${path}`);
         }
         let stage;
         switch(prefetchKind){
-            case 1:
-                {
-                    if (useRuntimeStageForPartialSegments) {
-                        stage = _stagedrendering.RenderStage.Runtime;
-                    } else {
-                        stage = _stagedrendering.RenderStage.ShellRuntime;
-                    }
-                    break;
-                }
-            case 3:
-                {
-                    if (useRuntimeStageForPartialSegments) {
-                        stage = _stagedrendering.RenderStage.Runtime;
-                    } else {
-                        // In legacy speculative prefetches, we always use static.
-                        stage = _stagedrendering.RenderStage.Static;
-                    }
-                    break;
-                }
-        }
-        switch(stage){
-            case _stagedrendering.RenderStage.Static:
+            case 2:
                 {
-                    hasStaticSegments = true;
+                    stage = overrideStageForPartialSegments ?? _stagedrendering.RenderStage.ShellStatic;
                     break;
                 }
-            case _stagedrendering.RenderStage.ShellRuntime:
+            case 1:
                 {
+                    stage = overrideStageForPartialSegments ?? _stagedrendering.RenderStage.ShellRuntime;
                     break;
                 }
-            case _stagedrendering.RenderStage.Runtime:
+            case 3:
                 {
-                    hasRuntimeSegments = true;
+                    // In legacy speculative prefetches, we always use static.
+                    stage = overrideStageForPartialSegments ?? _stagedrendering.RenderStage.Static;
                     break;
                 }
         }
@@ -817,7 +772,7 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
             endTime: undefined
         });
         // Build children first, then determine requiresInstantUI.
-        const slots = {};
+        let slots = null;
         const slotResults = new Map();
         let childrenRequireInstantUI = false;
         let childCreateInstantStack = null;
@@ -825,9 +780,12 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
         let childFirstModFilePath = null;
         for(const parallelRouteKey in parallelRoutes){
             const childSegmentDepth = segmentConsumesURLDepth(segment) ? segmentDepth + 1 : segmentDepth;
-            const result = await buildNewTreeSeedData(parallelRoutes[parallelRouteKey], path, parallelRouteKey, childSegmentDepth);
+            const result = await buildNewTransportTree(parallelRoutes[parallelRouteKey], getOriginalChildNode(originalNode, parallelRouteKey), path, parallelRouteKey, childSegmentDepth);
             slotResults.set(parallelRouteKey, result);
-            slots[parallelRouteKey] = result.seedData;
+            if (slots === null) {
+                slots = new Map();
+            }
+            slots.set(parallelRouteKey, result.node);
             if (childFirstModFilePath === null) {
                 childFirstModFilePath = result.firstModFilePath;
             }
@@ -861,72 +819,53 @@ async function createCombinedPayloadAtDepth(prefetchKind, initialRSCPayload, cac
         // any, otherwise the first non-null we got from a child.
         const firstModFilePath = localModFilePath ?? childFirstModFilePath;
         return {
-            seedData: getCacheNodeSeedDataFromSegment(segmentData, slots),
+            node: createTransportNodeFromSegment(originalNode, segmentData, slots),
             requiresInstantUI,
             createInstantStack,
             firstModFilePath,
             configDepth
         };
     }
-    const { seedData, requiresInstantUI, createInstantStack } = await buildSharedTreeSeedData(initialLoaderTree, null, null, 0 /* urlDepthConsumed */ , 0 /* groupDepthConsumed */ );
+    const { node: rebuiltTree, requiresInstantUI, createInstantStack } = await buildSharedTransportTree(initialLoaderTree, initialRSCPayload.t.t, null, null, 0 /* urlDepthConsumed */ , 0 /* groupDepthConsumed */ );
     if (!requiresInstantUI) {
         return null;
     }
     // Set the root config at index 0. This is the fallback for errors
     // that occur above any fork (no slot marker in the component stack).
     slotStacks[0] = createInstantStack;
-    const { flightRouterState } = getRootDataFromPayload(initialRSCPayload);
     let headStage;
     switch(prefetchKind){
-        case 1:
-            {
-                if (useRuntimeStageForPartialSegments) {
-                    headStage = _stagedrendering.RenderStage.Runtime;
-                } else {
-                    headStage = _stagedrendering.RenderStage.ShellRuntime;
-                }
-                break;
-            }
-        case 3:
+        case 2:
             {
-                headStage = hasRuntimeSegments ? _stagedrendering.RenderStage.Runtime : _stagedrendering.RenderStage.Static;
+                headStage = overrideStageForPartialSegments ?? _stagedrendering.RenderStage.ShellStatic;
                 break;
             }
-    }
-    debug == null ? void 0 : debug(`    /_head - ${_stagedrendering.RenderStage[headStage]}`);
-    let hasAmbiguousErrors;
-    switch(prefetchKind){
         case 1:
             {
-                // In a shell prefetch, holes are always ambiguous
-                // (they can be either link data or dynamic data)
-                // unless we're already overriding and using the runtime stage,
-                // which resolves link data.
-                hasAmbiguousErrors = !useRuntimeStageForPartialSegments;
+                headStage = overrideStageForPartialSegments ?? _stagedrendering.RenderStage.ShellRuntime;
                 break;
             }
         case 3:
             {
-                // In the old prefetching mechanism, holes in static segments are ambiguous
-                // (they can be either runtime data or dynamic data).
-                hasAmbiguousErrors = hasStaticSegments;
+                headStage = overrideStageForPartialSegments ?? _stagedrendering.RenderStage.Static;
                 break;
             }
     }
+    debug == null ? void 0 : debug(`    /_head - ${_stagedrendering.RenderStage[headStage]}`);
     const head = await createValidationHead(cache, releaseSignal, clientReferenceManifest, headStage);
     const payload = {
         ...initialRSCPayload,
-        f: [
-            [
-                flightRouterState,
-                seedData,
-                head
-            ]
-        ]
+        t: {
+            t: rebuiltTree,
+            h: {
+                r: head,
+                p: initialRSCPayload.t.h.p,
+                v: initialRSCPayload.t.h.v
+            }
+        }
     };
     return {
         payload,
-        hasAmbiguousErrors,
         slotStacks
     };
 }

package/.next/standalone/node_modules/next/dist/server/app-render/instant-validation/stream-utils.js

@@ -23,11 +23,7 @@ _export(exports, {
 const _invarianterror = require("../../../shared/lib/invariant-error");
 function createNodeStreamWithLateRelease(partialChunks, allChunks, releaseSignal) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('createNodeStreamWithLateRelease cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E993",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('createNodeStreamWithLateRelease cannot be used in the edge runtime');
     } else {
         const { Readable } = require('node:stream');
         let nextIndex = 0;
@@ -62,11 +58,7 @@ function createNodeStreamWithLateRelease(partialChunks, allChunks, releaseSignal
 }
 function createNodeStreamFromChunks(chunks, signal) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('createNodeStreamFromChunks cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
-            value: "E945",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('createNodeStreamFromChunks cannot be used in the edge runtime');
     } else {
         const { Readable } = require('node:stream');
         // If there's a signal, delay closing until it fires