qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/server/app-render/app-render.js

@@ -42,7 +42,7 @@ const _makegetserverinsertedhtml = require("./make-get-server-inserted-html");
 const _walktreewithflightrouterstate = require("./walk-tree-with-flight-router-state");
 const _createcomponenttree = require("./create-component-tree");
 const _getassetquerystring = require("./get-asset-query-string");
-const _encryptionutils = require("./encryption-utils");
+const _manifestssingleton = require("./manifests-singleton");
 const _postponedstate = require("./postponed-state");
 const _hooksservercontext = require("../../client/components/hooks-server-context");
 const _useflightresponse = require("./use-flight-response");
@@ -50,7 +50,6 @@ const _staticgenerationbailout = require("../../client/components/static-generat
 const _formatservererror = require("../../lib/format-server-error");
 const _dynamicrendering = require("./dynamic-rendering");
 const _clientcomponentrendererlogger = require("../client-component-renderer-logger");
-const _actionutils = require("./action-utils");
 const _helpers = require("../base-http/helpers");
 const _parserelativeurl = require("../../shared/lib/router/utils/parse-relative-url");
 const _approuter = /*#__PURE__*/ _interop_require_default(require("../../client/components/app-router"));
@@ -208,8 +207,8 @@ function createNotFoundLoaderTree(loaderTree) {
         if (!segmentParam) {
             return null;
         }
-        const segmentKey = segmentParam.param;
-        const dynamicParamType = _getshortdynamicparamtype.dynamicParamTypes[segmentParam.type];
+        const segmentKey = segmentParam.paramName;
+        const dynamicParamType = _getshortdynamicparamtype.dynamicParamTypes[segmentParam.paramType];
         return (0, _getdynamicparam.getDynamicParam)(interpolatedParams, segmentKey, dynamicParamType, fallbackRouteParams);
     };
 }
@@ -240,7 +239,7 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
     let flightData = '';
     const { componentMod: { routeModule: { userland: { loaderTree } }, createElement, createMetadataComponents, Fragment }, getDynamicParamFromSegment, query, requestId, flightRouterState, workStore, url } = ctx;
     const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
-    if (!(options == null ? void 0 : options.skipFlight)) {
+    if (!(options == null ? void 0 : options.skipPageRendering)) {
         const preloadCallbacks = [];
         const { Viewport, Metadata, MetadataOutlet } = createMetadataComponents({
             tree: loaderTree,
@@ -278,6 +277,8 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
         })).map((path)=>path.slice(1)) // remove the '' (root) segment
         ;
     }
+    const varyHeader = ctx.res.getHeader('vary');
+    const couldBeIntercepted = typeof varyHeader === 'string' && varyHeader.includes(_approuterheaders.NEXT_URL);
     // If we have an action result, then this is a server action response.
     // We can rely on this because `ActionResult` will always be a promise, even if
     // the result is falsey.
@@ -285,13 +286,17 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
         return {
             a: options.actionResult,
             f: flightData,
-            b: ctx.sharedContext.buildId
+            b: ctx.sharedContext.buildId,
+            q: getRenderedSearch(query),
+            i: !!couldBeIntercepted
         };
     }
     // Otherwise, it's a regular RSC response.
     const baseResponse = {
         b: ctx.sharedContext.buildId,
         f: flightData,
+        q: getRenderedSearch(query),
+        i: !!couldBeIntercepted,
         S: workStore.isStaticGeneration
     };
     // For runtime prefetches, we encode the stale time and isPartial flag in the response body
@@ -321,20 +326,21 @@ function createErrorContext(ctx, renderSource) {
  * Produces a RenderResult containing the Flight data for the given request. See
  * `generateDynamicRSCPayload` for information on the contents of the render result.
  */ async function generateDynamicFlightRenderResult(req, ctx, requestStore, options) {
-    const { clientReferenceManifest, componentMod: { renderToReadableStream }, htmlRequestId, renderOpts, requestId, workStore } = ctx;
-    const { dev = false, onInstrumentationRequestError, setReactDebugChannel } = renderOpts;
-    function onFlightDataRenderError(err) {
-        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'));
+    const { componentMod: { renderToReadableStream }, htmlRequestId, renderOpts, requestId, workStore } = ctx;
+    const { dev = false, onInstrumentationRequestError, setReactDebugChannel, nextExport = false } = renderOpts;
+    function onFlightDataRenderError(err, silenceLog) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
     }
-    const onError = (0, _createerrorhandler.createFlightReactServerErrorHandler)(dev, onFlightDataRenderError);
+    const onError = (0, _createerrorhandler.createReactServerErrorHandler)(dev, nextExport, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
     const debugChannel = setReactDebugChannel && createDebugChannel();
     if (debugChannel) {
         setReactDebugChannel(debugChannel.clientSide, htmlRequestId, requestId);
     }
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     // For app dir, use the bundled version of Flight server renderer (renderToReadableStream)
     // which contains the subset React.
     const rscPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, options);
-    const flightReadableStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, renderToReadableStream, rscPayload, clientReferenceManifest.clientModules, {
+    const flightReadableStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, renderToReadableStream, rscPayload, clientModules, {
         onError,
         temporaryReferences: options == null ? void 0 : options.temporaryReferences,
         filterStackFrame,
@@ -342,23 +348,31 @@ function createErrorContext(ctx, renderSource) {
     });
     return new _flightrenderresult.FlightRenderResult(flightReadableStream, {
         fetchMetrics: workStore.fetchMetrics
-    });
+    }, options == null ? void 0 : options.waitUntil);
 }
-async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore, getPayload, clientReferenceManifest, options) {
+async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore, getPayload, options) {
     const { componentMod: { renderToReadableStream } } = ctx;
     // We're rendering while bypassing caches,
     // so we have no hope of showing a useful runtime stage.
     // But we still want things like `params` to show up in devtools correctly,
     // which relies on mechanisms we've set up for staged rendering,
     // so we do a 2-task version (Static -> Dynamic) instead.
-    const stageController = new _stagedrendering.StagedRenderingController();
+    // We aren't doing any validation in this kind of render so we say there
+    // is not runtime prefetch regardless of whether there is or not
+    const hasRuntimePrefetch = false;
+    // We aren't filling caches so we don't need to abort this render, it'll
+    // stream in a single pass
+    const abortSignal = null;
+    const stageController = new _stagedrendering.StagedRenderingController(abortSignal, hasRuntimePrefetch);
     const environmentName = ()=>{
         const currentStage = stageController.currentStage;
         switch(currentStage){
+            case _stagedrendering.RenderStage.Before:
             case _stagedrendering.RenderStage.Static:
                 return 'Prerender';
             case _stagedrendering.RenderStage.Runtime:
             case _stagedrendering.RenderStage.Dynamic:
+            case _stagedrendering.RenderStage.Abandoned:
                 return 'Server';
             default:
                 currentStage;
@@ -371,9 +385,11 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
     };
     requestStore.stagedRendering = stageController;
     requestStore.asyncApiPromises = createAsyncApiPromisesInDev(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     const rscPayload = await getPayload(requestStore);
     return await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _apprenderrenderutils.scheduleInSequentialTasks, ()=>{
-        return renderToReadableStream(rscPayload, clientReferenceManifest.clientModules, {
+        stageController.advanceStage(_stagedrendering.RenderStage.Static);
+        return renderToReadableStream(rscPayload, clientModules, {
             ...options,
             environmentName
         });
@@ -384,13 +400,16 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
 /**
  * Fork of `generateDynamicFlightRenderResult` that renders using `renderWithRestartOnCacheMissInDev`
  * to ensure correct separation of environments Prerender/Server (for use in Cache Components)
- */ async function generateDynamicFlightRenderResultWithStagesInDev(req, ctx, initialRequestStore, createRequestStore) {
-    const { htmlRequestId, renderOpts, requestId, workStore, componentMod: { createElement } } = ctx;
-    const { dev = false, onInstrumentationRequestError, setReactDebugChannel, setCacheStatus, clientReferenceManifest } = renderOpts;
-    function onFlightDataRenderError(err) {
-        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'));
+ */ async function generateDynamicFlightRenderResultWithStagesInDev(req, ctx, initialRequestStore, createRequestStore, devFallbackParams) {
+    const { htmlRequestId, renderOpts, requestId, workStore, componentMod: { createElement }, url } = ctx;
+    const { dev = false, onInstrumentationRequestError, setReactDebugChannel, setCacheStatus, nextExport = false } = renderOpts;
+    function onFlightDataRenderError(err, silenceLog) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
     }
-    const onError = (0, _createerrorhandler.createFlightReactServerErrorHandler)(dev, onFlightDataRenderError);
+    const onError = (0, _createerrorhandler.createReactServerErrorHandler)(dev, nextExport, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
+    // We only validate RSC requests if it is for HMR refreshes since we know we
+    // will render all the layouts necessary to perform the validation.
+    const shouldValidate = !isBypassingCachesInDev(renderOpts, initialRequestStore) && initialRequestStore.isHmrRefresh === true;
     const getPayload = async (requestStore)=>{
         const payload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, undefined);
         if (isBypassingCachesInDev(renderOpts, requestStore)) {
@@ -399,6 +418,10 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
             payload._bypassCachesInDev = createElement(WarnForBypassCachesInDev, {
                 route: workStore.route
             });
+        } else if (shouldValidate) {
+            // If this payload will be used for validation, it needs to contain the
+            // canonical URL. Without it we'd get an error.
+            payload.c = prepareInitialCanonicalUrl(url);
         }
         return payload;
     };
@@ -414,19 +437,29 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
         if (setCacheStatus) {
             setCacheStatus('ready', htmlRequestId);
         }
-        const result = await renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, createRequestStore, getPayload, onError);
-        debugChannel = result.debugChannel;
-        stream = result.stream;
+        const { stream: serverStream, accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, debugChannel: returnedDebugChannel, requestStore: finalRequestStore } = await renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, createRequestStore, getPayload, onError);
+        if (shouldValidate) {
+            let validationDebugChannelClient = undefined;
+            if (returnedDebugChannel) {
+                const [t1, t2] = returnedDebugChannel.clientSide.readable.tee();
+                returnedDebugChannel.clientSide.readable = t1;
+                validationDebugChannelClient = nodeStreamFromReadableStream(t2);
+            }
+            _consoleasyncstorageexternal.consoleAsyncStorage.run({
+                dim: true
+            }, spawnStaticShellValidationInDev, accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, ctx, finalRequestStore, devFallbackParams, validationDebugChannelClient);
+        }
+        debugChannel = returnedDebugChannel;
+        stream = serverStream;
     } else {
         // We're either bypassing caches or we can't restart the render.
         // Do a dynamic render, but with (basic) environment labels.
-        assertClientReferenceManifest(clientReferenceManifest);
         // Set cache status to bypass when specifically bypassing caches in dev
         if (setCacheStatus) {
             setCacheStatus('bypass', htmlRequestId);
         }
         debugChannel = setReactDebugChannel && createDebugChannel();
-        stream = await stagedRenderToReadableStreamWithoutCachesInDev(ctx, initialRequestStore, getPayload, clientReferenceManifest, {
+        stream = await stagedRenderToReadableStreamWithoutCachesInDev(ctx, initialRequestStore, getPayload, {
             onError: onError,
             filterStackFrame,
             debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
@@ -440,13 +473,13 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
     });
 }
 async function generateRuntimePrefetchResult(req, ctx, requestStore) {
-    const { workStore } = ctx;
-    const renderOpts = ctx.renderOpts;
-    function onFlightDataRenderError(err) {
-        return renderOpts.onInstrumentationRequestError == null ? void 0 : renderOpts.onInstrumentationRequestError.call(renderOpts, err, req, // TODO(runtime-ppr): should we use a different value?
-        createErrorContext(ctx, 'react-server-components-payload'));
+    const { workStore, renderOpts } = ctx;
+    const { nextExport = false, onInstrumentationRequestError } = renderOpts;
+    function onFlightDataRenderError(err, silenceLog) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, // TODO(runtime-ppr): should we use a different value?
+        createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
     }
-    const onError = (0, _createerrorhandler.createFlightReactServerErrorHandler)(false, onFlightDataRenderError);
+    const onError = (0, _createerrorhandler.createReactServerErrorHandler)(false, nextExport, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
     const metadata = {};
     // Generate a random sentinel that will be used as a placeholder in the payload
     // and later replaced by the transform stream
@@ -469,8 +502,7 @@ async function generateRuntimePrefetchResult(req, ctx, requestStore) {
 }
 async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, headers, cookies, draftMode) {
     const { implicitTags, renderOpts, workStore } = ctx;
-    const { clientReferenceManifest, ComponentMod } = renderOpts;
-    assertClientReferenceManifest(clientReferenceManifest);
+    const { ComponentMod } = renderOpts;
     // Prerender controller represents the lifetime of the prerender.
     // It will be aborted when a Task is complete or a synchronously aborting
     // API is called. Notably during cache-filling renders this does not actually
@@ -514,10 +546,11 @@ async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResum
         cookies,
         draftMode
     };
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     // We're not going to use the result of this render because the only time it could be used
     // is if it completes in a microtask and that's likely very rare for any non-trivial app
     const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, getPayload);
-    const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientReferenceManifest.clientModules, {
+    const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientModules, {
         filterStackFrame,
         onError: (err)=>{
             const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
@@ -529,7 +562,7 @@ async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResum
                 // the error is caused by unfinished components within the render
                 return;
             } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
-                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
             }
         },
         // We don't want to stop rendering until the cacheSignal is complete so we pass
@@ -555,7 +588,7 @@ async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResum
         } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
             // We don't normally log these errors because we are going to retry anyway but
             // it can be useful for debugging Next.js itself to get visibility here when needed
-            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
         }
         return null;
     }
@@ -650,8 +683,7 @@ async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResum
 }
 async function finalRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, headers, cookies, draftMode, onError, runtimePrefetchSentinel) {
     const { implicitTags, renderOpts } = ctx;
-    const { clientReferenceManifest, ComponentMod, experimental, isDebugDynamicAccesses } = renderOpts;
-    assertClientReferenceManifest(clientReferenceManifest);
+    const { ComponentMod, experimental, isDebugDynamicAccesses } = renderOpts;
     const selectStaleTime = createSelectStaleTime(experimental);
     let serverIsDynamic = false;
     const finalServerController = new AbortController();
@@ -685,11 +717,12 @@ async function finalRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataC
         cookies,
         draftMode
     };
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     const finalRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPrerenderStore, getPayload);
     let prerenderIsPending = true;
     const result = await (0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasksWithStages)(async ()=>{
         // Static stage
-        const prerenderResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPrerenderStore, ComponentMod.prerender, finalRSCPayload, clientReferenceManifest.clientModules, {
+        const prerenderResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPrerenderStore, ComponentMod.prerender, finalRSCPayload, clientModules, {
             filterStackFrame,
             onError,
             signal: finalServerController.signal
@@ -944,19 +977,10 @@ async function getErrorRSCPayload(tree, ctx, ssrError, errorType) {
         S: workStore.isStaticGeneration
     };
 }
-function assertClientReferenceManifest(clientReferenceManifest) {
-    if (!clientReferenceManifest) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected clientReferenceManifest to be defined.'), "__NEXT_ERROR_CODE", {
-            value: "E692",
-            enumerable: false,
-            configurable: true
-        });
-    }
-}
 // This component must run in an SSR context. It will render the RSC root component
-function App({ reactServerStream, reactDebugStream, preinitScripts, clientReferenceManifest, ServerInsertedHTMLProvider, nonce, images }) {
+function App({ reactServerStream, reactDebugStream, debugEndTime, preinitScripts, ServerInsertedHTMLProvider, nonce, images }) {
     preinitScripts();
-    const response = _react.use((0, _useflightresponse.useFlightStream)(reactServerStream, reactDebugStream, clientReferenceManifest, nonce));
+    const response = _react.use((0, _useflightresponse.getFlightStream)(reactServerStream, reactDebugStream, debugEndTime, nonce));
     const initialState = (0, _createinitialrouterstate.createInitialRouterState)({
         // This is not used during hydration, so we don't have to pass a
         // real timestamp.
@@ -964,7 +988,6 @@ function App({ reactServerStream, reactDebugStream, preinitScripts, clientRefere
         initialFlightData: response.f,
         initialCanonicalUrlParts: response.c,
         initialRenderedSearch: response.q,
-        initialParallelRoutes: new Map(),
         // location is not initialized in the SSR render
         // it's set to window.location during hydration
         location: null
@@ -990,9 +1013,9 @@ function App({ reactServerStream, reactDebugStream, preinitScripts, clientRefere
 // @TODO our error stream should be probably just use the same root component. But it was previously
 // different I don't want to figure out if that is meaningful at this time so just keeping the behavior
 // consistent for now.
-function ErrorApp({ reactServerStream, reactDebugStream, preinitScripts, clientReferenceManifest, ServerInsertedHTMLProvider, nonce, images }) {
+function ErrorApp({ reactServerStream, preinitScripts, ServerInsertedHTMLProvider, nonce, images }) {
     /* eslint-disable @next/internal/no-ambiguous-jsx -- React Client */ preinitScripts();
-    const response = _react.use((0, _useflightresponse.useFlightStream)(reactServerStream, reactDebugStream, clientReferenceManifest, nonce));
+    const response = _react.use((0, _useflightresponse.getFlightStream)(reactServerStream, undefined, undefined, nonce));
     const initialState = (0, _createinitialrouterstate.createInitialRouterState)({
         // This is not used during hydration, so we don't have to pass a
         // real timestamp.
@@ -1000,7 +1023,6 @@ function ErrorApp({ reactServerStream, reactDebugStream, preinitScripts, clientR
         initialFlightData: response.f,
         initialCanonicalUrlParts: response.c,
         initialRenderedSearch: response.q,
-        initialParallelRoutes: new Map(),
         // location is not initialized in the SSR render
         // it's set to window.location during hydration
         location: null
@@ -1026,7 +1048,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
     // avoid that resources can be deduped by React Float if the same resource is
     // rendered or preloaded multiple times: `<link href="a.css?v={Date.now()}"/>`.
     const requestTimestamp = Date.now();
-    const { clientReferenceManifest, serverActionsManifest, ComponentMod, nextFontManifest, serverActions, assetPrefix = '', enableTainting, cacheComponents } = renderOpts;
+    const { ComponentMod, nextFontManifest, serverActions, assetPrefix = '', enableTainting, cacheComponents } = renderOpts;
     // We need to expose the bundled `require` API globally for
     // react-server-dom-webpack. This is a hack until we find a better way.
     if (ComponentMod.__next_app__) {
@@ -1117,16 +1139,6 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         statusCode: isNotFoundPath ? 404 : undefined
     };
     const appUsingSizeAdjustment = !!(nextFontManifest == null ? void 0 : nextFontManifest.appUsingSizeAdjust);
-    assertClientReferenceManifest(clientReferenceManifest);
-    const serverModuleMap = (0, _actionutils.createServerModuleMap)({
-        serverActionsManifest
-    });
-    (0, _encryptionutils.setReferenceManifestsSingleton)({
-        page: workStore.page,
-        clientReferenceManifest,
-        serverActionsManifest,
-        serverModuleMap
-    });
     ComponentMod.patchFetch();
     // Pull out the hooks/references from the component.
     const { routeModule: { userland: { loaderTree } }, taintObjectReference } = ComponentMod;
@@ -1182,7 +1194,6 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         requestId,
         htmlRequestId,
         pagePath,
-        clientReferenceManifest,
         assetPrefix,
         isNotFoundPath,
         nonce,
@@ -1271,18 +1282,12 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
                 return generateRuntimePrefetchResult(req, ctx, requestStore);
             } else {
                 if (process.env.NODE_ENV === 'development' && process.env.NEXT_RUNTIME !== 'edge' && cacheComponents) {
-                    return generateDynamicFlightRenderResultWithStagesInDev(req, ctx, requestStore, createRequestStore);
+                    return generateDynamicFlightRenderResultWithStagesInDev(req, ctx, requestStore, createRequestStore, devFallbackParams);
                 } else {
                     return generateDynamicFlightRenderResult(req, ctx, requestStore);
                 }
             }
         }
-        const renderToStreamWithTracing = (0, _tracer.getTracer)().wrap(_constants.AppRenderSpan.getBodyResult, {
-            spanName: `render route (app) ${pagePath}`,
-            attributes: {
-                'next.route': pagePath
-            }
-        }, renderToStream);
         let didExecuteServerAction = false;
         let formState = null;
         if (isPossibleActionRequest) {
@@ -1293,7 +1298,6 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
                 req,
                 res,
                 ComponentMod,
-                serverModuleMap,
                 generateFlight: generateDynamicFlightRenderResult,
                 workStore,
                 requestStore,
@@ -1306,7 +1310,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
                     const notFoundLoaderTree = createNotFoundLoaderTree(loaderTree);
                     res.statusCode = 404;
                     metadata.statusCode = 404;
-                    const stream = await renderToStreamWithTracing(requestStore, req, res, ctx, notFoundLoaderTree, formState, postponedState, metadata, undefined, devFallbackParams);
+                    const stream = await renderToStream(requestStore, req, res, ctx, notFoundLoaderTree, formState, postponedState, metadata, undefined, devFallbackParams);
                     return new _renderresult.default(stream, {
                         metadata,
                         contentType: _constants1.HTML_CONTENT_TYPE_HEADER
@@ -1328,7 +1332,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
             metadata,
             contentType: _constants1.HTML_CONTENT_TYPE_HEADER
         };
-        const stream = await renderToStreamWithTracing(// NOTE: in Cache Components (dev), if the render is restarted, it will use a different requestStore
+        const stream = await renderToStream(// NOTE: in Cache Components (dev), if the render is restarted, it will use a different requestStore
         // than the one that we're passing in here.
         requestStore, req, res, ctx, loaderTree, formState, postponedState, metadata, // If we're rendering HTML after an action, we don't want restartable-render behavior
         // because the result should be dynamic, like it is in prod.
@@ -1445,8 +1449,7 @@ function applyMetadataFromPrerenderResult(response, metadata, workStore) {
 }
 async function renderToStream(requestStore, req, res, ctx, tree, formState, postponedState, metadata, createRequestStore, devFallbackParams) {
     /* eslint-disable @next/internal/no-ambiguous-jsx -- React Client */ const { assetPrefix, htmlRequestId, nonce, pagePath, renderOpts, requestId, workStore } = ctx;
-    const { basePath, buildManifest, clientReferenceManifest, ComponentMod: { createElement, renderToReadableStream: serverRenderToReadableStream }, crossOrigin, dev = false, experimental, nextExport = false, onInstrumentationRequestError, page, reactMaxHeadersLength, setReactDebugChannel, shouldWaitOnAllReady, subresourceIntegrityManifest, supportsDynamicResponse, cacheComponents } = renderOpts;
-    assertClientReferenceManifest(clientReferenceManifest);
+    const { basePath, buildManifest, ComponentMod: { createElement, renderToReadableStream: serverRenderToReadableStream }, crossOrigin, dev = false, experimental, nextExport = false, onInstrumentationRequestError, page, reactMaxHeadersLength, setReactDebugChannel, shouldWaitOnAllReady, subresourceIntegrityManifest, supportsDynamicResponse, cacheComponents } = renderOpts;
     const { ServerInsertedHTMLProvider, renderServerInsertedHTML } = (0, _serverinsertedhtml.createServerInsertedHTML)();
     const getServerInsertedMetadata = (0, _createserverinsertedmetadata.createServerInsertedMetadata)(nonce);
     const tracingMetadata = (0, _utils1.getTracedMetadata)((0, _tracer.getTracer)().getTracePropagationData(), experimental.clientTraceMetadata);
@@ -1463,272 +1466,216 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
     // In development mode, set the request ID as a global variable, before the
     // bootstrap script is executed, which depends on it during hydration.
     const bootstrapScriptContent = process.env.NODE_ENV !== 'production' ? `self.__next_r=${JSON.stringify(requestId)}` : undefined;
-    const reactServerErrorsByDigest = new Map();
-    const silenceLogger = false;
-    function onHTMLRenderRSCError(err) {
-        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'));
-    }
-    const serverComponentsErrorHandler = (0, _createerrorhandler.createHTMLReactServerErrorHandler)(dev, nextExport, reactServerErrorsByDigest, silenceLogger, onHTMLRenderRSCError);
-    function onHTMLRenderSSRError(err) {
-        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'server-rendering'));
-    }
-    const allCapturedErrors = [];
-    const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(dev, nextExport, reactServerErrorsByDigest, allCapturedErrors, silenceLogger, onHTMLRenderSSRError);
-    let reactServerResult = null;
-    let reactDebugStream;
-    const setHeader = res.setHeader.bind(res);
-    const appendHeader = res.appendHeader.bind(res);
-    try {
-        if (// We only want this behavior when we have React's dev builds available
-        process.env.NODE_ENV === 'development' && // We only want this behavior when running `next dev`
-        dev && // Edge routes never prerender so we don't have a Prerender environment for anything in edge runtime
-        process.env.NEXT_RUNTIME !== 'edge' && // We only have a Prerender environment for projects opted into cacheComponents
-        cacheComponents) {
-            const [resolveValidation, validationOutlet] = createValidationOutlet();
-            let debugChannel;
-            const getPayload = async (// eslint-disable-next-line @typescript-eslint/no-shadow
-            requestStore)=>{
-                const payload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, res.statusCode === 404);
-                // Placing the validation outlet in the payload is safe
-                // even if we end up discarding a render and restarting,
-                // because we're not going to wait for the stream to complete,
-                // so leaving the validation unresolved is fine.
-                payload._validation = validationOutlet;
-                if (isBypassingCachesInDev(renderOpts, requestStore)) {
-                    // Mark the RSC payload to indicate that caches were bypassed in dev.
-                    // This lets the client know not to cache anything based on this render.
-                    if (renderOpts.setCacheStatus) {
-                        // we know this is available  when cacheComponents is enabled, but typeguard to be safe
-                        renderOpts.setCacheStatus('bypass', htmlRequestId);
+    // Create the "render route (app)" span manually so we can keep it open during streaming.
+    // This is necessary because errors inside Suspense boundaries are reported asynchronously
+    // during stream consumption, after a typical wrapped function would have ended the span.
+    // Note: We pass the full span name as the first argument since startSpan uses it directly.
+    const renderSpan = (0, _tracer.getTracer)().startSpan(`render route (app) ${pagePath}`, {
+        attributes: {
+            'next.span_name': `render route (app) ${pagePath}`,
+            'next.span_type': _constants.AppRenderSpan.getBodyResult,
+            'next.route': pagePath
+        }
+    });
+    // Helper to end the span with error status (used when throwing from catch blocks)
+    const endSpanWithError = (err)=>{
+        if (!renderSpan.isRecording()) return;
+        if (err instanceof Error) {
+            renderSpan.recordException(err);
+            renderSpan.setAttribute('error.type', err.name);
+        }
+        renderSpan.setStatus({
+            code: _tracer.SpanStatusCode.ERROR,
+            message: err instanceof Error ? err.message : undefined
+        });
+        renderSpan.end();
+    };
+    // Run the rest of the function within the span's context so child spans
+    // (like "build component tree", "generateMetadata") are properly parented.
+    return (0, _tracer.getTracer)().withSpan(renderSpan, async ()=>{
+        const { reactServerErrorsByDigest } = workStore;
+        function onHTMLRenderRSCError(err, silenceLog) {
+            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'), silenceLog);
+        }
+        const serverComponentsErrorHandler = (0, _createerrorhandler.createReactServerErrorHandler)(dev, nextExport, reactServerErrorsByDigest, onHTMLRenderRSCError, renderSpan);
+        function onHTMLRenderSSRError(err) {
+            // We don't need to silence logs here. onHTMLRenderSSRError won't be called
+            // at all if the error was logged before in the RSC error handler.
+            const silenceLog = false;
+            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'server-rendering'), silenceLog);
+        }
+        const allCapturedErrors = [];
+        const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(dev, nextExport, reactServerErrorsByDigest, allCapturedErrors, onHTMLRenderSSRError, renderSpan);
+        let reactServerResult = null;
+        let reactDebugStream;
+        const setHeader = res.setHeader.bind(res);
+        const appendHeader = res.appendHeader.bind(res);
+        const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
+        try {
+            if (// We only want this behavior when we have React's dev builds available
+            process.env.NODE_ENV === 'development' && // We only want this behavior when running `next dev`
+            dev && // Edge routes never prerender so we don't have a Prerender environment for anything in edge runtime
+            process.env.NEXT_RUNTIME !== 'edge' && // We only have a Prerender environment for projects opted into cacheComponents
+            cacheComponents) {
+                let debugChannel;
+                const getPayload = async (// eslint-disable-next-line @typescript-eslint/no-shadow
+                requestStore)=>{
+                    const payload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+                    if (isBypassingCachesInDev(renderOpts, requestStore)) {
+                        // Mark the RSC payload to indicate that caches were bypassed in dev.
+                        // This lets the client know not to cache anything based on this render.
+                        if (renderOpts.setCacheStatus) {
+                            // we know this is available  when cacheComponents is enabled, but typeguard to be safe
+                            renderOpts.setCacheStatus('bypass', htmlRequestId);
+                        }
+                        payload._bypassCachesInDev = createElement(WarnForBypassCachesInDev, {
+                            route: workStore.route
+                        });
+                    }
+                    return payload;
+                };
+                if (// We only do this flow if we can safely recreate the store from scratch
+                // (which is not the case for renders after an action)
+                createRequestStore && // We only do this flow if we're not bypassing caches in dev using
+                // "disable cache" in devtools or a hard refresh (cache-control: "no-store")
+                !isBypassingCachesInDev(renderOpts, requestStore)) {
+                    const { stream: serverStream, accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, debugChannel: returnedDebugChannel, requestStore: finalRequestStore } = await renderWithRestartOnCacheMissInDev(ctx, requestStore, createRequestStore, getPayload, serverComponentsErrorHandler);
+                    let validationDebugChannelClient = undefined;
+                    if (returnedDebugChannel) {
+                        const [t1, t2] = returnedDebugChannel.clientSide.readable.tee();
+                        returnedDebugChannel.clientSide.readable = t1;
+                        validationDebugChannelClient = nodeStreamFromReadableStream(t2);
                     }
-                    payload._bypassCachesInDev = createElement(WarnForBypassCachesInDev, {
-                        route: workStore.route
+                    _consoleasyncstorageexternal.consoleAsyncStorage.run({
+                        dim: true
+                    }, spawnStaticShellValidationInDev, accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, ctx, finalRequestStore, devFallbackParams, validationDebugChannelClient);
+                    reactServerResult = new _apprenderprerenderutils.ReactServerResult(serverStream);
+                    requestStore = finalRequestStore;
+                    debugChannel = returnedDebugChannel;
+                } else {
+                    // We're either bypassing caches or we can't restart the render.
+                    // Do a dynamic render, but with (basic) environment labels.
+                    debugChannel = setReactDebugChannel && createDebugChannel();
+                    const serverStream = await stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore, getPayload, {
+                        onError: serverComponentsErrorHandler,
+                        filterStackFrame,
+                        debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
                     });
+                    reactServerResult = new _apprenderprerenderutils.ReactServerResult(serverStream);
+                }
+                if (debugChannel && setReactDebugChannel) {
+                    const [readableSsr, readableBrowser] = debugChannel.clientSide.readable.tee();
+                    reactDebugStream = readableSsr;
+                    setReactDebugChannel({
+                        readable: readableBrowser
+                    }, htmlRequestId, requestId);
                 }
-                return payload;
-            };
-            if (// We only do this flow if we can safely recreate the store from scratch
-            // (which is not the case for renders after an action)
-            createRequestStore && // We only do this flow if we're not bypassing caches in dev using
-            // "disable cache" in devtools or a hard refresh (cache-control: "no-store")
-            !isBypassingCachesInDev(renderOpts, requestStore)) {
-                const { stream: serverStream, debugChannel: returnedDebugChannel, requestStore: finalRequestStore } = await renderWithRestartOnCacheMissInDev(ctx, requestStore, createRequestStore, getPayload, serverComponentsErrorHandler);
-                reactServerResult = new _apprenderprerenderutils.ReactServerResult(serverStream);
-                requestStore = finalRequestStore;
-                debugChannel = returnedDebugChannel;
             } else {
-                // We're either bypassing caches or we can't restart the render.
-                // Do a dynamic render, but with (basic) environment labels.
-                debugChannel = setReactDebugChannel && createDebugChannel();
-                const serverStream = await stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore, getPayload, clientReferenceManifest, {
-                    onError: serverComponentsErrorHandler,
+                // This is a dynamic render. We don't do dynamic tracking because we're not prerendering
+                const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+                const debugChannel = setReactDebugChannel && createDebugChannel();
+                if (debugChannel) {
+                    const [readableSsr, readableBrowser] = debugChannel.clientSide.readable.tee();
+                    reactDebugStream = readableSsr;
+                    setReactDebugChannel({
+                        readable: readableBrowser
+                    }, htmlRequestId, requestId);
+                }
+                reactServerResult = new _apprenderprerenderutils.ReactServerResult(_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, serverRenderToReadableStream, RSCPayload, clientModules, {
                     filterStackFrame,
+                    onError: serverComponentsErrorHandler,
                     debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
-                });
-                reactServerResult = new _apprenderprerenderutils.ReactServerResult(serverStream);
-            }
-            if (debugChannel && setReactDebugChannel) {
-                const [readableSsr, readableBrowser] = debugChannel.clientSide.readable.tee();
-                reactDebugStream = readableSsr;
-                setReactDebugChannel({
-                    readable: readableBrowser
-                }, htmlRequestId, requestId);
-            }
-            // TODO(restart-on-cache-miss):
-            // This can probably be optimized to do less work,
-            // because we've already made sure that we have warm caches.
-            _consoleasyncstorageexternal.consoleAsyncStorage.run({
-                dim: true
-            }, spawnDynamicValidationInDev, resolveValidation, tree, ctx, res.statusCode === 404, clientReferenceManifest, requestStore, devFallbackParams);
-        } else {
-            // This is a dynamic render. We don't do dynamic tracking because we're not prerendering
-            const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, res.statusCode === 404);
-            const debugChannel = setReactDebugChannel && createDebugChannel();
-            if (debugChannel) {
-                const [readableSsr, readableBrowser] = debugChannel.clientSide.readable.tee();
-                reactDebugStream = readableSsr;
-                setReactDebugChannel({
-                    readable: readableBrowser
-                }, htmlRequestId, requestId);
+                }));
             }
-            reactServerResult = new _apprenderprerenderutils.ReactServerResult(_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, serverRenderToReadableStream, RSCPayload, clientReferenceManifest.clientModules, {
-                filterStackFrame,
-                onError: serverComponentsErrorHandler,
-                debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
-            }));
-        }
-        // React doesn't start rendering synchronously but we want the RSC render to have a chance to start
-        // before we begin SSR rendering because we want to capture any available preload headers so we tick
-        // one task before continuing
-        await (0, _scheduler.waitAtLeastOneReactRenderTask)();
-        // If provided, the postpone state should be parsed as JSON so it can be
-        // provided to React.
-        if (typeof renderOpts.postponed === 'string') {
-            if ((postponedState == null ? void 0 : postponedState.type) === _postponedstate.DynamicState.DATA) {
-                // We have a complete HTML Document in the prerender but we need to
-                // still include the new server component render because it was not included
-                // in the static prelude.
-                const inlinedReactServerDataStream = (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.tee(), nonce, formState);
-                return (0, _nodewebstreamshelper.chainStreams)(inlinedReactServerDataStream, (0, _nodewebstreamshelper.createDocumentClosingStream)());
-            } else if (postponedState) {
-                // We assume we have dynamic HTML requiring a resume render to complete
-                const { postponed, preludeState } = (0, _postponedstate.getPostponedFromState)(postponedState);
-                const resume = require('react-dom/server').resume;
-                const htmlStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, resume, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
-                    reactServerStream: reactServerResult.tee(),
-                    reactDebugStream: reactDebugStream,
-                    preinitScripts: preinitScripts,
-                    clientReferenceManifest: clientReferenceManifest,
-                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
-                    nonce: nonce,
-                    images: ctx.renderOpts.images
-                }), postponed, {
-                    onError: htmlRendererErrorHandler,
-                    nonce
-                });
-                const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
-                    polyfills,
-                    renderServerInsertedHTML,
-                    serverCapturedErrors: allCapturedErrors,
-                    basePath,
-                    tracingMetadata: tracingMetadata
-                });
-                return await (0, _nodewebstreamshelper.continueDynamicHTMLResume)(htmlStream, {
-                    // If the prelude is empty (i.e. is no static shell), we should wait for initial HTML to be rendered
-                    // to avoid injecting RSC data too early.
-                    // If we have a non-empty-prelude (i.e. a static HTML shell), then it's already been sent separately,
-                    // so we shouldn't wait for any HTML to be emitted from the resume before sending RSC data.
-                    delayDataUntilFirstHtmlChunk: preludeState === _postponedstate.DynamicHTMLPreludeState.Empty,
-                    inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consume(), nonce, formState),
-                    getServerInsertedHTML,
-                    getServerInsertedMetadata
-                });
-            }
-        }
-        // This is a regular dynamic render
-        const renderToReadableStream = require('react-dom/server').renderToReadableStream;
-        const htmlStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, renderToReadableStream, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
-            reactServerStream: reactServerResult.tee(),
-            reactDebugStream: reactDebugStream,
-            preinitScripts: preinitScripts,
-            clientReferenceManifest: clientReferenceManifest,
-            ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
-            nonce: nonce,
-            images: ctx.renderOpts.images
-        }), {
-            onError: htmlRendererErrorHandler,
-            nonce,
-            onHeaders: (headers)=>{
-                headers.forEach((value, key)=>{
-                    appendHeader(key, value);
-                });
-            },
-            maxHeadersLength: reactMaxHeadersLength,
-            bootstrapScriptContent,
-            bootstrapScripts: [
-                bootstrapScript
-            ],
-            formState
-        });
-        const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
-            polyfills,
-            renderServerInsertedHTML,
-            serverCapturedErrors: allCapturedErrors,
-            basePath,
-            tracingMetadata: tracingMetadata
-        });
-        /**
-     * Rules of Static & Dynamic HTML:
-     *
-     *    1.) We must generate static HTML unless the caller explicitly opts
-     *        in to dynamic HTML support.
-     *
-     *    2.) If dynamic HTML support is requested, we must honor that request
-     *        or throw an error. It is the sole responsibility of the caller to
-     *        ensure they aren't e.g. requesting dynamic HTML for a static page.
-     *
-     *   3.) If `shouldWaitOnAllReady` is true, which indicates we need to
-     *       resolve all suspenses and generate a full HTML. e.g. when it's a
-     *       html limited bot requests, we produce the full HTML content.
-     *
-     * These rules help ensure that other existing features like request caching,
-     * coalescing, and ISR continue working as intended.
-     */ const generateStaticHTML = supportsDynamicResponse !== true || !!shouldWaitOnAllReady;
-        return await (0, _nodewebstreamshelper.continueFizzStream)(htmlStream, {
-            inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consume(), nonce, formState),
-            isStaticGeneration: generateStaticHTML,
-            isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
-            buildId: ctx.workStore.buildId,
-            getServerInsertedHTML,
-            getServerInsertedMetadata,
-            validateRootLayout: dev
-        });
-    } catch (err) {
-        if ((0, _staticgenerationbailout.isStaticGenBailoutError)(err) || typeof err === 'object' && err !== null && 'message' in err && typeof err.message === 'string' && err.message.includes('https://nextjs.org/docs/advanced-features/static-html-export')) {
-            // Ensure that "next dev" prints the red error overlay
-            throw err;
-        }
-        // If a bailout made it to this point, it means it wasn't wrapped inside
-        // a suspense boundary.
-        const shouldBailoutToCSR = (0, _bailouttocsr.isBailoutToCSRError)(err);
-        if (shouldBailoutToCSR) {
-            const stack = (0, _formatservererror.getStackWithoutErrorMessage)(err);
-            (0, _log.error)(`${err.reason} should be wrapped in a suspense boundary at page "${pagePath}". Read more: https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout\n${stack}`);
-            throw err;
-        }
-        let errorType;
-        if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
-            res.statusCode = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
-            metadata.statusCode = res.statusCode;
-            errorType = (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)(res.statusCode);
-        } else if ((0, _redirecterror.isRedirectError)(err)) {
-            errorType = 'redirect';
-            res.statusCode = (0, _redirect.getRedirectStatusCodeFromError)(err);
-            metadata.statusCode = res.statusCode;
-            const redirectUrl = (0, _addpathprefix.addPathPrefix)((0, _redirect.getURLFromRedirectError)(err), basePath);
-            // If there were mutable cookies set, we need to set them on the
-            // response.
-            const headers = new Headers();
-            if ((0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies)) {
-                setHeader('set-cookie', Array.from(headers.values()));
-            }
-            setHeader('location', redirectUrl);
-        } else if (!shouldBailoutToCSR) {
-            res.statusCode = 500;
-            metadata.statusCode = res.statusCode;
-        }
-        const [errorPreinitScripts, errorBootstrapScript] = (0, _requiredscripts.getRequiredScripts)(buildManifest, assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, false), nonce, '/_not-found/page');
-        const errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err.digest) ? null : err, errorType);
-        const errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, serverRenderToReadableStream, errorRSCPayload, clientReferenceManifest.clientModules, {
-            filterStackFrame,
-            onError: serverComponentsErrorHandler
-        });
-        if (reactServerResult === null) {
-            // We errored when we did not have an RSC stream to read from. This is not just a render
-            // error, we need to throw early
-            throw err;
-        }
-        try {
-            const fizzStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _nodewebstreamshelper.renderToInitialFizzStream, {
-                ReactDOMServer: require('react-dom/server'),
-                element: /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
-                    reactServerStream: errorServerStream,
-                    reactDebugStream: undefined,
-                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
-                    preinitScripts: errorPreinitScripts,
-                    clientReferenceManifest: clientReferenceManifest,
-                    nonce: nonce,
-                    images: ctx.renderOpts.images
-                }),
-                streamOptions: {
-                    nonce,
-                    bootstrapScriptContent,
-                    // Include hydration scripts in the HTML
-                    bootstrapScripts: [
-                        errorBootstrapScript
-                    ],
-                    formState
+            // React doesn't start rendering synchronously but we want the RSC render to have a chance to start
+            // before we begin SSR rendering because we want to capture any available preload headers so we tick
+            // one task before continuing
+            await (0, _scheduler.waitAtLeastOneReactRenderTask)();
+            // If provided, the postpone state should be parsed as JSON so it can be
+            // provided to React.
+            if (typeof renderOpts.postponed === 'string') {
+                if ((postponedState == null ? void 0 : postponedState.type) === _postponedstate.DynamicState.DATA) {
+                    // We have a complete HTML Document in the prerender but we need to
+                    // still include the new server component render because it was not included
+                    // in the static prelude.
+                    const inlinedReactServerDataStream = (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.tee(), nonce, formState);
+                    // End the span since there's no async rendering in this path
+                    if (renderSpan.isRecording()) renderSpan.end();
+                    return (0, _nodewebstreamshelper.chainStreams)(inlinedReactServerDataStream, (0, _nodewebstreamshelper.createDocumentClosingStream)());
+                } else if (postponedState) {
+                    // We assume we have dynamic HTML requiring a resume render to complete
+                    const { postponed, preludeState } = (0, _postponedstate.getPostponedFromState)(postponedState);
+                    const resume = require('react-dom/server').resume;
+                    const htmlStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, resume, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                        reactServerStream: reactServerResult.tee(),
+                        reactDebugStream: reactDebugStream,
+                        debugEndTime: undefined,
+                        preinitScripts: preinitScripts,
+                        ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                        nonce: nonce,
+                        images: ctx.renderOpts.images
+                    }), postponed, {
+                        onError: htmlRendererErrorHandler,
+                        nonce
+                    });
+                    // End the render span only after React completed rendering (including anything inside Suspense boundaries)
+                    htmlStream.allReady.finally(()=>{
+                        if (renderSpan.isRecording()) renderSpan.end();
+                    });
+                    const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                        polyfills,
+                        renderServerInsertedHTML,
+                        serverCapturedErrors: allCapturedErrors,
+                        basePath,
+                        tracingMetadata: tracingMetadata
+                    });
+                    return await (0, _nodewebstreamshelper.continueDynamicHTMLResume)(htmlStream, {
+                        // If the prelude is empty (i.e. is no static shell), we should wait for initial HTML to be rendered
+                        // to avoid injecting RSC data too early.
+                        // If we have a non-empty-prelude (i.e. a static HTML shell), then it's already been sent separately,
+                        // so we shouldn't wait for any HTML to be emitted from the resume before sending RSC data.
+                        delayDataUntilFirstHtmlChunk: preludeState === _postponedstate.DynamicHTMLPreludeState.Empty,
+                        inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consume(), nonce, formState),
+                        getServerInsertedHTML,
+                        getServerInsertedMetadata
+                    });
                 }
+            }
+            // This is a regular dynamic render
+            const renderToReadableStream = require('react-dom/server').renderToReadableStream;
+            const htmlStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, renderToReadableStream, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                reactServerStream: reactServerResult.tee(),
+                reactDebugStream: reactDebugStream,
+                debugEndTime: undefined,
+                preinitScripts: preinitScripts,
+                ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                nonce: nonce,
+                images: ctx.renderOpts.images
+            }), {
+                onError: htmlRendererErrorHandler,
+                nonce,
+                onHeaders: (headers)=>{
+                    headers.forEach((value, key)=>{
+                        appendHeader(key, value);
+                    });
+                },
+                maxHeadersLength: reactMaxHeadersLength,
+                bootstrapScriptContent,
+                bootstrapScripts: [
+                    bootstrapScript
+                ],
+                formState
+            });
+            // End the render span only after React completed rendering (including anything inside Suspense boundaries)
+            htmlStream.allReady.finally(()=>{
+                if (renderSpan.isRecording()) renderSpan.end();
+            });
+            const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                polyfills,
+                renderServerInsertedHTML,
+                serverCapturedErrors: allCapturedErrors,
+                basePath,
+                tracingMetadata: tracingMetadata
             });
             /**
        * Rules of Static & Dynamic HTML:
@@ -1739,55 +1686,163 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
        *    2.) If dynamic HTML support is requested, we must honor that request
        *        or throw an error. It is the sole responsibility of the caller to
        *        ensure they aren't e.g. requesting dynamic HTML for a static page.
-       *    3.) If `shouldWaitOnAllReady` is true, which indicates we need to
-       *        resolve all suspenses and generate a full HTML. e.g. when it's a
-       *        html limited bot requests, we produce the full HTML content.
+       *
+       *   3.) If `shouldWaitOnAllReady` is true, which indicates we need to
+       *       resolve all suspenses and generate a full HTML. e.g. when it's a
+       *       html limited bot requests, we produce the full HTML content.
        *
        * These rules help ensure that other existing features like request caching,
        * coalescing, and ISR continue working as intended.
        */ const generateStaticHTML = supportsDynamicResponse !== true || !!shouldWaitOnAllReady;
-            return await (0, _nodewebstreamshelper.continueFizzStream)(fizzStream, {
-                inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(// This is intentionally using the readable datastream from the
-                // main render rather than the flight data from the error page
-                // render
-                reactServerResult.consume(), nonce, formState),
+            return await (0, _nodewebstreamshelper.continueFizzStream)(htmlStream, {
+                inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consume(), nonce, formState),
                 isStaticGeneration: generateStaticHTML,
                 isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
                 buildId: ctx.workStore.buildId,
-                getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
-                    polyfills,
-                    renderServerInsertedHTML,
-                    serverCapturedErrors: [],
-                    basePath,
-                    tracingMetadata: tracingMetadata
-                }),
+                getServerInsertedHTML,
                 getServerInsertedMetadata,
                 validateRootLayout: dev
             });
-        } catch (finalErr) {
-            if (process.env.NODE_ENV === 'development' && (0, _httpaccessfallback.isHTTPAccessFallbackError)(finalErr)) {
-                const { bailOnRootNotFound } = require('../../client/components/dev-root-http-access-fallback-boundary');
-                bailOnRootNotFound();
+        } catch (err) {
+            if ((0, _staticgenerationbailout.isStaticGenBailoutError)(err) || typeof err === 'object' && err !== null && 'message' in err && typeof err.message === 'string' && err.message.includes('https://nextjs.org/docs/advanced-features/static-html-export')) {
+                // Ensure that "next dev" prints the red error overlay
+                endSpanWithError(err);
+                throw err;
+            }
+            // If a bailout made it to this point, it means it wasn't wrapped inside
+            // a suspense boundary.
+            const shouldBailoutToCSR = (0, _bailouttocsr.isBailoutToCSRError)(err);
+            if (shouldBailoutToCSR) {
+                const stack = (0, _formatservererror.getStackWithoutErrorMessage)(err);
+                (0, _log.error)(`${err.reason} should be wrapped in a suspense boundary at page "${pagePath}". Read more: https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout\n${stack}`);
+                endSpanWithError(err);
+                throw err;
+            }
+            let errorType;
+            if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
+                res.statusCode = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
+                metadata.statusCode = res.statusCode;
+                errorType = (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)(res.statusCode);
+            } else if ((0, _redirecterror.isRedirectError)(err)) {
+                errorType = 'redirect';
+                res.statusCode = (0, _redirect.getRedirectStatusCodeFromError)(err);
+                metadata.statusCode = res.statusCode;
+                const redirectUrl = (0, _addpathprefix.addPathPrefix)((0, _redirect.getURLFromRedirectError)(err), basePath);
+                // If there were mutable cookies set, we need to set them on the
+                // response.
+                const headers = new Headers();
+                if ((0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies)) {
+                    setHeader('set-cookie', Array.from(headers.values()));
+                }
+                setHeader('location', redirectUrl);
+            } else if (!shouldBailoutToCSR) {
+                res.statusCode = 500;
+                metadata.statusCode = res.statusCode;
+            }
+            const [errorPreinitScripts, errorBootstrapScript] = (0, _requiredscripts.getRequiredScripts)(buildManifest, assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, false), nonce, '/_not-found/page');
+            let errorRSCPayload;
+            let errorServerStream;
+            try {
+                errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err.digest) ? null : err, errorType);
+                errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, serverRenderToReadableStream, errorRSCPayload, clientModules, {
+                    filterStackFrame,
+                    onError: serverComponentsErrorHandler
+                });
+                if (reactServerResult === null) {
+                    // We errored when we did not have an RSC stream to read from. This is not just a render
+                    // error, we need to throw early
+                    endSpanWithError(err);
+                    throw err;
+                }
+            } catch (setupErr) {
+                endSpanWithError(setupErr);
+                throw setupErr;
+            }
+            try {
+                const fizzStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _nodewebstreamshelper.renderToInitialFizzStream, {
+                    ReactDOMServer: require('react-dom/server'),
+                    element: /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
+                        reactServerStream: errorServerStream,
+                        ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                        preinitScripts: errorPreinitScripts,
+                        nonce: nonce,
+                        images: ctx.renderOpts.images
+                    }),
+                    streamOptions: {
+                        nonce,
+                        bootstrapScriptContent,
+                        // Include hydration scripts in the HTML
+                        bootstrapScripts: [
+                            errorBootstrapScript
+                        ],
+                        formState
+                    }
+                });
+                // End the render span only after React completed rendering (including anything inside Suspense boundaries)
+                fizzStream.allReady.finally(()=>{
+                    if (renderSpan.isRecording()) renderSpan.end();
+                });
+                /**
+         * Rules of Static & Dynamic HTML:
+         *
+         *    1.) We must generate static HTML unless the caller explicitly opts
+         *        in to dynamic HTML support.
+         *
+         *    2.) If dynamic HTML support is requested, we must honor that request
+         *        or throw an error. It is the sole responsibility of the caller to
+         *        ensure they aren't e.g. requesting dynamic HTML for a static page.
+         *    3.) If `shouldWaitOnAllReady` is true, which indicates we need to
+         *        resolve all suspenses and generate a full HTML. e.g. when it's a
+         *        html limited bot requests, we produce the full HTML content.
+         *
+         * These rules help ensure that other existing features like request caching,
+         * coalescing, and ISR continue working as intended.
+         */ const generateStaticHTML = supportsDynamicResponse !== true || !!shouldWaitOnAllReady;
+                return await (0, _nodewebstreamshelper.continueFizzStream)(fizzStream, {
+                    inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(// This is intentionally using the readable datastream from the
+                    // main render rather than the flight data from the error page
+                    // render
+                    reactServerResult.consume(), nonce, formState),
+                    isStaticGeneration: generateStaticHTML,
+                    isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
+                    buildId: ctx.workStore.buildId,
+                    getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                        polyfills,
+                        renderServerInsertedHTML,
+                        serverCapturedErrors: [],
+                        basePath,
+                        tracingMetadata: tracingMetadata
+                    }),
+                    getServerInsertedMetadata,
+                    validateRootLayout: dev
+                });
+            } catch (finalErr) {
+                if (process.env.NODE_ENV === 'development' && (0, _httpaccessfallback.isHTTPAccessFallbackError)(finalErr)) {
+                    const { bailOnRootNotFound } = require('../../client/components/dev-root-http-access-fallback-boundary');
+                    bailOnRootNotFound();
+                }
+                endSpanWithError(finalErr);
+                throw finalErr;
             }
-            throw finalErr;
         }
-    }
+    });
 /* eslint-enable @next/internal/no-ambiguous-jsx */ }
 async function renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, createRequestStore, getPayload, onError) {
     const { htmlRequestId, renderOpts, componentMod: { routeModule: { userland: { loaderTree } } } } = ctx;
-    const { clientReferenceManifest, ComponentMod, setCacheStatus, setReactDebugChannel } = renderOpts;
-    assertClientReferenceManifest(clientReferenceManifest);
+    const { ComponentMod, setCacheStatus, setReactDebugChannel } = renderOpts;
     const hasRuntimePrefetch = await (0, _stagedvalidation.anySegmentHasRuntimePrefetchEnabled)(loaderTree);
     // If the render is restarted, we'll recreate a fresh request store
     let requestStore = initialRequestStore;
     const environmentName = ()=>{
         const currentStage = requestStore.stagedRendering.currentStage;
         switch(currentStage){
+            case _stagedrendering.RenderStage.Before:
             case _stagedrendering.RenderStage.Static:
                 return 'Prerender';
             case _stagedrendering.RenderStage.Runtime:
                 return hasRuntimePrefetch ? 'Prefetch' : 'Prefetchable';
             case _stagedrendering.RenderStage.Dynamic:
+            case _stagedrendering.RenderStage.Abandoned:
                 return 'Server';
             default:
                 currentStage;
@@ -1814,7 +1869,7 @@ async function renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, creat
     const initialReactController = new AbortController();
     const initialDataController = new AbortController() // Controls hanging promises we create
     ;
-    const initialStageController = new _stagedrendering.StagedRenderingController(initialDataController.signal);
+    const initialStageController = new _stagedrendering.StagedRenderingController(initialDataController.signal, hasRuntimePrefetch);
     requestStore.prerenderResumeDataCache = prerenderResumeDataCache;
     // `getRenderResumeDataCache` will fall back to using `prerenderResumeDataCache` as `renderResumeDataCache`,
     // so not having a resume data cache won't break any expectations in case we don't need to restart.
@@ -1823,10 +1878,14 @@ async function renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, creat
     requestStore.asyncApiPromises = createAsyncApiPromisesInDev(initialStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
     requestStore.cacheSignal = cacheSignal;
     let debugChannel = setReactDebugChannel && createDebugChannel();
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
+    // Note: The stage controller starts out in the `Before` stage,
+    // where sync IO does not cause aborts, so it's okay if it happens before render.
     const initialRscPayload = await getPayload(requestStore);
-    const maybeInitialServerStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>(0, _apprenderrenderutils.pipelineInSequentialTasks)(()=>{
+    const maybeInitialStreamResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>(0, _apprenderrenderutils.pipelineInSequentialTasks)(()=>{
             // Static stage
-            const stream = ComponentMod.renderToReadableStream(initialRscPayload, clientReferenceManifest.clientModules, {
+            initialStageController.advanceStage(_stagedrendering.RenderStage.Static);
+            const stream = ComponentMod.renderToReadableStream(initialRscPayload, clientModules, {
                 onError,
                 environmentName,
                 filterStackFrame,
@@ -1839,35 +1898,63 @@ async function renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, creat
             initialReactController.signal.addEventListener('abort', ()=>{
                 initialDataController.abort(initialReactController.signal.reason);
             });
-            return stream;
-        }, (stream)=>{
+            const [continuationStream, accumulatingStream] = stream.tee();
+            const accumulatedChunksPromise = accumulateStreamChunks(accumulatingStream, initialStageController, initialDataController.signal);
+            return {
+                stream: continuationStream,
+                accumulatedChunksPromise
+            };
+        }, ({ stream, accumulatedChunksPromise })=>{
             // Runtime stage
-            initialStageController.advanceStage(_stagedrendering.RenderStage.Runtime);
-            // If we had a cache miss in the static stage, we'll have to disard this stream
+            if (initialStageController.currentStage === _stagedrendering.RenderStage.Abandoned) {
+                // If we abandoned the render in the static stage, we won't proceed further.
+                return null;
+            }
+            // If we had a cache miss in the static stage, we'll have to discard this stream
             // and render again once the caches are warm.
+            // If we already advanced stages we similarly had sync IO that might be from module loading
+            // and need to render again once the caches are warm.
             if (cacheSignal.hasPendingReads()) {
+                // Regardless of whether we are going to abandon this
+                // render we need the unblock runtime b/c it's essential
+                // filling caches.
+                initialStageController.abandonRender();
                 return null;
             }
-            // If there's no cache misses, we'll continue rendering,
-            // and see if there's any cache misses in the runtime stage.
-            return stream;
-        }, async (maybeStream)=>{
+            initialStageController.advanceStage(_stagedrendering.RenderStage.Runtime);
+            return {
+                stream,
+                accumulatedChunksPromise
+            };
+        }, (result)=>{
             // Dynamic stage
+            if (result === null || initialStageController.currentStage === _stagedrendering.RenderStage.Abandoned) {
+                // If we abandoned the render in the static or runtime stage, we won't proceed further.
+                return null;
+            }
             // If we had cache misses in either of the previous stages,
             // then we'll only use this render for filling caches.
             // We won't advance the stage, and thus leave dynamic APIs hanging,
             // because they won't be cached anyway, so it'd be wasted work.
-            if (maybeStream === null || cacheSignal.hasPendingReads()) {
+            if (cacheSignal.hasPendingReads()) {
+                initialStageController.abandonRender();
                 return null;
             }
-            // If there's no cache misses, we'll use this render, so let it advance to the dynamic stage.
+            // Regardless of whether we are going to abandon this
+            // render we need the unblock runtime b/c it's essential
+            // filling caches.
             initialStageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
-            return maybeStream;
+            return result;
         }));
-    if (maybeInitialServerStream !== null) {
-        // No cache misses. We can use the stream as is.
+    if (maybeInitialStreamResult !== null) {
+        // No cache misses. We can use the result as-is.
         return {
-            stream: maybeInitialServerStream,
+            stream: maybeInitialStreamResult.stream,
+            accumulatedChunksPromise: maybeInitialStreamResult.accumulatedChunksPromise,
+            staticInterruptReason: initialStageController.getStaticInterruptReason(),
+            runtimeInterruptReason: initialStageController.getRuntimeInterruptReason(),
+            staticStageEndTime: initialStageController.getStaticStageEndTime(),
+            runtimeStageEndTime: initialStageController.getRuntimeStageEndTime(),
             debugChannel,
             requestStore
         };
@@ -1889,7 +1976,10 @@ async function renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, creat
     //===============================================
     // The initial render acted as a prospective render to warm the caches.
     requestStore = createRequestStore();
-    const finalStageController = new _stagedrendering.StagedRenderingController();
+    // We are going to render this pass all the way through because we've already
+    // filled any caches so we won't be aborting this time.
+    const abortSignal = null;
+    const finalStageController = new _stagedrendering.StagedRenderingController(abortSignal, hasRuntimePrefetch);
     // We've filled the caches, so now we can render as usual,
     // without any cache-filling mechanics.
     requestStore.prerenderResumeDataCache = null;
@@ -1900,33 +1990,103 @@ async function renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, creat
     // The initial render already wrote to its debug channel.
     // We're not using it, so we need to create a new one.
     debugChannel = setReactDebugChannel && createDebugChannel();
+    // Note: The stage controller starts out in the `Before` stage,
+    // where sync IO does not cause aborts, so it's okay if it happens before render.
     const finalRscPayload = await getPayload(requestStore);
-    const finalServerStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>(0, _apprenderrenderutils.pipelineInSequentialTasks)(()=>{
+    const finalStreamResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>(0, _apprenderrenderutils.pipelineInSequentialTasks)(()=>{
             // Static stage
-            return ComponentMod.renderToReadableStream(finalRscPayload, clientReferenceManifest.clientModules, {
+            finalStageController.advanceStage(_stagedrendering.RenderStage.Static);
+            const stream = ComponentMod.renderToReadableStream(finalRscPayload, clientModules, {
                 onError,
                 environmentName,
                 filterStackFrame,
                 debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
             });
-        }, (stream)=>{
+            const [continuationStream, accumulatingStream] = stream.tee();
+            const accumulatedChunksPromise = accumulateStreamChunks(accumulatingStream, finalStageController, null);
+            return {
+                stream: continuationStream,
+                accumulatedChunksPromise
+            };
+        }, (result)=>{
             // Runtime stage
             finalStageController.advanceStage(_stagedrendering.RenderStage.Runtime);
-            return stream;
-        }, (stream)=>{
+            return result;
+        }, (result)=>{
             // Dynamic stage
             finalStageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
-            return stream;
+            return result;
         }));
     if (process.env.NODE_ENV === 'development' && setCacheStatus) {
         setCacheStatus('filled', htmlRequestId);
     }
     return {
-        stream: finalServerStream,
+        stream: finalStreamResult.stream,
+        accumulatedChunksPromise: finalStreamResult.accumulatedChunksPromise,
+        staticInterruptReason: finalStageController.getStaticInterruptReason(),
+        runtimeInterruptReason: finalStageController.getRuntimeInterruptReason(),
+        staticStageEndTime: finalStageController.getStaticStageEndTime(),
+        runtimeStageEndTime: finalStageController.getRuntimeStageEndTime(),
         debugChannel,
         requestStore
     };
 }
+async function accumulateStreamChunks(stream, stageController, signal) {
+    const staticChunks = [];
+    const runtimeChunks = [];
+    const dynamicChunks = [];
+    const reader = stream.getReader();
+    let cancelled = false;
+    function cancel() {
+        if (!cancelled) {
+            cancelled = true;
+            reader.cancel();
+        }
+    }
+    if (signal) {
+        signal.addEventListener('abort', cancel, {
+            once: true
+        });
+    }
+    try {
+        while(!cancelled){
+            const { done, value } = await reader.read();
+            if (done) {
+                cancel();
+                break;
+            }
+            switch(stageController.currentStage){
+                case _stagedrendering.RenderStage.Before:
+                    throw Object.defineProperty(new _invarianterror.InvariantError('Unexpected stream chunk while in Before stage'), "__NEXT_ERROR_CODE", {
+                        value: "E942",
+                        enumerable: false,
+                        configurable: true
+                    });
+                case _stagedrendering.RenderStage.Static:
+                    staticChunks.push(value);
+                // fall through
+                case _stagedrendering.RenderStage.Runtime:
+                    runtimeChunks.push(value);
+                // fall through
+                case _stagedrendering.RenderStage.Dynamic:
+                    dynamicChunks.push(value);
+                    break;
+                case _stagedrendering.RenderStage.Abandoned:
+                    break;
+                default:
+                    stageController.currentStage;
+                    break;
+            }
+        }
+    } catch  {
+    // When we release the lock we may reject the read
+    }
+    return {
+        staticChunks,
+        runtimeChunks,
+        dynamicChunks
+    };
+}
 function createAsyncApiPromisesInDev(stagedRendering, cookies, mutableCookies, headers) {
     return {
         // Runtime APIs
@@ -1944,7 +2104,7 @@ function createDebugChannel() {
         return undefined;
     }
     let readableController;
-    const clientSideReadable = new ReadableStream({
+    let clientSideReadable = new ReadableStream({
         start (controller) {
             readableController = controller;
         }
@@ -1968,103 +2128,114 @@ function createDebugChannel() {
         }
     };
 }
-function createValidationOutlet() {
-    let resolveValidation;
-    let outlet = new Promise((resolve)=>{
-        resolveValidation = resolve;
-    });
-    return [
-        resolveValidation,
-        outlet
-    ];
+/**
+ * Logs the given messages, and sends the error instances to the browser as an
+ * RSC stream, where they can be deserialized and logged (or otherwise presented
+ * in the devtools), while leveraging React's capabilities to not only
+ * source-map the stack frames (via findSourceMapURL), but also create virtual
+ * server modules that allow users to inspect the server source code in the
+ * browser.
+ */ async function logMessagesAndSendErrorsToBrowser(messages, ctx) {
+    const { componentMod: ComponentMod, htmlRequestId, renderOpts } = ctx;
+    const { sendErrorsToBrowser } = renderOpts;
+    const errors = [];
+    for (const message of messages){
+        // Log the error to the CLI. Prevent the logs from being dimmed, which we
+        // apply for other logs during the spawned validation.
+        _consoleasyncstorageexternal.consoleAsyncStorage.exit(()=>{
+            console.error(message);
+        });
+        // Error instances are also sent to the browser. We're currently using a
+        // non-Error message only in debug build mode as a message that is only
+        // meant for the CLI. FIXME: This is a bit spooky action at a distance. We
+        // should maybe have a more explicit way of determining which messages
+        // should be sent to the browser. Regardless, only real errors with a proper
+        // stack make sense to be "replayed" in the browser.
+        if (message instanceof Error) {
+            errors.push(message);
+        }
+    }
+    if (errors.length > 0) {
+        if (!sendErrorsToBrowser) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Expected `sendErrorsToBrowser` to be defined in renderOpts.'), "__NEXT_ERROR_CODE", {
+                value: "E947",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
+        const errorsRscStream = ComponentMod.renderToReadableStream(errors, clientModules, {
+            filterStackFrame
+        });
+        sendErrorsToBrowser(errorsRscStream, htmlRequestId);
+    }
 }
 /**
  * This function is a fork of prerenderToStream cacheComponents branch.
  * While it doesn't return a stream we want it to have identical
  * prerender semantics to prerenderToStream and should update it
  * in conjunction with any changes to that function.
- */ async function spawnDynamicValidationInDev(resolveValidation, tree, ctx, isNotFound, clientReferenceManifest, requestStore, fallbackRouteParams) {
-    var _requestStore_cookies_get;
-    const { componentMod: ComponentMod, getDynamicParamFromSegment, implicitTags, nonce, renderOpts, workStore } = ctx;
+ */ async function spawnStaticShellValidationInDev(accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, ctx, requestStore, fallbackRouteParams, debugChannelClient) {
+    const { componentMod: ComponentMod, getDynamicParamFromSegment, renderOpts, workStore } = ctx;
     const { allowEmptyStaticShell = false } = renderOpts;
-    // These values are placeholder values for this validating render
-    // that are provided during the actual prerenderToStream.
+    const rootParams = (0, _createcomponenttree.getRootParams)(ComponentMod.routeModule.userland.loaderTree, getDynamicParamFromSegment);
+    const hmrRefreshHash = (0, _workunitasyncstorageexternal.getHmrRefreshHash)(workStore, requestStore);
+    // We don't need to continue the prerender process if we already
+    // detected invalid dynamic usage in the initial prerender phase.
+    const { invalidDynamicUsageError } = workStore;
+    if (invalidDynamicUsageError) {
+        return logMessagesAndSendErrorsToBrowser([
+            invalidDynamicUsageError
+        ], ctx);
+    }
+    if (staticInterruptReason) {
+        return logMessagesAndSendErrorsToBrowser([
+            staticInterruptReason
+        ], ctx);
+    }
+    if (runtimeInterruptReason) {
+        return logMessagesAndSendErrorsToBrowser([
+            runtimeInterruptReason
+        ], ctx);
+    }
+    const { staticChunks, runtimeChunks, dynamicChunks } = await accumulatedChunksPromise;
+    // First we warmup SSR with the runtime chunks. This ensures that when we do
+    // the full prerender pass with dynamic tracking module loading won't
+    // interrupt the prerender and can properly observe the entire content
+    await warmupModuleCacheForRuntimeValidationInDev(runtimeChunks, dynamicChunks, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx);
+    let debugChunks = null;
+    if (debugChannelClient) {
+        debugChunks = [];
+        debugChannelClient.on('data', (c)=>debugChunks.push(c));
+    }
+    const runtimeResult = await validateStagedShell(runtimeChunks, dynamicChunks, debugChunks, runtimeStageEndTime, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, hmrRefreshHash, _dynamicrendering.trackDynamicHoleInRuntimeShell);
+    if (runtimeResult.length > 0) {
+        // We have something to report from the runtime validation
+        // We can skip the static validation
+        return logMessagesAndSendErrorsToBrowser(runtimeResult, ctx);
+    }
+    const staticResult = await validateStagedShell(staticChunks, dynamicChunks, debugChunks, staticStageEndTime, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, hmrRefreshHash, _dynamicrendering.trackDynamicHoleInStaticShell);
+    return logMessagesAndSendErrorsToBrowser(staticResult, ctx);
+}
+async function warmupModuleCacheForRuntimeValidationInDev(runtimeServerChunks, allServerChunks, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx) {
+    const { implicitTags, nonce, workStore } = ctx;
+    // Warmup SSR
+    const initialClientPrerenderController = new AbortController();
+    const initialClientReactController = new AbortController();
+    const initialClientRenderController = new AbortController();
     const preinitScripts = ()=>{};
     const { ServerInsertedHTMLProvider } = (0, _serverinsertedhtml.createServerInsertedHTML)();
-    const rootParams = (0, _createcomponenttree.getRootParams)(ComponentMod.routeModule.userland.loaderTree, getDynamicParamFromSegment);
-    const hmrRefreshHash = (_requestStore_cookies_get = requestStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _requestStore_cookies_get.value;
-    // The prerender controller represents the lifetime of the prerender. It will
-    // be aborted when a task is complete or a synchronously aborting API is
-    // called. Notably, during prospective prerenders, this does not actually
-    // terminate the prerender itself, which will continue until all caches are
-    // filled.
-    const initialServerPrerenderController = new AbortController();
-    // This controller is used to abort the React prerender.
-    const initialServerReactController = new AbortController();
-    // This controller represents the lifetime of the React prerender. Its signal
-    // can be used for any I/O operation to abort the I/O and/or to reject, when
-    // prerendering aborts. This includes our own hanging promises for accessing
-    // request data, and for fetch calls. It might be replaced in the future by
-    // React.cacheSignal(). It's aborted after the React controller, so that no
-    // pending I/O can register abort listeners that are called before React's
-    // abort listener is called. This ensures that pending I/O is not rejected too
-    // early when aborting the prerender. Notably, during the prospective
-    // prerender, it is different from the prerender controller because we don't
-    // want to end the React prerender until all caches are filled.
-    const initialServerRenderController = new AbortController();
-    // The cacheSignal helps us track whether caches are still filling or we are
-    // ready to cut the render off.
-    const cacheSignal = new _cachesignal.CacheSignal();
-    const { createElement } = ComponentMod;
-    // The resume data cache here should use a fresh instance as it's
-    // performing a fresh prerender. If we get to implementing the
-    // prerendering of an already prerendered page, we should use the passed
-    // resume data cache instead.
-    const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
-    const initialServerPayloadPrerenderStore = {
-        type: 'prerender',
-        phase: 'render',
-        rootParams,
-        fallbackRouteParams,
-        implicitTags,
-        // While this render signal isn't going to be used to abort a React render while getting the RSC payload
-        // various request data APIs bind to this controller to reject after completion.
-        renderSignal: initialServerRenderController.signal,
-        // When we generate the RSC payload we might abort this controller due to sync IO
-        // but we don't actually care about sync IO in this phase so we use a throw away controller
-        // that isn't connected to anything
-        controller: new AbortController(),
-        // During the initial prerender we need to track all cache reads to ensure
-        // we render long enough to fill every cache it is possible to visit during
-        // the final prerender.
-        cacheSignal,
-        dynamicTracking: null,
-        allowEmptyStaticShell,
-        revalidate: _constants1.INFINITE_CACHE,
-        expire: _constants1.INFINITE_CACHE,
-        stale: _constants1.INFINITE_CACHE,
-        tags: [
-            ...implicitTags.tags
-        ],
-        prerenderResumeDataCache,
-        renderResumeDataCache: null,
-        hmrRefreshHash
-    };
-    // We're not going to use the result of this render because the only time it could be used
-    // is if it completes in a microtask and that's likely very rare for any non-trivial app
-    const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPayloadPrerenderStore, getRSCPayload, tree, ctx, isNotFound);
-    const initialServerPrerenderStore = {
-        type: 'prerender',
+    const initialClientPrerenderStore = {
+        type: 'prerender-client',
         phase: 'render',
         rootParams,
         fallbackRouteParams,
         implicitTags,
-        renderSignal: initialServerRenderController.signal,
-        controller: initialServerPrerenderController,
-        // During the initial prerender we need to track all cache reads to ensure
-        // we render long enough to fill every cache it is possible to visit during
-        // the final prerender.
-        cacheSignal,
+        renderSignal: initialClientRenderController.signal,
+        controller: initialClientPrerenderController,
+        // For HTML Generation the only cache tracked activity
+        // is module loading, which has it's own cache signal
+        cacheSignal: null,
         dynamicTracking: null,
         allowEmptyStaticShell,
         revalidate: _constants1.INFINITE_CACHE,
@@ -2073,12 +2244,24 @@ function createValidationOutlet() {
         tags: [
             ...implicitTags.tags
         ],
-        prerenderResumeDataCache,
+        // TODO should this be removed from client stores?
+        prerenderResumeDataCache: null,
         renderResumeDataCache: null,
-        hmrRefreshHash
+        hmrRefreshHash: undefined
     };
-    const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientReferenceManifest.clientModules, {
-        filterStackFrame,
+    const runtimeServerStream = createNodeStreamFromChunks(runtimeServerChunks, allServerChunks, initialClientReactController.signal);
+    const prerender = require('react-dom/static').prerender;
+    const pendingInitialClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, prerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- React Client
+    /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+        reactServerStream: runtimeServerStream,
+        reactDebugStream: undefined,
+        debugEndTime: undefined,
+        preinitScripts: preinitScripts,
+        ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+        nonce: nonce,
+        images: ctx.renderOpts.images
+    }), {
+        signal: initialClientReactController.signal,
         onError: (err)=>{
             const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
             if (digest) {
@@ -2089,232 +2272,55 @@ function createValidationOutlet() {
                 console.error(err);
                 return undefined;
             }
-            if (initialServerPrerenderController.signal.aborted) {
-                // The render aborted before this error was handled which indicates
-                // the error is caused by unfinished components within the render
-                return;
+            if (initialClientReactController.signal.aborted) {
+            // These are expected errors that might error the prerender. we ignore them.
             } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
-                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                // We don't normally log these errors because we are going to retry anyway but
+                // it can be useful for debugging Next.js itself to get visibility here when needed
+                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
             }
-        },
-        // We don't want to stop rendering until the cacheSignal is complete so we pass
-        // a different signal to this render call than is used by dynamic APIs to signify
-        // transitioning out of the prerender environment
-        signal: initialServerReactController.signal
+        }
     });
     // The listener to abort our own render controller must be added after React
-    // has added its listener, to ensure that pending I/O is not aborted/rejected
-    // too early.
-    initialServerReactController.signal.addEventListener('abort', ()=>{
-        initialServerRenderController.abort();
+    // has added its listener, to ensure that pending I/O is not
+    // aborted/rejected too early.
+    initialClientReactController.signal.addEventListener('abort', ()=>{
+        initialClientRenderController.abort();
     }, {
         once: true
     });
-    // Wait for all caches to be finished filling and for async imports to resolve
-    (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
-    await cacheSignal.cacheReady();
-    initialServerReactController.abort();
-    // We don't need to continue the prerender process if we already
-    // detected invalid dynamic usage in the initial prerender phase.
-    const { invalidDynamicUsageError } = workStore;
-    if (invalidDynamicUsageError) {
-        resolveValidation(createElement(LogSafely, {
-            fn: ()=>{
-                console.error(invalidDynamicUsageError);
-            }
-        }));
-        return;
-    }
-    let initialServerResult;
-    try {
-        initialServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)(pendingInitialServerResult);
-    } catch (err) {
-        if (initialServerReactController.signal.aborted || initialServerPrerenderController.signal.aborted) {
+    pendingInitialClientResult.catch((err)=>{
+        if (initialClientReactController.signal.aborted || (0, _dynamicrendering.isPrerenderInterruptedError)(err)) {
         // These are expected errors that might error the prerender. we ignore them.
         } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
             // We don't normally log these errors because we are going to retry anyway but
             // it can be useful for debugging Next.js itself to get visibility here when needed
-            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
         }
-    }
-    if (initialServerResult) {
-        const initialClientPrerenderController = new AbortController();
-        const initialClientReactController = new AbortController();
-        const initialClientRenderController = new AbortController();
-        const initialClientPrerenderStore = {
-            type: 'prerender-client',
-            phase: 'render',
-            rootParams,
-            fallbackRouteParams,
-            implicitTags,
-            renderSignal: initialClientRenderController.signal,
-            controller: initialClientPrerenderController,
-            // For HTML Generation the only cache tracked activity
-            // is module loading, which has it's own cache signal
-            cacheSignal: null,
-            dynamicTracking: null,
-            allowEmptyStaticShell,
-            revalidate: _constants1.INFINITE_CACHE,
-            expire: _constants1.INFINITE_CACHE,
-            stale: _constants1.INFINITE_CACHE,
-            tags: [
-                ...implicitTags.tags
-            ],
-            prerenderResumeDataCache,
-            renderResumeDataCache: null,
-            hmrRefreshHash: undefined
-        };
-        const prerender = require('react-dom/static').prerender;
-        const pendingInitialClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, prerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- React Client
-        /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
-            reactServerStream: initialServerResult.asUnclosingStream(),
-            reactDebugStream: undefined,
-            preinitScripts: preinitScripts,
-            clientReferenceManifest: clientReferenceManifest,
-            ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
-            nonce: nonce,
-            images: ctx.renderOpts.images
-        }), {
-            signal: initialClientReactController.signal,
-            onError: (err)=>{
-                const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
-                if (digest) {
-                    return digest;
-                }
-                if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
-                    // TODO: Aggregate
-                    console.error(err);
-                    return undefined;
-                }
-                if (initialClientReactController.signal.aborted) {
-                // These are expected errors that might error the prerender. we ignore them.
-                } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
-                    // We don't normally log these errors because we are going to retry anyway but
-                    // it can be useful for debugging Next.js itself to get visibility here when needed
-                    (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
-                }
-            }
-        });
-        // The listener to abort our own render controller must be added after React
-        // has added its listener, to ensure that pending I/O is not
-        // aborted/rejected too early.
-        initialClientReactController.signal.addEventListener('abort', ()=>{
-            initialClientRenderController.abort();
-        }, {
-            once: true
-        });
-        pendingInitialClientResult.catch((err)=>{
-            if (initialClientReactController.signal.aborted || (0, _dynamicrendering.isPrerenderInterruptedError)(err)) {
-            // These are expected errors that might error the prerender. we ignore them.
-            } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
-                // We don't normally log these errors because we are going to retry anyway but
-                // it can be useful for debugging Next.js itself to get visibility here when needed
-                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
-            }
-        });
-        // This is mostly needed for dynamic `import()`s in client components.
-        // Promises passed to client were already awaited above (assuming that they came from cached functions)
-        (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
-        await cacheSignal.cacheReady();
-        initialClientReactController.abort();
-    }
-    const finalServerReactController = new AbortController();
-    const finalServerRenderController = new AbortController();
-    const finalServerPayloadPrerenderStore = {
-        type: 'prerender',
-        phase: 'render',
-        rootParams,
-        fallbackRouteParams,
-        implicitTags,
-        // While this render signal isn't going to be used to abort a React render while getting the RSC payload
-        // various request data APIs bind to this controller to reject after completion.
-        renderSignal: finalServerRenderController.signal,
-        // When we generate the RSC payload we might abort this controller due to sync IO
-        // but we don't actually care about sync IO in this phase so we use a throw away controller
-        // that isn't connected to anything
-        controller: new AbortController(),
-        // All caches we could read must already be filled so no tracking is necessary
-        cacheSignal: null,
-        dynamicTracking: null,
-        allowEmptyStaticShell,
-        revalidate: _constants1.INFINITE_CACHE,
-        expire: _constants1.INFINITE_CACHE,
-        stale: _constants1.INFINITE_CACHE,
-        tags: [
-            ...implicitTags.tags
-        ],
-        prerenderResumeDataCache,
-        renderResumeDataCache: null,
-        hmrRefreshHash
-    };
-    const finalAttemptRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPayloadPrerenderStore, getRSCPayload, tree, ctx, isNotFound);
-    const serverDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(false // isDebugDynamicAccesses
-    );
-    const finalServerPrerenderStore = {
-        type: 'prerender',
-        phase: 'render',
-        rootParams,
-        fallbackRouteParams,
-        implicitTags,
-        renderSignal: finalServerRenderController.signal,
-        controller: finalServerReactController,
-        // All caches we could read must already be filled so no tracking is necessary
-        cacheSignal: null,
-        dynamicTracking: serverDynamicTracking,
-        allowEmptyStaticShell,
-        revalidate: _constants1.INFINITE_CACHE,
-        expire: _constants1.INFINITE_CACHE,
-        stale: _constants1.INFINITE_CACHE,
-        tags: [
-            ...implicitTags.tags
-        ],
-        prerenderResumeDataCache,
-        renderResumeDataCache: null,
-        hmrRefreshHash
-    };
-    const reactServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)((0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasks)(async ()=>{
-        const pendingPrerenderResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(// The store to scope
-        finalServerPrerenderStore, // The function to run
-        ComponentMod.prerender, // ... the arguments for the function to run
-        finalAttemptRSCPayload, clientReferenceManifest.clientModules, {
-            filterStackFrame,
-            onError: (err)=>{
-                if (finalServerReactController.signal.aborted && (0, _dynamicrendering.isPrerenderInterruptedError)(err)) {
-                    return err.digest;
-                }
-                if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
-                    // TODO: Aggregate
-                    console.error(err);
-                    return undefined;
-                }
-                return (0, _createerrorhandler.getDigestForWellKnownError)(err);
-            },
-            signal: finalServerReactController.signal
-        });
-        // The listener to abort our own render controller must be added after
-        // React has added its listener, to ensure that pending I/O is not
-        // aborted/rejected too early.
-        finalServerReactController.signal.addEventListener('abort', ()=>{
-            finalServerRenderController.abort();
-        }, {
-            once: true
-        });
-        return pendingPrerenderResult;
-    }, ()=>{
-        finalServerReactController.abort();
-    }));
+    });
+    // This is mostly needed for dynamic `import()`s in client components.
+    // Promises passed to client were already awaited above (assuming that they came from cached functions)
+    const cacheSignal = new _cachesignal.CacheSignal();
+    (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+    await cacheSignal.cacheReady();
+    initialClientReactController.abort();
+}
+async function validateStagedShell(stageChunks, allServerChunks, debugChunks, debugEndTime, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, hmrRefreshHash, trackDynamicHole) {
+    const { implicitTags, nonce, workStore } = ctx;
     const clientDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(false //isDebugDynamicAccesses
     );
-    const finalClientReactController = new AbortController();
-    const finalClientRenderController = new AbortController();
+    const clientReactController = new AbortController();
+    const clientRenderController = new AbortController();
+    const preinitScripts = ()=>{};
+    const { ServerInsertedHTMLProvider } = (0, _serverinsertedhtml.createServerInsertedHTML)();
     const finalClientPrerenderStore = {
         type: 'prerender-client',
         phase: 'render',
         rootParams,
         fallbackRouteParams,
         implicitTags,
-        renderSignal: finalClientRenderController.signal,
-        controller: finalClientReactController,
+        renderSignal: clientRenderController.signal,
+        controller: clientReactController,
         // No APIs require a cacheSignal through the workUnitStore during the HTML prerender
         cacheSignal: null,
         dynamicTracking: clientDynamicTracking,
@@ -2325,30 +2331,33 @@ function createValidationOutlet() {
         tags: [
             ...implicitTags.tags
         ],
-        prerenderResumeDataCache,
+        // TODO should this be removed from client stores?
+        prerenderResumeDataCache: null,
         renderResumeDataCache: null,
         hmrRefreshHash
     };
-    let dynamicValidation = (0, _dynamicrendering.createDynamicValidationState)();
+    let runtimeDynamicValidation = (0, _dynamicrendering.createDynamicValidationState)();
+    const serverStream = createNodeStreamFromChunks(stageChunks, allServerChunks, clientReactController.signal);
+    const debugChannelClient = debugChunks ? createNodeStreamFromChunks(debugChunks, debugChunks, clientReactController.signal) : undefined;
+    const prerender = require('react-dom/static').prerender;
     try {
-        const prerender = require('react-dom/static').prerender;
         let { prelude: unprocessedPrelude } = await (0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasks)(()=>{
             const pendingFinalClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalClientPrerenderStore, prerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- React Client
             /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
-                reactServerStream: reactServerResult.asUnclosingStream(),
-                reactDebugStream: undefined,
+                reactServerStream: serverStream,
+                reactDebugStream: debugChannelClient,
+                debugEndTime: debugEndTime,
                 preinitScripts: preinitScripts,
-                clientReferenceManifest: clientReferenceManifest,
                 ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                 nonce: nonce,
                 images: ctx.renderOpts.images
             }), {
-                signal: finalClientReactController.signal,
+                signal: clientReactController.signal,
                 onError: (err, errorInfo)=>{
-                    if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || finalClientReactController.signal.aborted) {
+                    if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || clientReactController.signal.aborted) {
                         const componentStack = errorInfo.componentStack;
                         if (typeof componentStack === 'string') {
-                            (0, _dynamicrendering.trackAllowedDynamicAccess)(workStore, componentStack, dynamicValidation, clientDynamicTracking);
+                            trackDynamicHole(workStore, componentStack, runtimeDynamicValidation, clientDynamicTracking);
                         }
                         return;
                     }
@@ -2363,44 +2372,27 @@ function createValidationOutlet() {
             // The listener to abort our own render controller must be added after
             // React has added its listener, to ensure that pending I/O is not
             // aborted/rejected too early.
-            finalClientReactController.signal.addEventListener('abort', ()=>{
-                finalClientRenderController.abort();
+            clientReactController.signal.addEventListener('abort', ()=>{
+                clientRenderController.abort();
             }, {
                 once: true
             });
             return pendingFinalClientResult;
         }, ()=>{
-            finalClientReactController.abort();
+            clientReactController.abort();
         });
         const { preludeIsEmpty } = await (0, _apprenderprerenderutils.processPrelude)(unprocessedPrelude);
-        resolveValidation(createElement(LogSafely, {
-            fn: _dynamicrendering.throwIfDisallowedDynamic.bind(null, workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, dynamicValidation, serverDynamicTracking)
-        }));
+        return (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, runtimeDynamicValidation);
     } catch (thrownValue) {
         // Even if the root errors we still want to report any cache components errors
         // that were discovered before the root errored.
-        let loggingFunction = _dynamicrendering.throwIfDisallowedDynamic.bind(null, workStore, _dynamicrendering.PreludeState.Errored, dynamicValidation, serverDynamicTracking);
+        let errors = (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, _dynamicrendering.PreludeState.Errored, runtimeDynamicValidation);
         if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
-            // We don't normally log these errors because we are going to retry anyway but
-            // it can be useful for debugging Next.js itself to get visibility here when needed
-            const originalLoggingFunction = loggingFunction;
-            loggingFunction = ()=>{
-                console.error('During dynamic validation the root of the page errored. The next logged error is the thrown value. It may be a duplicate of errors reported during the normal development mode render.');
-                console.error(thrownValue);
-                originalLoggingFunction();
-            };
+            errors.unshift('During dynamic validation the root of the page errored. The next logged error is the thrown value. It may be a duplicate of errors reported during the normal development mode render.', thrownValue);
         }
-        resolveValidation(createElement(LogSafely, {
-            fn: loggingFunction
-        }));
+        return errors;
     }
 }
-async function LogSafely({ fn }) {
-    try {
-        await fn();
-    } catch  {}
-    return null;
-}
 /**
  * Determines whether we should generate static flight data.
  */ function shouldGenerateStaticFlightData(workStore) {
@@ -2414,8 +2406,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
     // more explicit than making it an optional function argument
     const formState = null;
     const { assetPrefix, getDynamicParamFromSegment, implicitTags, nonce, pagePath, renderOpts, workStore } = ctx;
-    const { allowEmptyStaticShell = false, basePath, buildManifest, clientReferenceManifest, ComponentMod, crossOrigin, dev = false, experimental, isDebugDynamicAccesses, nextExport = false, onInstrumentationRequestError, page, reactMaxHeadersLength, subresourceIntegrityManifest, cacheComponents } = renderOpts;
-    assertClientReferenceManifest(clientReferenceManifest);
+    const { allowEmptyStaticShell = false, basePath, buildManifest, ComponentMod, crossOrigin, dev = false, experimental, isDebugDynamicAccesses, nextExport = false, onInstrumentationRequestError, page, reactMaxHeadersLength, subresourceIntegrityManifest, cacheComponents } = renderOpts;
     const rootParams = (0, _createcomponenttree.getRootParams)(tree, getDynamicParamFromSegment);
     const { ServerInsertedHTMLProvider, renderServerInsertedHTML } = (0, _serverinsertedhtml.createServerInsertedHTML)();
     const getServerInsertedMetadata = (0, _createserverinsertedmetadata.createServerInsertedMetadata)(nonce);
@@ -2430,18 +2421,25 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
     const [preinitScripts, bootstrapScript] = (0, _requiredscripts.getRequiredScripts)(buildManifest, // Why is assetPrefix optional on renderOpts?
     // @TODO make it default empty string on renderOpts and get rid of it from ctx
     assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, true), nonce, page);
-    const reactServerErrorsByDigest = new Map();
+    const { reactServerErrorsByDigest } = workStore;
     // We don't report errors during prerendering through our instrumentation hooks
-    const silenceLogger = !!experimental.isRoutePPREnabled;
-    function onHTMLRenderRSCError(err) {
-        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'));
+    const reportErrors = !experimental.isRoutePPREnabled;
+    function onHTMLRenderRSCError(err, silenceLog) {
+        if (reportErrors) {
+            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'), silenceLog);
+        }
     }
-    const serverComponentsErrorHandler = (0, _createerrorhandler.createHTMLReactServerErrorHandler)(dev, nextExport, reactServerErrorsByDigest, silenceLogger, onHTMLRenderRSCError);
+    const serverComponentsErrorHandler = (0, _createerrorhandler.createReactServerErrorHandler)(dev, nextExport, reactServerErrorsByDigest, onHTMLRenderRSCError);
     function onHTMLRenderSSRError(err) {
-        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'server-rendering'));
+        if (reportErrors) {
+            // We don't need to silence logs here. onHTMLRenderSSRError won't be
+            // called at all if the error was logged before in the RSC error handler.
+            const silenceLog = false;
+            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'server-rendering'), silenceLog);
+        }
     }
     const allCapturedErrors = [];
-    const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(dev, nextExport, reactServerErrorsByDigest, allCapturedErrors, silenceLogger, onHTMLRenderSSRError);
+    const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(dev, nextExport, reactServerErrorsByDigest, allCapturedErrors, onHTMLRenderSSRError);
     let reactServerPrerenderResult = null;
     const setMetadataHeader = (name)=>{
         metadata.headers ??= {};
@@ -2463,6 +2461,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
         setMetadataHeader(name);
     };
     const selectStaleTime = createSelectStaleTime(experimental);
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     let prerenderStore = null;
     try {
         if (cacheComponents) {
@@ -2570,7 +2569,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 renderResumeDataCache,
                 hmrRefreshHash: undefined
             };
-            const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientReferenceManifest.clientModules, {
+            const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientModules, {
                 filterStackFrame,
                 onError: (err)=>{
                     const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
@@ -2587,7 +2586,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                         // the error is caused by unfinished components within the render
                         return;
                     } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
-                        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
                     }
                 },
                 // We don't want to stop rendering until the cacheSignal is complete so we pass
@@ -2623,7 +2622,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
                     // We don't normally log these errors because we are going to retry anyway but
                     // it can be useful for debugging Next.js itself to get visibility here when needed
-                    (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                    (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
                 }
             }
             if (initialServerResult) {
@@ -2658,8 +2657,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                     reactServerStream: initialServerResult.asUnclosingStream(),
                     reactDebugStream: undefined,
+                    debugEndTime: undefined,
                     preinitScripts: preinitScripts,
-                    clientReferenceManifest: clientReferenceManifest,
                     ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                     nonce: nonce,
                     images: ctx.renderOpts.images
@@ -2680,7 +2679,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                         } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
                             // We don't normally log these errors because we are going to retry anyway but
                             // it can be useful for debugging Next.js itself to get visibility here when needed
-                            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
                         }
                     },
                     bootstrapScripts: [
@@ -2701,7 +2700,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
                         // We don't normally log these errors because we are going to retry anyway but
                         // it can be useful for debugging Next.js itself to get visibility here when needed
-                        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
                     }
                 });
                 // This is mostly needed for dynamic `import()`s in client components.
@@ -2769,7 +2768,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 const pendingPrerenderResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(// The store to scope
                 finalServerPrerenderStore, // The function to run
                 ComponentMod.prerender, // ... the arguments for the function to run
-                finalAttemptRSCPayload, clientReferenceManifest.clientModules, {
+                finalAttemptRSCPayload, clientModules, {
                     filterStackFrame,
                     onError: (err)=>{
                         return serverComponentsErrorHandler(err);
@@ -2833,8 +2832,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                     reactServerStream: reactServerResult.asUnclosingStream(),
                     reactDebugStream: undefined,
+                    debugEndTime: undefined,
                     preinitScripts: preinitScripts,
-                    clientReferenceManifest: clientReferenceManifest,
                     ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                     nonce: nonce,
                     images: ctx.renderOpts.images
@@ -2941,8 +2940,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                         reactServerStream: foreverStream,
                         reactDebugStream: undefined,
+                        debugEndTime: undefined,
                         preinitScripts: ()=>{},
-                        clientReferenceManifest: clientReferenceManifest,
                         ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                         nonce: nonce,
                         images: ctx.renderOpts.images
@@ -2973,7 +2972,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     // TODO: In the future, rather than defer the entire hydration payload
                     // to be fetched by the client, we should only defer the client
                     // segments, since those are the only ones whose data is not complete.
-                    const emptyReactServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(ComponentMod.renderToReadableStream([], clientReferenceManifest.clientModules, {
+                    const emptyReactServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(ComponentMod.renderToReadableStream([], clientModules, {
                         filterStackFrame,
                         onError: serverComponentsErrorHandler
                     }));
@@ -3028,7 +3027,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             };
             const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(reactServerPrerenderStore, getRSCPayload, tree, ctx, res.statusCode === 404);
             const reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(reactServerPrerenderStore, ComponentMod.renderToReadableStream, // ... the arguments for the function to run
-            RSCPayload, clientReferenceManifest.clientModules, {
+            RSCPayload, clientModules, {
                 filterStackFrame,
                 onError: serverComponentsErrorHandler
             }));
@@ -3052,8 +3051,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                 reactServerStream: reactServerResult.asUnclosingStream(),
                 reactDebugStream: undefined,
+                debugEndTime: undefined,
                 preinitScripts: preinitScripts,
-                clientReferenceManifest: clientReferenceManifest,
                 ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                 nonce: nonce,
                 images: ctx.renderOpts.images
@@ -3165,8 +3164,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                         reactServerStream: foreverStream,
                         reactDebugStream: undefined,
+                        debugEndTime: undefined,
                         preinitScripts: ()=>{},
-                        clientReferenceManifest: clientReferenceManifest,
                         ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                         nonce: nonce,
                         images: ctx.renderOpts.images
@@ -3212,7 +3211,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             // This is a regular static generation. We don't do dynamic tracking because we rely on
             // the old-school dynamic error handling to bail out of static generation
             const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getRSCPayload, tree, ctx, res.statusCode === 404);
-            const reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, ComponentMod.renderToReadableStream, RSCPayload, clientReferenceManifest.clientModules, {
+            const reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, ComponentMod.renderToReadableStream, RSCPayload, clientModules, {
                 filterStackFrame,
                 onError: serverComponentsErrorHandler
             }));
@@ -3221,8 +3220,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                 reactServerStream: reactServerResult.asUnclosingStream(),
                 reactDebugStream: undefined,
+                debugEndTime: undefined,
                 preinitScripts: preinitScripts,
-                clientReferenceManifest: clientReferenceManifest,
                 ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                 nonce: nonce,
                 images: ctx.renderOpts.images
@@ -3315,7 +3314,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             ]
         };
         const errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err.digest) ? undefined : err, errorType);
-        const errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, ComponentMod.renderToReadableStream, errorRSCPayload, clientReferenceManifest.clientModules, {
+        const errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, ComponentMod.renderToReadableStream, errorRSCPayload, clientModules, {
             filterStackFrame,
             onError: serverComponentsErrorHandler
         });
@@ -3328,10 +3327,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 element: // eslint-disable-next-line @next/internal/no-ambiguous-jsx
                 /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
                     reactServerStream: errorServerStream,
-                    reactDebugStream: undefined,
                     ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                     preinitScripts: errorPreinitScripts,
-                    clientReferenceManifest: clientReferenceManifest,
                     nonce: nonce,
                     images: ctx.renderOpts.images
                 }),
@@ -3440,10 +3437,7 @@ async function collectSegmentData(fullPageDataBuffer, prerenderStore, ComponentM
     // For performance, we reuse the Flight output that was created when
     // generating the initial page HTML. The Flight stream for the whole page is
     // decomposed into a separate stream per segment.
-    const clientReferenceManifest = renderOpts.clientReferenceManifest;
-    if (!clientReferenceManifest) {
-        return;
-    }
+    const { clientModules, edgeRscModuleMapping, rscModuleMapping } = (0, _manifestssingleton.getClientReferenceManifest)();
     // Manifest passed to the Flight client for reading the full-page Flight
     // stream. Based off similar code in use-cache-wrapper.ts.
     const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
@@ -3452,12 +3446,12 @@ async function collectSegmentData(fullPageDataBuffer, prerenderStore, ComponentM
         // to be added to the consumer. Instead, we'll wait for any ClientReference to be emitted
         // which themselves will handle the preloading.
         moduleLoading: null,
-        moduleMap: isEdgeRuntime ? clientReferenceManifest.edgeRscModuleMapping : clientReferenceManifest.rscModuleMapping,
-        serverModuleMap: (0, _encryptionutils.getServerModuleMap)()
+        moduleMap: isEdgeRuntime ? edgeRscModuleMapping : rscModuleMapping,
+        serverModuleMap: (0, _manifestssingleton.getServerModuleMap)()
     };
     const selectStaleTime = createSelectStaleTime(renderOpts.experimental);
     const staleTime = selectStaleTime(prerenderStore.stale);
-    return await ComponentMod.collectSegmentData(renderOpts.cacheComponents, fullPageDataBuffer, staleTime, clientReferenceManifest.clientModules, serverConsumerManifest);
+    return await ComponentMod.collectSegmentData(renderOpts.cacheComponents, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest);
 }
 function isBypassingCachesInDev(renderOpts, requestStore) {
     return process.env.NODE_ENV === 'development' && !!renderOpts.dev && requestStore.headers.get('cache-control') === 'no-cache';
@@ -3466,5 +3460,67 @@ function WarnForBypassCachesInDev({ route }) {
     (0, _warnonce.warnOnce)(`Route ${route} is rendering with server caches disabled. For this navigation, Component Metadata in React DevTools will not accurately reflect what is statically prerenderable and runtime prefetchable. See more info here: https://nextjs.org/docs/messages/cache-bypass-in-dev`);
     return null;
 }
+function nodeStreamFromReadableStream(stream) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('nodeStreamFromReadableStream cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
+            value: "E944",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        const reader = stream.getReader();
+        const { Readable } = require('node:stream');
+        return new Readable({
+            read () {
+                reader.read().then(({ done, value })=>{
+                    if (done) {
+                        this.push(null);
+                    } else {
+                        this.push(value);
+                    }
+                }).catch((err)=>this.destroy(err));
+            }
+        });
+    }
+}
+function createNodeStreamFromChunks(partialChunks, allChunks, 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
+        });
+    } else {
+        const { Readable } = require('node:stream');
+        let nextIndex = 0;
+        const readable = new Readable({
+            read () {
+                while(nextIndex < partialChunks.length){
+                    this.push(partialChunks[nextIndex]);
+                    nextIndex++;
+                }
+            }
+        });
+        signal.addEventListener('abort', ()=>{
+            // Flush any remaining chunks from the original set
+            while(nextIndex < partialChunks.length){
+                readable.push(partialChunks[nextIndex]);
+                nextIndex++;
+            }
+            // Flush all chunks since we're now aborted and can't schedule
+            // any new work but these chunks might unblock debugInfo
+            while(nextIndex < allChunks.length){
+                readable.push(allChunks[nextIndex]);
+                nextIndex++;
+            }
+            setImmediate(()=>{
+                readable.push(null);
+            });
+        }, {
+            once: true
+        });
+        return readable;
+    }
+}
 
 //# sourceMappingURL=app-render.js.map