@evoscientist/webui 0.2.5 → 0.2.6

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    ValidationPrefetchKind: null,
     collectStagedSegmentData: null,
     createCombinedPayloadAtDepth: null,
     createCombinedPayloadStream: null,
@@ -15,6 +16,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    ValidationPrefetchKind: function() {
+        return ValidationPrefetchKind;
+    },
     collectStagedSegmentData: function() {
         return collectStagedSegmentData;
     },
@@ -37,14 +41,14 @@ const _workasyncstorageexternal = require("../work-async-storage.external");
 const _prospectiverenderutils = require("../prospective-render-utils");
 const _createerrorhandler = require("../create-error-handler");
 const _boundary = require("../../../client/components/instant-validation/boundary");
+const _boundaryconstants = require("./boundary-constants");
 const _appdirmodule = require("../../lib/app-dir-module");
 const _parseloadertree = require("../../../shared/lib/router/utils/parse-loader-tree");
 const _nodestream = require("node:stream");
 const _streamutils = require("./stream-utils");
-const _debugchannelserver = require("../debug-channel-server");
 const _client = require("react-server-dom-webpack/client");
-const _server = require("react-server-dom-webpack/server");
 const _segment = require("../../../shared/lib/segment");
+const _instantconfig = require("./instant-config");
 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;
 const debug = process.env.NEXT_PRIVATE_DEBUG_VALIDATION === '1' ? console.log : undefined;
@@ -82,7 +86,42 @@ function createChildSegmentPath(parentPath, parallelRouteKey, segment) {
 function stringifySegment(segment) {
     return typeof segment === 'string' ? encodeURIComponent(segment) : encodeURIComponent(segment[0]) + '|' + segment[1] + '|' + segment[2];
 }
-async function collectStagedSegmentData(fullPageChunks, fullPageDebugChunks, startTime, hasRuntimePrefetch, clientReferenceManifest) {
+async function collectStagedSegmentData(prefetchKind, ComponentMod, renderFlightStream, fullPageChunks, fullPageDebugChunks, startTime, stageEndTimes, clientReferenceManifest, createDebugChannel) {
+    const cache = createSegmentCache();
+    let partialStages;
+    switch(prefetchKind){
+        case 1:
+            {
+                partialStages = [
+                    _stagedrendering.RenderStage.ShellRuntime,
+                    _stagedrendering.RenderStage.Runtime
+                ];
+                break;
+            }
+        case 3:
+            {
+                partialStages = [
+                    _stagedrendering.RenderStage.Static,
+                    _stagedrendering.RenderStage.Runtime
+                ];
+                break;
+            }
+    }
+    const doStage = async (targetStage)=>{
+        const endTime = targetStage !== _stagedrendering.RenderStage.Dynamic ? stageEndTimes[targetStage] : undefined;
+        const firstStage = partialStages[0];
+        return await collectSegmentDataForStage(ComponentMod, renderFlightStream, fullPageChunks, fullPageDebugChunks, clientReferenceManifest, createDebugChannel, cache, firstStage, targetStage, startTime, endTime);
+    };
+    for (const targetStage of partialStages){
+        await doStage(targetStage);
+    }
+    const payload = await doStage(_stagedrendering.RenderStage.Dynamic);
+    return {
+        cache,
+        payload
+    };
+}
+async function collectSegmentDataForStage(ComponentMod, renderFlightStream, fullPageChunks, fullPageDebugChunks, clientReferenceManifest, createDebugChannel, cache, firstStage, targetStage, startTime, endTime) {
     const debugChannelAbortController = new AbortController();
     const debugStream = fullPageDebugChunks ? (0, _streamutils.createNodeStreamFromChunks)(fullPageDebugChunks, debugChannelAbortController.signal) : null;
     const { stream, controller } = createStagedStreamFromChunks(fullPageChunks);
@@ -96,10 +135,12 @@ async function collectStagedSegmentData(fullPageChunks, fullPageDebugChunks, sta
     const environmentName = ()=>{
         const currentStage = controller.currentStage;
         switch(currentStage){
+            case _stagedrendering.RenderStage.Before:
             case _stagedrendering.RenderStage.Static:
                 return 'Prerender';
+            case _stagedrendering.RenderStage.ShellRuntime:
             case _stagedrendering.RenderStage.Runtime:
-                return hasRuntimePrefetch ? 'Prefetch' : 'Prefetchable';
+                return 'Prefetch';
             case _stagedrendering.RenderStage.Dynamic:
                 return 'Server';
             default:
@@ -111,21 +152,31 @@ async function collectStagedSegmentData(fullPageChunks, fullPageDebugChunks, sta
                 });
         }
     };
-    // Deserialize the payload.
-    // NOTE: the stream will initially be in the static stage, so that's as far as we get here.
-    // We still expect the outer structure of the payload to be readable in this state.
+    // Deserialize the payload partially so that we can traverse the structure.
     const serverConsumerManifest = {
         moduleLoading: null,
         moduleMap: clientReferenceManifest.rscModuleMapping,
         serverModuleMap: (0, _manifestssingleton.getServerModuleMap)()
     };
-    const payload = await (0, _client.createFromNodeStream)(stream, serverConsumerManifest, {
+    const payloadPromise = (0, _client.createFromNodeStream)(stream, serverConsumerManifest, {
         findSourceMapURL,
         debugChannel: debugStream ?? undefined,
-        // Do not pass start/end timings - we do not want to omit any debug info.
-        startTime: undefined,
-        endTime: undefined
+        startTime,
+        // Each stage is decoded with an `endTime` corresponding to
+        // when it finished rendering, so that we can avoid pointing to
+        // IO that finished after the stage is done.
+        // This needs to happen during the first deserialization, because
+        // when we serialize the segments afterwards, React will clamp the
+        // timestamps of IO to the current time, and we will lose the ability
+        // to omit info about IO that hasn't resolved in this stage.
+        endTime
     });
+    // We expect the outer structure of the payload to be readable in any stage,
+    // even if the segments are incomplete.
+    // NOTE: This must be done after the `createFromNodeStream` call but *before*
+    // the result is awaited, otherwise we'll deadlock.
+    controller.advanceStage(firstStage);
+    const payload = await payloadPromise;
     // 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.
@@ -134,75 +185,86 @@ async function collectStagedSegmentData(fullPageChunks, fullPageDebugChunks, sta
     traverseRootSeedDataSegments(payload, (segmentPath, seedData)=>{
         segments.set(segmentPath, createSegmentData(seedData));
     });
-    const cache = createSegmentCache();
     const pendingTasks = [];
-    /** Track when we advance stages so we can pass them as `endTime` later. */ const stageEndTimes = {
-        [_stagedrendering.RenderStage.Static]: -1,
-        [_stagedrendering.RenderStage.Runtime]: -1
-    };
-    const renderIntoCacheItem = async (data, cacheEntry)=>{
-        const segmentDebugChannel = cacheEntry.debugChunks ? (0, _debugchannelserver.createDebugChannel)() : undefined;
-        const itemStream = (0, _server.renderToReadableStream)(data, clientReferenceManifest.clientModules, {
+    const renderIntoStageEntry = async (data, stageEntry)=>{
+        const segmentDebugChannel = stageEntry.debugChunks ? createDebugChannel() : undefined;
+        const itemStream = renderFlightStream(ComponentMod, data, clientReferenceManifest.clientModules, {
             filterStackFrame,
             debugChannel: segmentDebugChannel == null ? void 0 : segmentDebugChannel.serverSide,
             environmentName,
             startTime,
-            onError (error) {
-                const digest = (0, _createerrorhandler.getDigestForWellKnownError)(error);
-                if (digest) {
-                    return digest;
-                }
-                // Forward existing digests
-                if (error && typeof error === 'object' && 'digest' in error && typeof error.digest === 'string') {
-                    return error.digest;
-                }
-                // We don't need to log the errors because we would have already done that
-                // when generating the original Flight stream for the whole page.
-                if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
-                    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-                    (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(error, (workStore == null ? void 0 : workStore.route) ?? 'unknown route', _prospectiverenderutils.Phase.InstantValidation);
-                }
-            }
+            onError: onFlightRenderError
         });
         await Promise.all([
             // accumulate Flight chunks
             (async ()=>{
-                for await (const chunk of itemStream.values()){
-                    writeChunk(cacheEntry.chunks, controller.currentStage, chunk);
+                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
+                        });
+                    }
+                    writeChunk(stageEntry, controller.currentStage, targetStage, chunk);
                 }
             })(),
             // accumulate Debug chunks
             segmentDebugChannel && (async ()=>{
-                for await (const chunk of segmentDebugChannel.clientSide.readable.values()){
-                    cacheEntry.debugChunks.push(chunk);
+                for await (const chunk of segmentDebugChannel.clientSide.readable){
+                    stageEntry.debugChunks.push(chunk);
                 }
             })()
         ]);
     };
+    // Each stage is rendered in a separate pass (passed in as targetStage),
+    // so we only need two stages:
+    // 1. the target stage
+    // 2. the dynamic stage (for late-release debug info)
     await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+        if (targetStage !== _stagedrendering.RenderStage.Dynamic) {
+            controller.advanceStage(targetStage);
+        }
+        const withDebugChunks = !!fullPageDebugChunks;
         {
-            const headCacheItem = createSegmentCacheItem(!!fullPageDebugChunks);
-            cache.head = headCacheItem;
-            pendingTasks.push(renderIntoCacheItem(head, headCacheItem));
+            let headCacheItem = cache.head;
+            if (!headCacheItem) {
+                headCacheItem = createSegmentCacheItem();
+                cache.head = headCacheItem;
+            }
+            const stageEntry = getOrCreateStageEntry(headCacheItem, targetStage, withDebugChunks);
+            pendingTasks.push(renderIntoStageEntry(head, stageEntry));
         }
         for (const [segmentPath, segmentData] of segments){
-            const segmentCacheItem = createSegmentCacheItem(!!fullPageDebugChunks);
-            cache.segments.set(segmentPath, segmentCacheItem);
-            pendingTasks.push(renderIntoCacheItem(segmentData, segmentCacheItem));
+            let segmentCacheItem = cache.segments.get(segmentPath);
+            if (!segmentCacheItem) {
+                segmentCacheItem = createSegmentCacheItem();
+                cache.segments.set(segmentPath, segmentCacheItem);
+            }
+            const stageEntry = getOrCreateStageEntry(segmentCacheItem, targetStage, withDebugChunks);
+            pendingTasks.push(renderIntoStageEntry(segmentData, stageEntry));
         }
     }, ()=>{
-        stageEndTimes[_stagedrendering.RenderStage.Static] = performance.now() + performance.timeOrigin;
-        controller.advanceStage(_stagedrendering.RenderStage.Runtime);
-    }, ()=>{
-        stageEndTimes[_stagedrendering.RenderStage.Runtime] = performance.now() + performance.timeOrigin;
         controller.advanceStage(_stagedrendering.RenderStage.Dynamic);
     });
     await Promise.all(pendingTasks);
-    return {
-        cache,
-        payload,
-        stageEndTimes
-    };
+    return payload;
+}
+function onFlightRenderError(error) {
+    const digest = (0, _createerrorhandler.getDigestForWellKnownError)(error);
+    if (digest) {
+        return digest;
+    }
+    // Forward existing digests
+    if (error && typeof error === 'object' && 'digest' in error && typeof error.digest === 'string') {
+        return error.digest;
+    }
+    // We don't need to log the errors because we would have already done that
+    // when generating the original Flight stream for the whole page.
+    if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+        const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(error, (workStore == null ? void 0 : workStore.route) ?? 'unknown route', _prospectiverenderutils.Phase.InstantValidation);
+    }
 }
 /**
  * Turns accumulated stage chunks into a stream.
@@ -215,56 +277,27 @@ async function collectStagedSegmentData(fullPageChunks, fullPageDebugChunks, sta
     // so we can index into the dynamic chunks everywhere
     // and just look at the lengths of the Static/Runtime arrays
     const allChunks = stageChunks[_stagedrendering.RenderStage.Dynamic];
-    const numStaticChunks = stageChunks[_stagedrendering.RenderStage.Static].length;
-    const numRuntimeChunks = stageChunks[_stagedrendering.RenderStage.Runtime].length;
-    const numDynamicChunks = stageChunks[_stagedrendering.RenderStage.Dynamic].length;
     let chunkIx = 0;
-    let currentStage = _stagedrendering.RenderStage.Static;
+    let currentStage = _stagedrendering.RenderStage.Before;
     let closed = false;
-    function push(chunk) {
-        stream.push(chunk);
+    function emitNewChunks(chunks) {
+        for(; chunkIx < chunks.length; chunkIx++){
+            stream.push(allChunks[chunkIx]);
+        }
     }
     function close() {
         closed = true;
         stream.push(null);
     }
     const stream = new _nodestream.Readable({
-        read () {
-            // Emit static chunks
-            for(; chunkIx < numStaticChunks; chunkIx++){
-                push(allChunks[chunkIx]);
-            }
-            // If there's no more chunks after this stage, finish the stream.
-            if (chunkIx >= allChunks.length) {
-                close();
-                return;
-            }
-        }
+        read () {}
     });
     function advanceStage(stage) {
         if (closed) return true;
-        switch(stage){
-            case _stagedrendering.RenderStage.Runtime:
-                {
-                    currentStage = _stagedrendering.RenderStage.Runtime;
-                    for(; chunkIx < numRuntimeChunks; chunkIx++){
-                        push(allChunks[chunkIx]);
-                    }
-                    break;
-                }
-            case _stagedrendering.RenderStage.Dynamic:
-                {
-                    currentStage = _stagedrendering.RenderStage.Dynamic;
-                    for(; chunkIx < numDynamicChunks; chunkIx++){
-                        push(allChunks[chunkIx]);
-                    }
-                    break;
-                }
-            default:
-                {
-                    stage;
-                }
-        }
+        // NOTE: we don't special handling for skipping stages,
+        // emitNewChunks will emit anything that hasn't been emitted before.
+        currentStage = stage;
+        emitNewChunks(stageChunks[stage]);
         // If there's no more chunks after this stage, finish the stream.
         if (chunkIx >= allChunks.length) {
             close();
@@ -283,39 +316,22 @@ async function collectStagedSegmentData(fullPageChunks, fullPageDebugChunks, sta
         }
     };
 }
-function writeChunk(stageChunks, stage, chunk) {
-    switch(stage){
-        case _stagedrendering.RenderStage.Static:
-            {
-                stageChunks[_stagedrendering.RenderStage.Static].push(chunk);
-            // fallthrough
-            }
-        case _stagedrendering.RenderStage.Runtime:
-            {
-                stageChunks[_stagedrendering.RenderStage.Runtime].push(chunk);
-            // fallthrough
-            }
-        case _stagedrendering.RenderStage.Dynamic:
-            {
-                stageChunks[_stagedrendering.RenderStage.Dynamic].push(chunk);
-                break;
-            }
-        default:
-            {
-                stage;
-            }
+function writeChunk(stageData, currentStage, targetStage, chunk) {
+    if (currentStage <= targetStage) {
+        stageData.chunks.push(chunk);
     }
+    stageData.allChunks.push(chunk);
 }
-async function createCombinedPayloadStream(payload, extraChunksAbortController, renderSignal, clientReferenceManifest, startTime, isDebugChannelEnabled) {
+async function createCombinedPayloadStream(ComponentMod, renderFlightStream, payload, extraChunksAbortController, renderSignal, clientReferenceManifest, startTime, isDebugChannelEnabled, createDebugChannel) {
     // Collect all the chunks so that we're not dependent on timing of the render.
     let isRenderable = true;
     const renderableChunks = [];
     const allChunks = [];
     const debugChunks = isDebugChannelEnabled ? [] : null;
-    const debugChannel = isDebugChannelEnabled ? (0, _debugchannelserver.createDebugChannel)() : null;
+    const debugChannel = isDebugChannelEnabled ? createDebugChannel() : null;
     let streamFinished;
     await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
-        const stream = (0, _server.renderToReadableStream)(payload, clientReferenceManifest.clientModules, {
+        const stream = renderFlightStream(ComponentMod, payload, clientReferenceManifest.clientModules, {
             filterStackFrame,
             debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide,
             startTime,
@@ -339,7 +355,7 @@ async function createCombinedPayloadStream(payload, extraChunksAbortController,
         streamFinished = Promise.all([
             // Accumulate Flight chunks
             (async ()=>{
-                for await (const chunk of stream.values()){
+                for await (const chunk of stream){
                     allChunks.push(chunk);
                     if (isRenderable) {
                         renderableChunks.push(chunk);
@@ -348,7 +364,7 @@ async function createCombinedPayloadStream(payload, extraChunksAbortController,
             })(),
             // Accumulate debug chunks
             debugChannel && (async ()=>{
-                for await (const chunk of debugChannel.clientSide.readable.values()){
+                for await (const chunk of debugChannel.clientSide.readable){
                     debugChunks.push(chunk);
                 }
             })()
@@ -364,9 +380,13 @@ async function createCombinedPayloadStream(payload, extraChunksAbortController,
     };
 }
 function getRootDataFromPayload(initialRSCPayload) {
-    // FlightDataPath is an unsound type, hence the additional checks.
+    // 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) {
+    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,
@@ -383,7 +403,7 @@ function getRootDataFromPayload(initialRSCPayload) {
         head
     };
 }
-async function createValidationHead(cache, releaseSignal, clientReferenceManifest, stageEndTimes, stage) {
+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", {
@@ -392,9 +412,12 @@ async function createValidationHead(cache, releaseSignal, clientReferenceManifes
             configurable: true
         });
     }
-    return await deserializeFromChunks(segmentCacheItem.chunks[stage], segmentCacheItem.chunks[_stagedrendering.RenderStage.Dynamic], segmentCacheItem.debugChunks, releaseSignal, clientReferenceManifest, {
+    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
+    // truncated to the appropriate `endTime` when the segment cache was filled.
+    {
         startTime: undefined,
-        endTime: stageEndTimes[stage]
+        endTime: undefined
     });
 }
 /**
@@ -448,16 +471,41 @@ function createSegmentCache() {
         segments: new Map()
     };
 }
-function createSegmentCacheItem(withDebugChunks) {
+function createSegmentCacheItem() {
     return {
-        chunks: {
-            [_stagedrendering.RenderStage.Static]: [],
-            [_stagedrendering.RenderStage.Runtime]: [],
-            [_stagedrendering.RenderStage.Dynamic]: []
-        },
+        [_stagedrendering.RenderStage.Static]: null,
+        [_stagedrendering.RenderStage.ShellRuntime]: null,
+        [_stagedrendering.RenderStage.Runtime]: null,
+        [_stagedrendering.RenderStage.Dynamic]: null
+    };
+}
+function createSegmentCacheItemStageEntry(withDebugChunks) {
+    return {
+        allChunks: [],
+        chunks: [],
         debugChunks: withDebugChunks ? [] : null
     };
 }
+function getOrCreateStageEntry(segmentCacheItem, stage, withDebugChunks) {
+    let data = segmentCacheItem[stage];
+    if (!data) {
+        data = createSegmentCacheItemStageEntry(withDebugChunks);
+        segmentCacheItem[stage] = data;
+    }
+    return data;
+}
+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
+        });
+    }
+    return data;
+}
 /**
  * Whether this segment consumes a URL depth level. Each URL depth
  * represents a potential navigation boundary.
@@ -514,9 +562,58 @@ function discoverValidationDepths(loaderTree) {
     walk(loaderTree, -1, 0);
     return groupDepthsByUrlDepth;
 }
-async function createCombinedPayloadAtDepth(initialRSCPayload, cache, initialLoaderTree, getDynamicParamFromSegment, query, depth, groupDepth, releaseSignal, boundaryState, clientReferenceManifest, stageEndTimes, useRuntimeStageForPartialSegments) {
+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,
+    /** 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) {
+    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
+        });
+    }
+    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
+   * 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;
+            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
+            ];
+        }
+    }
     function getSegment(loaderTree) {
         const dynamicParam = getDynamicParamFromSegment(loaderTree);
         if (dynamicParam) {
@@ -538,7 +635,9 @@ async function createCombinedPayloadAtDepth(initialRSCPayload, cache, initialLoa
                 configurable: true
             });
         }
-        const segmentData = await deserializeFromChunks(segmentCacheItem.chunks[_stagedrendering.RenderStage.Dynamic], segmentCacheItem.chunks[_stagedrendering.RenderStage.Dynamic], segmentCacheItem.debugChunks, releaseSignal, clientReferenceManifest, null);
+        const stageEntry = getStageEntry(segmentCacheItem, _stagedrendering.RenderStage.Dynamic);
+        const dynamicChunks = stageEntry.chunks;
+        const segmentData = await deserializeFromChunks(dynamicChunks, dynamicChunks, stageEntry.debugChunks, releaseSignal, clientReferenceManifest, null);
         const consumesUrlDepth = segmentConsumesURLDepth(segment);
         const isGroup = typeof segment === 'string' && (0, _segment.isGroupSegment)(segment) && segment !== '(__SLOT__)';
         // Advance counters for this segment before the boundary check,
@@ -558,7 +657,6 @@ async function createCombinedPayloadAtDepth(initialRSCPayload, cache, initialLoa
         const isBoundary = pastUrlBoundary && currentGroupDepth >= groupDepth;
         if (isBoundary) {
             debug == null ? void 0 : debug(`    ['${path}' is the boundary (url=${nextUrlDepth}, group=${currentGroupDepth})]`);
-            boundaryState.expectedIds.add(path);
             const finalSegmentData = {
                 ...segmentData,
                 node: // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- bundled in the server layer
@@ -568,79 +666,102 @@ async function createCombinedPayloadAtDepth(initialRSCPayload, cache, initialLoa
                 }, "c")
             };
             const slots = {};
+            const slotResults = new Map();
             let requiresInstantUI = false;
             let createInstantStack = null;
+            let bestConfigDepth = -1;
+            // Collect the first mod file path from each slot's subtree.
+            // Don't include the boundary segment's own layout/page — that
+            // file DID render (it wraps the boundary). What didn't render
+            // is the content inside the children slots.
+            const slotModFilePaths = [];
+            let firstModFilePath = null;
             for(const parallelRouteKey in parallelRoutes){
-                const result = await buildNewTreeSeedData(parallelRoutes[parallelRouteKey], path, parallelRouteKey, false);
+                const result = await buildNewTreeSeedData(parallelRoutes[parallelRouteKey], path, parallelRouteKey, 0 /* segmentDepth */ );
+                slotResults.set(parallelRouteKey, result);
                 slots[parallelRouteKey] = result.seedData;
+                if (result.firstModFilePath !== null) {
+                    slotModFilePaths.push(result.firstModFilePath);
+                    if (firstModFilePath === null) {
+                        firstModFilePath = result.firstModFilePath;
+                    }
+                }
                 if (result.requiresInstantUI) {
                     requiresInstantUI = true;
-                    if (createInstantStack === null) {
+                    if (result.configDepth > bestConfigDepth || result.configDepth === bestConfigDepth && parallelRouteKey === 'children') {
+                        bestConfigDepth = result.configDepth;
                         createInstantStack = result.createInstantStack;
                     }
                 }
             }
+            // Only require this boundary to render if the subtree has an
+            // instant config. Unconfigured slot subtrees are allowed to not
+            // render (e.g. conditionally excluded by a layout).
+            if (requiresInstantUI) {
+                boundaryState.requiredIds.set(path, slotModFilePaths);
+            }
+            wrapSlotsWithMarkers(slots, slotResults);
             return {
                 seedData: getCacheNodeSeedDataFromSegment(finalSegmentData, slots),
                 requiresInstantUI,
-                createInstantStack
+                createInstantStack,
+                firstModFilePath,
+                configDepth: bestConfigDepth
             };
         }
         // Not at the boundary yet — keep walking as shared.
         const slots = {};
+        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);
+            slotResults.set(parallelRouteKey, result);
             slots[parallelRouteKey] = result.seedData;
+            if (firstModFilePath === null) {
+                firstModFilePath = result.firstModFilePath;
+            }
             if (result.requiresInstantUI) {
                 requiresInstantUI = true;
-                if (createInstantStack === null) {
+                if (result.configDepth > bestConfigDepth || result.configDepth === bestConfigDepth && parallelRouteKey === 'children') {
+                    bestConfigDepth = result.configDepth;
                     createInstantStack = result.createInstantStack;
                 }
             }
         }
+        wrapSlotsWithMarkers(slots, slotResults);
         return {
             seedData: getCacheNodeSeedDataFromSegment(segmentData, slots),
             requiresInstantUI,
-            createInstantStack
+            createInstantStack,
+            firstModFilePath,
+            configDepth: bestConfigDepth
         };
     }
-    async function buildNewTreeSeedData(lt, parentPath, key, isInsideRuntimePrefetch) {
+    async function buildNewTreeSeedData(lt, parentPath, key, segmentDepth) {
         const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(lt);
-        const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(lt);
+        const { mod: layoutOrPageMod, filePath: layoutOrPageFilePath } = await (0, _appdirmodule.getLayoutOrPageModule)(lt);
+        const localModFilePath = layoutOrPageFilePath ?? null;
         const segment = getSegment(lt);
         const path = parentPath === null ? stringifySegment(segment) : createChildSegmentPath(parentPath, key, segment);
         let instantConfig = null;
         let localCreateInstantStack = null;
         if (layoutOrPageMod !== undefined) {
-            instantConfig = layoutOrPageMod.unstable_instant ?? null;
-            if (instantConfig && typeof instantConfig === 'object') {
+            instantConfig = layoutOrPageMod.instant ?? null;
+            // When the default validation level is active and this is a page or
+            // default segment without an explicit config, treat it as if
+            // instant = true was exported. Framework-synthesized error
+            // routes are excluded — see isFrameworkErrorRoute.
+            if (instantConfig === null && validationLevel !== 'manual-warning' && validationLevel !== 'experimental-manual-error' && (0, _instantconfig.isImplicitValidationSegment)(segment) && !(0, _instantconfig.isFrameworkErrorRoute)(route)) {
+                instantConfig = true;
+            }
+            if (instantConfig === true || typeof instantConfig === 'object' && instantConfig !== null) {
                 const rawFactory = layoutOrPageMod.__debugCreateInstantConfigStack;
                 localCreateInstantStack = typeof rawFactory === 'function' ? rawFactory : null;
             }
         }
-        let childIsInsideRuntimePrefetch = isInsideRuntimePrefetch;
-        let stage;
-        if (!isInsideRuntimePrefetch) {
-            if (instantConfig && typeof instantConfig === 'object' && instantConfig.prefetch === 'runtime') {
-                stage = _stagedrendering.RenderStage.Runtime;
-                childIsInsideRuntimePrefetch = true;
-                hasRuntimeSegments = true;
-            } else {
-                if (useRuntimeStageForPartialSegments) {
-                    stage = _stagedrendering.RenderStage.Runtime;
-                    hasRuntimeSegments = true;
-                } else {
-                    stage = _stagedrendering.RenderStage.Static;
-                    hasStaticSegments = true;
-                }
-            }
-        } else {
-            stage = _stagedrendering.RenderStage.Runtime;
-            hasRuntimeSegments = true;
-        }
-        debug == null ? void 0 : debug(`    ${path || '/'} - ${_stagedrendering.RenderStage[stage]}`);
         const segmentCacheItem = cache.segments.get(path);
         if (!segmentCacheItem) {
             throw Object.defineProperty(new _invarianterror.InvariantError(`Missing segment data: ${path}`), "__NEXT_ERROR_CODE", {
@@ -649,50 +770,150 @@ async function createCombinedPayloadAtDepth(initialRSCPayload, cache, initialLoa
                 configurable: true
             });
         }
-        const segmentData = await deserializeFromChunks(segmentCacheItem.chunks[stage], segmentCacheItem.chunks[_stagedrendering.RenderStage.Dynamic], segmentCacheItem.debugChunks, releaseSignal, clientReferenceManifest, {
+        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:
+                {
+                    hasStaticSegments = true;
+                    break;
+                }
+            case _stagedrendering.RenderStage.ShellRuntime:
+                {
+                    break;
+                }
+            case _stagedrendering.RenderStage.Runtime:
+                {
+                    hasRuntimeSegments = true;
+                    break;
+                }
+        }
+        debug == null ? void 0 : debug(`    ${path || '/'} - ${_stagedrendering.RenderStage[stage]}`);
+        const stageEntry = getStageEntry(segmentCacheItem, stage);
+        const segmentData = await deserializeFromChunks(stageEntry.chunks, stageEntry.allChunks, stageEntry.debugChunks, releaseSignal, clientReferenceManifest, // NOTE: We're not passing an endTime, because the debug info has already been
+        // truncated to the appropriate `endTime` when the segment cache was filled.
+        {
             startTime: undefined,
-            endTime: stageEndTimes[stage]
+            endTime: undefined
         });
         // Build children first, then determine requiresInstantUI.
         const slots = {};
+        const slotResults = new Map();
         let childrenRequireInstantUI = false;
         let childCreateInstantStack = null;
+        let bestChildConfigDepth = -1;
+        let childFirstModFilePath = null;
         for(const parallelRouteKey in parallelRoutes){
-            const result = await buildNewTreeSeedData(parallelRoutes[parallelRouteKey], path, parallelRouteKey, childIsInsideRuntimePrefetch);
+            const childSegmentDepth = segmentConsumesURLDepth(segment) ? segmentDepth + 1 : segmentDepth;
+            const result = await buildNewTreeSeedData(parallelRoutes[parallelRouteKey], path, parallelRouteKey, childSegmentDepth);
+            slotResults.set(parallelRouteKey, result);
             slots[parallelRouteKey] = result.seedData;
+            if (childFirstModFilePath === null) {
+                childFirstModFilePath = result.firstModFilePath;
+            }
             if (result.requiresInstantUI) {
                 childrenRequireInstantUI = true;
-                if (childCreateInstantStack === null) {
+                if (result.configDepth > bestChildConfigDepth || result.configDepth === bestChildConfigDepth && parallelRouteKey === 'children') {
+                    bestChildConfigDepth = result.configDepth;
                     childCreateInstantStack = result.createInstantStack;
                 }
             }
         }
+        wrapSlotsWithMarkers(slots, slotResults);
         // Local config takes precedence over children.
         let requiresInstantUI;
         let createInstantStack;
+        let configDepth;
         if (instantConfig === false) {
             requiresInstantUI = false;
             createInstantStack = null;
-        } else if (instantConfig && typeof instantConfig === 'object') {
+            configDepth = -1;
+        } else if (instantConfig === true || typeof instantConfig === 'object' && instantConfig !== null) {
             requiresInstantUI = true;
             createInstantStack = localCreateInstantStack;
+            configDepth = segmentDepth;
         } else {
             requiresInstantUI = childrenRequireInstantUI;
             createInstantStack = childCreateInstantStack;
+            configDepth = bestChildConfigDepth;
         }
+        // First mod we find in DFS order: this segment's own layout/page if
+        // any, otherwise the first non-null we got from a child.
+        const firstModFilePath = localModFilePath ?? childFirstModFilePath;
         return {
             seedData: getCacheNodeSeedDataFromSegment(segmentData, slots),
             requiresInstantUI,
-            createInstantStack
+            createInstantStack,
+            firstModFilePath,
+            configDepth
         };
     }
     const { seedData, requiresInstantUI, createInstantStack } = await buildSharedTreeSeedData(initialLoaderTree, 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);
-    const headStage = hasRuntimeSegments ? _stagedrendering.RenderStage.Runtime : _stagedrendering.RenderStage.Static;
-    const head = await createValidationHead(cache, releaseSignal, clientReferenceManifest, stageEndTimes, headStage);
+    let headStage;
+    switch(prefetchKind){
+        case 1:
+            {
+                if (useRuntimeStageForPartialSegments) {
+                    headStage = _stagedrendering.RenderStage.Runtime;
+                } else {
+                    headStage = _stagedrendering.RenderStage.ShellRuntime;
+                }
+                break;
+            }
+        case 3:
+            {
+                headStage = hasRuntimeSegments ? _stagedrendering.RenderStage.Runtime : _stagedrendering.RenderStage.Static;
+                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;
+                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;
+                break;
+            }
+    }
+    const head = await createValidationHead(cache, releaseSignal, clientReferenceManifest, headStage);
     const payload = {
         ...initialRSCPayload,
         f: [
@@ -705,8 +926,8 @@ async function createCombinedPayloadAtDepth(initialRSCPayload, cache, initialLoa
     };
     return {
         payload,
-        hasAmbiguousErrors: hasStaticSegments,
-        createInstantStack
+        hasAmbiguousErrors,
+        slotStacks
     };
 }