@semiont/frontend 0.3.2 → 0.3.4

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

@@ -12,7 +12,7 @@ const _jsxruntime = require("react/jsx-runtime");
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
 const _renderresult = /*#__PURE__*/ _interop_require_default(require("../render-result"));
-const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
+const _streamops = require("./stream-ops");
 const _internalutils = require("../internal-utils");
 const _approuterheaders = require("../../client/components/app-router-headers");
 const _metadatacontext = require("../../lib/metadata/metadata-context");
@@ -48,6 +48,7 @@ const _hooksservercontext = require("../../client/components/hooks-server-contex
 const _useflightresponse = require("./use-flight-response");
 const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
 const _formatservererror = require("../../lib/format-server-error");
+const _errortelemetryutils = require("../../lib/error-telemetry-utils");
 const _dynamicrendering = require("./dynamic-rendering");
 const _clientcomponentrendererlogger = require("../client-component-renderer-logger");
 const _helpers = require("../base-http/helpers");
@@ -58,6 +59,7 @@ const _createinitialrouterstate = require("../../client/components/router-reduce
 const _approuterinstance = require("../../client/components/app-router-instance");
 const _utils = require("../instrumentation/utils");
 const _segment = require("../../shared/lib/segment");
+const _fallbackparams = require("../request/fallback-params");
 const _apprenderprerenderutils = require("./app-render-prerender-utils");
 const _prospectiverenderutils = require("./prospective-render-utils");
 const _apprenderrenderutils = require("./app-render-render-utils");
@@ -65,8 +67,10 @@ const _scheduler = require("../../lib/scheduler");
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
 const _consoleasyncstorageexternal = require("./console-async-storage.external");
 const _cachesignal = require("./cache-signal");
+const _varyparams = require("./vary-params");
 const _utils1 = require("../lib/trace/utils");
 const _invarianterror = require("../../shared/lib/invariant-error");
+const _staletime = require("./stale-time");
 const _constants1 = require("../../lib/constants");
 const _createcomponentstylesandscripts = require("./create-component-styles-and-scripts");
 const _parseloadertree = require("../../shared/lib/router/utils/parse-loader-tree");
@@ -80,12 +84,16 @@ const _reactlargeshellerror = require("./react-large-shell-error");
 const _segmentexplorerpath = require("./segment-explorer-path");
 const _requestmeta = require("../request-meta");
 const _getdynamicparam = require("../../shared/lib/router/utils/get-dynamic-param");
-const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
 const _imageconfigcontextsharedruntime = require("../../shared/lib/image-config-context.shared-runtime");
 const _imageconfig = require("../../shared/lib/image-config");
 const _stagedrendering = require("./staged-rendering");
-const _stagedvalidation = require("./staged-validation");
+const _instantconfig = require("./instant-validation/instant-config");
 const _warnonce = require("../../shared/lib/utils/warn-once");
+const _debugchannelserver = require("./debug-channel-server");
+const _streamutils = require("./instant-validation/stream-utils");
+const _boundarytracking = require("./instant-validation/boundary-tracking");
+const _cookies = require("../web/spec-extension/cookies");
+const _instantvalidationerror = require("./instant-validation/instant-validation-error");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -132,6 +140,14 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function maybeAppendBuildIdToRSCPayload(ctx, payload) {
+    if (!ctx.sharedContext.deploymentId) {
+        // When using the build id, we need to initialize the id on initial page load, so a build id
+        // header wouldn't be enough.
+        payload.b = ctx.sharedContext.buildId;
+    }
+    return payload;
+}
 const flightDataPathHeadKey = 'h';
 const getFlightViewportKey = (requestId)=>requestId + 'v';
 const getFlightMetadataKey = (requestId)=>requestId + 'm';
@@ -152,8 +168,8 @@ function parseRequestHeaders(headers, options) {
     const previouslyRevalidatedTags = (0, _serverutils.getPreviouslyRevalidatedTags)(headers, options.previewModeId);
     let requestId;
     let htmlRequestId;
-    if (process.env.NODE_ENV !== 'production') {
-        // The request IDs are only used in development mode to send debug
+    if (process.env.__NEXT_DEV_SERVER) {
+        // The request IDs are only used for the dev server to send debug
         // information to the matching client (identified by the HTML request ID
         // that was sent to the client with the HTML document) for the current
         // request (identified by the request ID, as defined by the client).
@@ -173,6 +189,38 @@ function parseRequestHeaders(headers, options) {
         htmlRequestId
     };
 }
+/**
+ * Walks the loader tree to find the minimum `unstable_dynamicStaleTime` exported by
+ * any page module. Returns null if no page exports the config.
+ *
+ * This only reads static exports from page modules — it does not render any
+ * server components, so it's cheap to call.
+ *
+ * TODO: Move this to the prefetch hints file so we don't have to walk the
+ * tree on every render.
+ */ async function getDynamicStaleTime(tree) {
+    const { page, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    let result = null;
+    // Only pages (not layouts) can export unstable_dynamicStaleTime.
+    if (typeof page !== 'undefined') {
+        const pageMod = await page[0]();
+        if (pageMod && typeof pageMod.unstable_dynamicStaleTime === 'number') {
+            const value = pageMod.unstable_dynamicStaleTime;
+            result = result !== null ? Math.min(result, value) : value;
+        }
+    }
+    const childPromises = [];
+    for(const parallelRouteKey in parallelRoutes){
+        childPromises.push(getDynamicStaleTime(parallelRoutes[parallelRouteKey]));
+    }
+    const childResults = await Promise.all(childPromises);
+    for (const childResult of childResults){
+        if (childResult !== null) {
+            result = result !== null ? Math.min(result, childResult) : childResult;
+        }
+    }
+    return result;
+}
 function createNotFoundLoaderTree(loaderTree) {
     const components = loaderTree[2];
     const hasGlobalNotFound = !!components['global-not-found'];
@@ -191,25 +239,33 @@ function createNotFoundLoaderTree(loaderTree) {
             children: [
                 _segment.PAGE_SEGMENT_KEY,
                 {},
-                notFoundTreeComponents
+                notFoundTreeComponents,
+                null
             ]
         },
-        // When global-not-found is present, skip layout from components
-        hasGlobalNotFound ? components : {}
+        // Always include global-error so that getGlobalErrorStyles can access it.
+        // When global-not-found is present, use full components.
+        // Otherwise, only include global-error module.
+        hasGlobalNotFound ? components : {
+            'global-error': components['global-error']
+        },
+        null
     ];
 }
 /**
  * Returns a function that parses the dynamic segment and return the associated value.
- */ function makeGetDynamicParamFromSegment(interpolatedParams, fallbackRouteParams) {
-    return function getDynamicParamFromSegment(// [slug] / [[slug]] / [...slug]
-    segment) {
+ */ function makeGetDynamicParamFromSegment(interpolatedParams, fallbackRouteParams, optimisticRouting) {
+    return function getDynamicParamFromSegment(loaderTree) {
+        const [segment, , , staticSiblings] = loaderTree;
         const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
         if (!segmentParam) {
             return null;
         }
         const segmentKey = segmentParam.paramName;
         const dynamicParamType = _getshortdynamicparamtype.dynamicParamTypes[segmentParam.paramType];
-        return (0, _getdynamicparam.getDynamicParam)(interpolatedParams, segmentKey, dynamicParamType, fallbackRouteParams);
+        // Static siblings are only included when optimistic routing is enabled
+        const siblings = optimisticRouting ? staticSiblings : null;
+        return (0, _getdynamicparam.getDynamicParam)(interpolatedParams, segmentKey, dynamicParamType, fallbackRouteParams, siblings);
     };
 }
 function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction }) {
@@ -237,78 +293,105 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
     // is for server actions, if the server action handler instructs this function to skip it. When the server
     // action reducer sees a falsy value, it'll simply resolve the action with no data.
     let flightData = '';
-    const { componentMod: { routeModule: { userland: { loaderTree } }, createElement, createMetadataComponents, Fragment }, getDynamicParamFromSegment, query, requestId, flightRouterState, workStore, url } = ctx;
+    const { componentMod: { routeModule: { userland: { loaderTree } }, createElement, createMetadataComponents, Fragment }, query, requestId, flightRouterState, workStore, url } = ctx;
     const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
     if (!(options == null ? void 0 : options.skipPageRendering)) {
+        var _ctx_renderOpts_prefetchHints;
         const preloadCallbacks = [];
+        // If we're performing instant validation, we need to render the whole tree,
+        // without skipping shared layouts.
+        const needsFullTree = process.env.__NEXT_DEV_SERVER && ctx.renderOpts.cacheComponents && !(options == null ? void 0 : options.actionResult) && // Only for navigations
+        await (0, _instantconfig.anySegmentNeedsInstantValidationInDev)(loaderTree);
+        const metadataIsRuntimePrefetchable = await (0, _instantconfig.anySegmentHasRuntimePrefetchEnabled)(loaderTree);
         const { Viewport, Metadata, MetadataOutlet } = createMetadataComponents({
             tree: loaderTree,
             parsedQuery: query,
             pathname: url.pathname,
             metadataContext: (0, _metadatacontext.createMetadataContext)(ctx.renderOpts),
-            getDynamicParamFromSegment,
-            workStore,
-            serveStreamingMetadata
+            interpolatedParams: ctx.interpolatedParams,
+            serveStreamingMetadata,
+            isRuntimePrefetchable: metadataIsRuntimePrefetchable
         });
-        flightData = (await (0, _walktreewithflightrouterstate.walkTreeWithFlightRouterState)({
+        const rscHead = createElement(Fragment, {
+            key: flightDataPathHeadKey
+        }, createElement(NonIndex, {
+            createElement,
+            pagePath: ctx.pagePath,
+            statusCode: ctx.res.statusCode,
+            isPossibleServerAction: ctx.isPossibleServerAction
+        }), createElement(Viewport, {
+            key: getFlightViewportKey(requestId)
+        }), createElement(Metadata, {
+            key: getFlightMetadataKey(requestId)
+        }));
+        flightData = (needsFullTree ? await (0, _walktreewithflightrouterstate.createFullTreeFlightDataForNavigation)({
+            ctx,
+            loaderTree,
+            rscHead,
+            injectedCSS: new Set(),
+            injectedJS: new Set(),
+            injectedFontPreloadTags: new Set(),
+            preloadCallbacks,
+            MetadataOutlet
+        }) : await (0, _walktreewithflightrouterstate.walkTreeWithFlightRouterState)({
             ctx,
             loaderTreeToFilter: loaderTree,
             parentParams: {},
             flightRouterState,
-            // For flight, render metadata inside leaf page
-            rscHead: createElement(Fragment, {
-                key: flightDataPathHeadKey
-            }, createElement(NonIndex, {
-                createElement,
-                pagePath: ctx.pagePath,
-                statusCode: ctx.res.statusCode,
-                isPossibleServerAction: ctx.isPossibleServerAction
-            }), createElement(Viewport, {
-                key: getFlightViewportKey(requestId)
-            }), createElement(Metadata, {
-                key: getFlightMetadataKey(requestId)
-            })),
+            rscHead,
             injectedCSS: new Set(),
             injectedJS: new Set(),
             injectedFontPreloadTags: new Set(),
             rootLayoutIncluded: false,
             preloadCallbacks,
-            MetadataOutlet
+            MetadataOutlet,
+            hintTree: ((_ctx_renderOpts_prefetchHints = ctx.renderOpts.prefetchHints) == null ? void 0 : _ctx_renderOpts_prefetchHints[ctx.pagePath]) ?? null
         })).map((path)=>path.slice(1)) // remove the '' (root) segment
         ;
     }
+    // In dev, the Vary header may not reliably reflect whether a route can
+    // be intercepted, because interception routes are compiled on demand.
+    // Default to true so the client doesn't cache a stale Fallback entry.
     const varyHeader = ctx.res.getHeader('vary');
-    const couldBeIntercepted = typeof varyHeader === 'string' && varyHeader.includes(_approuterheaders.NEXT_URL);
+    const couldBeIntercepted = !!process.env.__NEXT_DEV_SERVER || 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.
     if (options == null ? void 0 : options.actionResult) {
-        return {
+        return maybeAppendBuildIdToRSCPayload(ctx, {
             a: options.actionResult,
             f: flightData,
-            b: ctx.sharedContext.buildId,
             q: getRenderedSearch(query),
             i: !!couldBeIntercepted
-        };
+        });
     }
     // Otherwise, it's a regular RSC response.
-    const baseResponse = {
-        b: ctx.sharedContext.buildId,
+    const baseResponse = maybeAppendBuildIdToRSCPayload(ctx, {
         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
-    // rather than relying on response headers. Both of these values will be transformed
-    // by a transform stream before being sent to the client.
-    if ((options == null ? void 0 : options.runtimePrefetchSentinel) !== undefined) {
-        return {
-            ...baseResponse,
-            rp: [
-                options.runtimePrefetchSentinel
-            ]
-        };
+        S: workStore.isStaticGeneration,
+        h: (0, _varyparams.getMetadataVaryParamsThenable)()
+    });
+    if ((options == null ? void 0 : options.staleTimeIterable) !== undefined) {
+        baseResponse.s = options.staleTimeIterable;
+    }
+    if ((options == null ? void 0 : options.staticStageByteLengthPromise) !== undefined) {
+        baseResponse.l = options.staticStageByteLengthPromise;
+    }
+    if ((options == null ? void 0 : options.runtimePrefetchStream) !== undefined) {
+        baseResponse.p = options.runtimePrefetchStream;
+    }
+    // Include the per-page dynamic stale time from unstable_dynamicStaleTime, but only
+    // for dynamic renders (not prerenders/static generation). The client treats
+    // its presence as authoritative.
+    // TODO: Move this to the prefetch hints file so we don't have to walk the
+    // tree on every render.
+    if (!workStore.isStaticGeneration) {
+        const dynamicStaleTime = await getDynamicStaleTime(ctx.componentMod.routeModule.userland.loaderTree);
+        if (dynamicStaleTime !== null) {
+            baseResponse.d = dynamicStaleTime;
+        }
     }
     return baseResponse;
 }
@@ -326,13 +409,13 @@ 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 { componentMod: { renderToReadableStream }, htmlRequestId, renderOpts, requestId, workStore } = ctx;
-    const { dev = false, onInstrumentationRequestError, setReactDebugChannel, nextExport = false } = renderOpts;
+    const { htmlRequestId, renderOpts, requestId, workStore } = ctx;
+    const { onInstrumentationRequestError, setReactDebugChannel, isBuildTimePrerendering = 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.createReactServerErrorHandler)(dev, nextExport, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
-    const debugChannel = setReactDebugChannel && createDebugChannel();
+    const onError = (0, _createerrorhandler.createReactServerErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
+    const debugChannel = setReactDebugChannel && (0, _debugchannelserver.createDebugChannel)();
     if (debugChannel) {
         setReactDebugChannel(debugChannel.clientSide, htmlRequestId, requestId);
     }
@@ -340,36 +423,142 @@ function createErrorContext(ctx, renderSource) {
     // 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, clientModules, {
+    const flightStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFlightStream, ctx.componentMod, rscPayload, clientModules, {
         onError,
         temporaryReferences: options == null ? void 0 : options.temporaryReferences,
         filterStackFrame,
         debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
     });
-    return new _flightrenderresult.FlightRenderResult(flightReadableStream, {
+    return new _flightrenderresult.FlightRenderResult(flightStream, {
         fetchMetrics: workStore.fetchMetrics
     }, options == null ? void 0 : options.waitUntil);
 }
+/**
+ * Production-only staged dynamic flight render for cache components. Uses
+ * staged rendering to separate static (RDC-backed) from runtime/dynamic
+ * content.
+ */ async function generateStagedDynamicFlightRenderResult(req, ctx, requestStore) {
+    const { componentMod, workStore, renderOpts } = ctx;
+    const { renderToReadableStream, routeModule } = componentMod;
+    const { loaderTree } = routeModule.userland;
+    const { onInstrumentationRequestError, experimental } = renderOpts;
+    function onFlightDataRenderError(err, silenceLog) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
+    }
+    const onError = (0, _createerrorhandler.createReactServerErrorHandler)(false, false, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
+    const selectStaleTime = (0, _staletime.createSelectStaleTime)(experimental);
+    const staleTimeIterable = new _staletime.StaleTimeIterable();
+    // TODO(cached-navs): this assumes that we checked during build that there's no sync IO.
+    // but it can happen e.g. after a revalidation or conditionally for a param that wasn't prerendered.
+    // we should change this to track sync IO, log an error and advance to dynamic.
+    const shouldTrackSyncIO = false;
+    const stageController = new _stagedrendering.StagedRenderingController(null, null, shouldTrackSyncIO);
+    // Initialize stale time tracking on the request store.
+    requestStore.stale = _constants1.INFINITE_CACHE;
+    requestStore.stagedRendering = stageController;
+    requestStore.asyncApiPromises = createAsyncApiPromises(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
+    (0, _staletime.trackStaleTime)(requestStore, staleTimeIterable, selectStaleTime);
+    // Deferred promise for the static stage byte length. Flight serializes the
+    // resolved value into the stream so the client knows where the static
+    // prefix ends.
+    let resolveStaticStageByteLength;
+    const staticStageByteLengthPromise = new Promise((resolve)=>{
+        resolveStaticStageByteLength = resolve;
+    });
+    // Check if this route has opted into runtime prefetching via
+    // unstable_instant. If so, we piggyback on the dynamic render to fill caches
+    // and then spawn a final runtime prerender whose result stream is embedded in
+    // the RSC payload. This is gated on the explicit opt-in because it adds extra
+    // server processing, increases the response payload size, and the runtime
+    // prefetch output should have been validated first.
+    const hasRuntimePrefetch = await (0, _instantconfig.anySegmentHasRuntimePrefetchEnabled)(loaderTree);
+    let runtimePrefetchStream;
+    if (hasRuntimePrefetch) {
+        // Create a mutable cache that gets filled during the dynamic render.
+        const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+        requestStore.prerenderResumeDataCache = prerenderResumeDataCache;
+        const cacheSignal = new _cachesignal.CacheSignal();
+        (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+        requestStore.cacheSignal = cacheSignal;
+        // Create a deferred stream for the runtime prefetch result. Its readable
+        // side goes into the RSC payload (Flight serializes it lazily). The
+        // writable side receives the runtime prerender result once the dynamic
+        // render has filled all caches.
+        const runtimePrefetchTransform = new TransformStream();
+        runtimePrefetchStream = runtimePrefetchTransform.readable;
+        // Wait for the dynamic render to fill caches, then run the final runtime
+        // prerender (fire-and-forget — does not block the response).
+        void cacheSignal.cacheReady().then(()=>spawnRuntimePrefetchWithFilledCaches(runtimePrefetchTransform.writable, ctx, prerenderResumeDataCache, requestStore, onError));
+    }
+    const rscPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, {
+        staleTimeIterable,
+        staticStageByteLengthPromise,
+        runtimePrefetchStream
+    });
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
+    const flightReadableStream = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+        stageController.advanceStage(_stagedrendering.RenderStage.Static);
+        const stream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, renderToReadableStream, rscPayload, clientModules, {
+            onError,
+            filterStackFrame
+        });
+        const [dynamicStream, staticStream] = stream.tee();
+        countStaticStageBytes(staticStream, stageController).then(resolveStaticStageByteLength);
+        return dynamicStream;
+    }, ()=>{
+        // This is a separate task that doesn't advance a stage. It forces
+        // draining the microtask queue so that the stale time iterable is closed
+        // before we advance to the dynamic stage.
+        void (0, _staletime.finishStaleTimeTracking)(staleTimeIterable);
+    }, ()=>{
+        stageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
+    });
+    return new _flightrenderresult.FlightRenderResult(flightReadableStream, {
+        fetchMetrics: workStore.fetchMetrics
+    });
+}
+/**
+ * Runs a final runtime prerender using the provided (already filled) cache and
+ * pipes its output into the provided writable stream. The caller is responsible
+ * for waiting until caches are warm before calling this function.
+ */ async function spawnRuntimePrefetchWithFilledCaches(writable, ctx, prerenderResumeDataCache, requestStore, onError) {
+    try {
+        const { componentMod, getDynamicParamFromSegment } = ctx;
+        const { loaderTree } = componentMod.routeModule.userland;
+        const rootParams = (0, _createcomponenttree.getRootParams)(loaderTree, getDynamicParamFromSegment);
+        const staleTimeIterable = new _staletime.StaleTimeIterable();
+        const { result } = await finalRuntimeServerPrerender(ctx, generateDynamicRSCPayload.bind(null, ctx, {
+            staleTimeIterable
+        }), prerenderResumeDataCache, null, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode, onError, staleTimeIterable);
+        await result.prelude.pipeTo(writable);
+    } catch  {
+        // Runtime prerender failed. Close the stream gracefully — the navigation
+        // still works, we just won't get cached runtime data.
+        try {
+            await writable.close();
+        } catch  {
+        // Writable may already be closed/errored.
+        }
+    }
+}
 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.
-    // 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 stageController = new _stagedrendering.StagedRenderingController(null, null, false // do not track sync IO (we don't have reliable stages)
+    );
     const environmentName = ()=>{
         const currentStage = stageController.currentStage;
         switch(currentStage){
             case _stagedrendering.RenderStage.Before:
+            case _stagedrendering.RenderStage.EarlyStatic:
             case _stagedrendering.RenderStage.Static:
                 return 'Prerender';
+            case _stagedrendering.RenderStage.EarlyRuntime:
             case _stagedrendering.RenderStage.Runtime:
             case _stagedrendering.RenderStage.Dynamic:
             case _stagedrendering.RenderStage.Abandoned:
@@ -384,12 +573,12 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
         }
     };
     requestStore.stagedRendering = stageController;
-    requestStore.asyncApiPromises = createAsyncApiPromisesInDev(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
+    requestStore.asyncApiPromises = createAsyncApiPromises(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 await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
         stageController.advanceStage(_stagedrendering.RenderStage.Static);
-        return renderToReadableStream(rscPayload, clientModules, {
+        return _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFlightStream, ctx.componentMod, rscPayload, clientModules, {
             ...options,
             environmentName
         });
@@ -400,19 +589,20 @@ 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, devFallbackParams) {
-    const { htmlRequestId, renderOpts, requestId, workStore, componentMod: { createElement }, url } = ctx;
-    const { dev = false, onInstrumentationRequestError, setReactDebugChannel, setCacheStatus, nextExport = false } = renderOpts;
+ */ async function generateDynamicFlightRenderResultWithStagesInDev(req, ctx, initialRequestStore, createRequestStore, fallbackParams) {
+    const { htmlRequestId, renderOpts, requestId, workStore, componentMod: { createElement, routeModule: { userland: { loaderTree } } }, url } = ctx;
+    const { onInstrumentationRequestError, setReactDebugChannel, setCacheStatus, isBuildTimePrerendering = 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.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 onError = (0, _createerrorhandler.createReactServerErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
+    // We validate RSC requests for HMR refreshes and client navigations when
+    // instant configs exist, since we render all the layouts necessary to perform
+    // the validation in those cases.
+    const shouldValidate = !isBypassingCachesInDev(initialRequestStore) && (initialRequestStore.isHmrRefresh === true || await (0, _instantconfig.anySegmentNeedsInstantValidationInDev)(loaderTree));
     const getPayload = async (requestStore)=>{
         const payload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, undefined);
-        if (isBypassingCachesInDev(renderOpts, requestStore)) {
+        if (isBypassingCachesInDev(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.
             payload._bypassCachesInDev = createElement(WarnForBypassCachesInDev, {
@@ -431,13 +621,13 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
     // (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, initialRequestStore)) {
+    !isBypassingCachesInDev(initialRequestStore)) {
         // Before we kick off the render, we set the cache status back to it's initial state
         // in case a previous render bypassed the cache.
         if (setCacheStatus) {
             setCacheStatus('ready', htmlRequestId);
         }
-        const { stream: serverStream, accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, debugChannel: returnedDebugChannel, requestStore: finalRequestStore } = await renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, createRequestStore, getPayload, onError);
+        const { stream: serverStream, accumulatedChunksPromise, syncInterruptReason, startTime, staticStageEndTime, runtimeStageEndTime, debugChannel: returnedDebugChannel, requestStore: finalRequestStore } = await renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, createRequestStore, getPayload, onError);
         if (shouldValidate) {
             let validationDebugChannelClient = undefined;
             if (returnedDebugChannel) {
@@ -447,7 +637,9 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
             }
             _consoleasyncstorageexternal.consoleAsyncStorage.run({
                 dim: true
-            }, spawnStaticShellValidationInDev, accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, ctx, finalRequestStore, devFallbackParams, validationDebugChannelClient);
+            }, spawnStaticShellValidationInDev, accumulatedChunksPromise, syncInterruptReason, startTime, staticStageEndTime, runtimeStageEndTime, ctx, finalRequestStore, fallbackParams, validationDebugChannelClient);
+        } else {
+            logValidationSkipped(ctx);
         }
         debugChannel = returnedDebugChannel;
         stream = serverStream;
@@ -458,7 +650,7 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
         if (setCacheStatus) {
             setCacheStatus('bypass', htmlRequestId);
         }
-        debugChannel = setReactDebugChannel && createDebugChannel();
+        debugChannel = setReactDebugChannel && (0, _debugchannelserver.createDebugChannel)();
         stream = await stagedRenderToReadableStreamWithoutCachesInDev(ctx, initialRequestStore, getPayload, {
             onError: onError,
             filterStackFrame,
@@ -474,19 +666,14 @@ async function stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore,
 }
 async function generateRuntimePrefetchResult(req, ctx, requestStore) {
     const { workStore, renderOpts } = ctx;
-    const { nextExport = false, onInstrumentationRequestError } = renderOpts;
+    const { isBuildTimePrerendering = 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.createReactServerErrorHandler)(false, nextExport, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
+    const onError = (0, _createerrorhandler.createReactServerErrorHandler)(false, isBuildTimePrerendering, 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
-    const runtimePrefetchSentinel = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
-    const generatePayload = ()=>generateDynamicRSCPayload(ctx, {
-            runtimePrefetchSentinel
-        });
+    const staleTimeIterable = new _staletime.StaleTimeIterable();
     const { componentMod: { routeModule: { userland: { loaderTree } } }, getDynamicParamFromSegment } = ctx;
     const rootParams = (0, _createcomponenttree.getRootParams)(loaderTree, getDynamicParamFromSegment);
     // We need to share caches between the prospective prerender and the final prerender,
@@ -494,8 +681,10 @@ async function generateRuntimePrefetchResult(req, ctx, requestStore) {
     const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
     // We're not resuming an existing render.
     const renderResumeDataCache = null;
-    await prospectiveRuntimeServerPrerender(ctx, generatePayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode);
-    const response = await finalRuntimeServerPrerender(ctx, generatePayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode, onError, runtimePrefetchSentinel);
+    await prospectiveRuntimeServerPrerender(ctx, generateDynamicRSCPayload.bind(null, ctx), prerenderResumeDataCache, renderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode);
+    const response = await finalRuntimeServerPrerender(ctx, generateDynamicRSCPayload.bind(null, ctx, {
+        staleTimeIterable
+    }), prerenderResumeDataCache, renderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode, onError, staleTimeIterable);
     applyMetadataFromPrerenderResult(response, metadata, workStore);
     metadata.fetchMetrics = ctx.workStore.fetchMetrics;
     return new _flightrenderresult.FlightRenderResult(response.result.prelude, metadata);
@@ -539,8 +728,10 @@ async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResum
         renderResumeDataCache,
         prerenderResumeDataCache,
         hmrRefreshHash: undefined,
-        // We only need task sequencing in the final prerender.
-        runtimeStagePromise: null,
+        // We don't track vary params during initial prerender, only the final one
+        varyParamsAccumulator: null,
+        // No stage sequencing needed for prospective renders.
+        stagedRendering: null,
         // These are not present in regular prerenders, but allowed in a runtime prerender.
         headers,
         cookies,
@@ -550,7 +741,7 @@ async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResum
     // 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, clientModules, {
+    const prerenderOptions = {
         filterStackFrame,
         onError: (err)=>{
             const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
@@ -569,7 +760,8 @@ async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResum
         // a different signal to this render call than is used by dynamic APIs to signify
         // transitioning out of the prerender environment
         signal: initialServerRenderController.signal
-    });
+    };
+    const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, (0, _streamops.getServerPrerender)(ComponentMod), initialServerPayload, clientModules, prerenderOptions);
     // Wait for all caches to be finished filling and for async imports to resolve
     (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
     await cacheSignal.cacheReady();
@@ -594,101 +786,29 @@ async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResum
     }
 }
 /**
- * Updates the runtime prefetch metadata in the RSC payload as it streams:
- *   "rp":[<sentinel>] -> "rp":[<isPartial>,<staleTime>]
- *
- * We use a transform stream to do this to avoid needing to trigger an additional render.
- * A random sentinel number guarantees no collision with user data.
- */ function createRuntimePrefetchTransformStream(sentinel, isPartial, staleTime) {
-    const encoder = new TextEncoder();
-    // Search for: [<sentinel>]
-    // Replace with: [<isPartial>,<staleTime>]
-    const search = encoder.encode(`[${sentinel}]`);
-    const first = search[0];
-    const replace = encoder.encode(`[${isPartial},${staleTime}]`);
-    const searchLen = search.length;
-    let currentChunk = null;
-    let found = false;
-    function processChunk(controller, nextChunk) {
-        if (found) {
-            if (nextChunk) {
-                controller.enqueue(nextChunk);
-            }
-            return;
-        }
-        if (currentChunk) {
-            // We can't search past the index that can contain a full match
-            let exclusiveUpperBound = currentChunk.length - (searchLen - 1);
-            if (nextChunk) {
-                // If we have any overflow bytes we can search up to the chunk's final byte
-                exclusiveUpperBound += Math.min(nextChunk.length, searchLen - 1);
-            }
-            if (exclusiveUpperBound < 1) {
-                // we can't match the current chunk.
-                controller.enqueue(currentChunk);
-                currentChunk = nextChunk // advance so we don't process this chunk again
-                ;
-                return;
-            }
-            let currentIndex = currentChunk.indexOf(first);
-            // check the current candidate match if it is within the bounds of our search space for the currentChunk
-            candidateLoop: while(-1 < currentIndex && currentIndex < exclusiveUpperBound){
-                // We already know index 0 matches because we used indexOf to find the candidateIndex so we start at index 1
-                let matchIndex = 1;
-                while(matchIndex < searchLen){
-                    const candidateIndex = currentIndex + matchIndex;
-                    const candidateValue = candidateIndex < currentChunk.length ? currentChunk[candidateIndex] : nextChunk[candidateIndex - currentChunk.length];
-                    if (candidateValue !== search[matchIndex]) {
-                        // No match, reset and continue the search from the next position
-                        currentIndex = currentChunk.indexOf(first, currentIndex + 1);
-                        continue candidateLoop;
-                    }
-                    matchIndex++;
-                }
-                // We found a complete match. currentIndex is our starting point to replace the value.
-                found = true;
-                // enqueue everything up to the match
-                controller.enqueue(currentChunk.subarray(0, currentIndex));
-                // enqueue the replacement value
-                controller.enqueue(replace);
-                // If there are bytes in the currentChunk after the match enqueue them
-                if (currentIndex + searchLen < currentChunk.length) {
-                    controller.enqueue(currentChunk.slice(currentIndex + searchLen));
-                }
-                // If we have a next chunk we enqueue it now
-                if (nextChunk) {
-                    // if replacement spills over to the next chunk we first exclude the replaced bytes
-                    const overflowBytes = currentIndex + searchLen - currentChunk.length;
-                    const truncatedChunk = overflowBytes > 0 ? nextChunk.subarray(overflowBytes) : nextChunk;
-                    controller.enqueue(truncatedChunk);
-                }
-                // We are now in found mode and don't need to track currentChunk anymore
-                currentChunk = null;
-                return;
-            }
-            // No match found in this chunk, emit it and wait for the next one
-            controller.enqueue(currentChunk);
-        }
-        // Advance to the next chunk
-        currentChunk = nextChunk;
-    }
-    return new TransformStream({
-        transform (chunk, controller) {
-            processChunk(controller, chunk);
-        },
-        flush (controller) {
-            processChunk(controller, null);
+ * Prepends a single ASCII byte to the stream indicating whether the response
+ * is partial (contains dynamic holes): '~' (0x7e) for partial, '#' (0x23)
+ * for complete.
+ */ function prependIsPartialByte(stream, isPartial) {
+    const byte = new Uint8Array([
+        isPartial ? 0x7e : 0x23
+    ]);
+    return stream.pipeThrough(new TransformStream({
+        start (controller) {
+            controller.enqueue(byte);
         }
-    });
+    }));
 }
-async function finalRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, headers, cookies, draftMode, onError, runtimePrefetchSentinel) {
+async function finalRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, headers, cookies, draftMode, onError, staleTimeIterable) {
     const { implicitTags, renderOpts } = ctx;
     const { ComponentMod, experimental, isDebugDynamicAccesses } = renderOpts;
-    const selectStaleTime = createSelectStaleTime(experimental);
+    const selectStaleTime = (0, _staletime.createSelectStaleTime)(experimental);
     let serverIsDynamic = false;
     const finalServerController = new AbortController();
     const serverDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
-    const { promise: runtimeStagePromise, resolve: resolveBlockedRuntimeAPIs } = (0, _promisewithresolvers.createPromiseWithResolvers)();
+    const finalStageController = new _stagedrendering.StagedRenderingController(finalServerController.signal, null, true // track sync IO
+    );
+    const varyParamsAccumulator = (0, _varyparams.createResponseVaryParamsAccumulator)();
     const finalServerPrerenderStore = {
         type: 'prerender-runtime',
         phase: 'render',
@@ -710,19 +830,24 @@ async function finalRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataC
         prerenderResumeDataCache,
         renderResumeDataCache,
         hmrRefreshHash: undefined,
-        // Used to separate the "Static" stage from the "Runtime" stage.
-        runtimeStagePromise,
+        varyParamsAccumulator,
+        // Used to separate the stages in the 5-task pipeline.
+        stagedRendering: finalStageController,
         // These are not present in regular prerenders, but allowed in a runtime prerender.
         headers,
         cookies,
         draftMode
     };
+    (0, _staletime.trackStaleTime)(finalServerPrerenderStore, staleTimeIterable, selectStaleTime);
     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, clientModules, {
+    const result = await (0, _apprenderrenderutils.runInSequentialTasks)(async ()=>{
+        // EarlyStatic stage: render begins.
+        // Runtime-prefetchable segments render immediately.
+        // Non-prefetchable segments are gated until the Static stage.
+        finalStageController.advanceStage(_stagedrendering.RenderStage.EarlyStatic);
+        const prerenderResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPrerenderStore, (0, _streamops.getServerPrerender)(ComponentMod), finalRSCPayload, clientModules, {
             filterStackFrame,
             onError,
             signal: finalServerController.signal
@@ -730,33 +855,41 @@ async function finalRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataC
         prerenderIsPending = false;
         return prerenderResult;
     }, ()=>{
-        // Advance to the runtime stage.
-        //
-        // We make runtime APIs hang during the first task (above), and unblock them in the following task (here).
-        // This makes sure that, at this point, we'll have finished all the static parts (what we'd prerender statically).
-        // We know that they don't contain any incorrect sync IO, because that'd have caused a build error.
-        // After we unblock Runtime APIs, if we encounter sync IO (e.g. `await cookies(); Date.now()`),
-        // we'll abort, but we'll produce at least as much output as a static prerender would.
-        resolveBlockedRuntimeAPIs();
+        // Advance to Static stage: resolve promise holding back
+        // non-prefetchable segments so they can begin rendering.
+        finalStageController.advanceStage(_stagedrendering.RenderStage.Static);
     }, ()=>{
-        // Abort.
-        if (finalServerController.signal.aborted) {
-            // If the server controller is already aborted we must have called something
-            // that required aborting the prerender synchronously such as with new Date()
-            serverIsDynamic = true;
-            return;
-        }
-        if (prerenderIsPending) {
-            // If prerenderIsPending then we have blocked for longer than a Task and we assume
-            // there is something unfinished.
-            serverIsDynamic = true;
-        }
-        finalServerController.abort();
+        // Advance to EarlyRuntime stage: resolve cookies/headers for
+        // runtime-prefetchable segments. Sync IO is checked here.
+        finalStageController.advanceStage(_stagedrendering.RenderStage.EarlyRuntime);
+    }, ()=>{
+        // Advance to Runtime stage: resolve cookies/headers for
+        // non-prefetchable segments. Sync IO is allowed here.
+        finalStageController.advanceStage(_stagedrendering.RenderStage.Runtime);
+    }, ()=>{
+        Promise.all([
+            (0, _staletime.finishStaleTimeTracking)(staleTimeIterable),
+            (0, _varyparams.finishAccumulatingVaryParams)(varyParamsAccumulator)
+        ]).then(()=>{
+            // Abort. This runs as a microtask after Flight has flushed the
+            // staleTime and varyParams closing chunks, but before the next
+            // macrotask resolves the overall result.
+            if (finalServerController.signal.aborted) {
+                // If the server controller is already aborted we must have called
+                // something that required aborting the prerender synchronously such
+                // as with new Date()
+                serverIsDynamic = true;
+                return;
+            }
+            if (prerenderIsPending) {
+                // If prerenderIsPending then we have blocked for longer than a Task
+                // and we assume there is something unfinished.
+                serverIsDynamic = true;
+            }
+            finalServerController.abort();
+        });
     });
-    // Update the RSC payload stream to replace the sentinel with actual values.
-    // React has already serialized the payload with the sentinel, so we need to transform the stream.
-    const collectedStale = selectStaleTime(finalServerPrerenderStore.stale);
-    result.prelude = result.prelude.pipeThrough(createRuntimePrefetchTransformStream(runtimePrefetchSentinel, serverIsDynamic, collectedStale));
+    result.prelude = prependIsPartialByte(result.prelude, serverIsDynamic);
     return {
         result,
         // TODO(runtime-ppr): do we need to produce a digest map here?
@@ -765,7 +898,7 @@ async function finalRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataC
         isPartial: serverIsDynamic,
         collectedRevalidate: finalServerPrerenderStore.revalidate,
         collectedExpire: finalServerPrerenderStore.expire,
-        collectedStale,
+        collectedStale: staleTimeIterable.currentValue,
         collectedTags: finalServerPrerenderStore.tags
     };
 }
@@ -805,19 +938,23 @@ function getRenderedSearch(query) {
     return '?' + pairs.join('&');
 }
 // This is the data necessary to render <AppRouter /> when no SSR errors are encountered
-async function getRSCPayload(tree, ctx, is404) {
+async function getRSCPayload(tree, ctx, options) {
+    var _ctx_renderOpts_prefetchHints;
+    const { is404, staleTimeIterable, staticStageByteLengthPromise, runtimePrefetchStream } = options;
     const injectedCSS = new Set();
     const injectedJS = new Set();
     const injectedFontPreloadTags = new Set();
     let missingSlots;
     // We only track missing parallel slots in development
-    if (process.env.NODE_ENV === 'development') {
+    if (process.env.__NEXT_DEV_SERVER) {
         missingSlots = new Set();
     }
     const { getDynamicParamFromSegment, query, appUsingSizeAdjustment, componentMod: { createMetadataComponents, createElement, Fragment }, url, workStore } = ctx;
-    const initialTree = (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(tree, getDynamicParamFromSegment, query);
+    const hints = ((_ctx_renderOpts_prefetchHints = ctx.renderOpts.prefetchHints) == null ? void 0 : _ctx_renderOpts_prefetchHints[ctx.pagePath]) ?? null;
+    const initialTree = await (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(tree, hints, getDynamicParamFromSegment, query);
     const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
     const hasGlobalNotFound = !!tree[2]['global-not-found'];
+    const metadataIsRuntimePrefetchable = await (0, _instantconfig.anySegmentHasRuntimePrefetchEnabled)(tree);
     const { Viewport, Metadata, MetadataOutlet } = createMetadataComponents({
         tree,
         // When it's using global-not-found, metadata errorType is undefined, which will retrieve the
@@ -829,15 +966,17 @@ async function getRSCPayload(tree, ctx, is404) {
         parsedQuery: query,
         pathname: url.pathname,
         metadataContext: (0, _metadatacontext.createMetadataContext)(ctx.renderOpts),
-        getDynamicParamFromSegment,
-        workStore,
-        serveStreamingMetadata
+        interpolatedParams: ctx.interpolatedParams,
+        serveStreamingMetadata,
+        isRuntimePrefetchable: metadataIsRuntimePrefetchable
     });
     const preloadCallbacks = [];
     const seedData = await (0, _createcomponenttree.createComponentTree)({
         ctx,
         loaderTree: tree,
         parentParams: {},
+        parentOptionalCatchAllParamName: null,
+        parentRuntimePrefetchable: false,
         injectedCSS,
         injectedJS,
         injectedFontPreloadTags,
@@ -850,8 +989,11 @@ async function getRSCPayload(tree, ctx, is404) {
     // When the `vary` response header is present with `Next-URL`, that means there's a chance
     // it could respond differently if there's an interception route. We provide this information
     // to `AppRouter` so that it can properly seed the prefetch cache with a prefix, if needed.
+    // In dev, the Vary header may not reliably reflect whether a route can
+    // be intercepted, because interception routes are compiled on demand.
+    // Default to true so the client doesn't cache a stale Fallback entry.
     const varyHeader = ctx.res.getHeader('vary');
-    const couldBeIntercepted = typeof varyHeader === 'string' && varyHeader.includes(_approuterheaders.NEXT_URL);
+    const couldBeIntercepted = !!process.env.__NEXT_DEV_SERVER || typeof varyHeader === 'string' && varyHeader.includes(_approuterheaders.NEXT_URL);
     const initialHead = createElement(Fragment, {
         key: flightDataPathHeadKey
     }, createElement(NonIndex, {
@@ -871,12 +1013,11 @@ async function getRSCPayload(tree, ctx, is404) {
     //
     // See similar comment in create-component-tree.tsx for more context.
     const isPossiblyPartialHead = workStore.isStaticGeneration && ctx.renderOpts.experimental.isRoutePPREnabled === true;
-    return {
+    return maybeAppendBuildIdToRSCPayload(ctx, {
         // See the comment above the `Preloads` component (below) for why this is part of the payload
         P: createElement(Preloads, {
             preloadCallbacks: preloadCallbacks
         }),
-        b: ctx.sharedContext.buildId,
         c: prepareInitialCanonicalUrl(url),
         q: getRenderedSearch(query),
         i: !!couldBeIntercepted,
@@ -893,8 +1034,22 @@ async function getRSCPayload(tree, ctx, is404) {
             GlobalError,
             globalErrorStyles
         ],
-        S: workStore.isStaticGeneration
-    };
+        // Tells the client whether this route supports per-segment prefetching.
+        // With Cache Components, all routes support it. Without it, only fully
+        // static pages do, because their per-segment prefetch responses are
+        // generated during static generation (build or ISR).
+        S: workStore.isStaticGeneration || ctx.renderOpts.cacheComponents,
+        h: (0, _varyparams.getMetadataVaryParamsThenable)(),
+        s: staleTimeIterable,
+        l: staticStageByteLengthPromise,
+        p: runtimePrefetchStream,
+        // Include the per-page dynamic stale time from unstable_dynamicStaleTime, but
+        // only for dynamic renders. The client treats its presence as
+        // authoritative.
+        // TODO: Move this to the prefetch hints file so we don't have to walk
+        // the tree on every render.
+        d: !workStore.isStaticGeneration ? await getDynamicStaleTime(tree) ?? undefined : undefined
+    });
 }
 /**
  * Preload calls (such as `ReactDOM.preloadStyle` and `ReactDOM.preloadFont`) need to be called during rendering
@@ -907,17 +1062,19 @@ async function getRSCPayload(tree, ctx, is404) {
 }
 // This is the data necessary to render <AppRouter /> when an error state is triggered
 async function getErrorRSCPayload(tree, ctx, ssrError, errorType) {
+    var _ctx_renderOpts_prefetchHints;
     const { getDynamicParamFromSegment, query, componentMod: { createMetadataComponents, createElement, Fragment }, url, workStore } = ctx;
     const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
+    const metadataIsRuntimePrefetchable = await (0, _instantconfig.anySegmentHasRuntimePrefetchEnabled)(tree);
     const { Viewport, Metadata } = createMetadataComponents({
         tree,
         parsedQuery: query,
         pathname: url.pathname,
         metadataContext: (0, _metadatacontext.createMetadataContext)(ctx.renderOpts),
         errorType,
-        getDynamicParamFromSegment,
-        workStore,
-        serveStreamingMetadata: serveStreamingMetadata
+        interpolatedParams: ctx.interpolatedParams,
+        serveStreamingMetadata: serveStreamingMetadata,
+        isRuntimePrefetchable: metadataIsRuntimePrefetchable
     });
     const initialHead = createElement(Fragment, {
         key: flightDataPathHeadKey
@@ -926,11 +1083,12 @@ async function getErrorRSCPayload(tree, ctx, ssrError, errorType) {
         pagePath: ctx.pagePath,
         statusCode: ctx.res.statusCode,
         isPossibleServerAction: ctx.isPossibleServerAction
-    }), createElement(Viewport, null), process.env.NODE_ENV === 'development' && createElement('meta', {
+    }), createElement(Viewport, null), process.env.__NEXT_DEV_SERVER && createElement('meta', {
         name: 'next-error',
         content: 'not-found'
     }), createElement(Metadata, null));
-    const initialTree = (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(tree, getDynamicParamFromSegment, query);
+    const errorHints = ((_ctx_renderOpts_prefetchHints = ctx.renderOpts.prefetchHints) == null ? void 0 : _ctx_renderOpts_prefetchHints[ctx.pagePath]) ?? null;
+    const initialTree = await (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(tree, errorHints, getDynamicParamFromSegment, query);
     let err = undefined;
     if (ssrError) {
         err = (0, _iserror.default)(ssrError) ? ssrError : Object.defineProperty(new Error(ssrError + ''), "__NEXT_ERROR_CODE", {
@@ -944,7 +1102,7 @@ async function getErrorRSCPayload(tree, ctx, ssrError, errorType) {
     const seedData = [
         createElement('html', {
             id: '__next_error__'
-        }, createElement('head', null), createElement('body', null, process.env.NODE_ENV !== 'production' && err ? createElement('template', {
+        }, createElement('head', null), createElement('body', null, process.env.__NEXT_DEV_SERVER && err ? createElement('template', {
             'data-next-error-message': err.message,
             'data-next-error-digest': 'digest' in err ? err.digest : '',
             'data-next-error-stack': err.stack
@@ -952,12 +1110,11 @@ async function getErrorRSCPayload(tree, ctx, ssrError, errorType) {
         {},
         null,
         false,
-        false
+        null
     ];
     const { GlobalError, styles: globalErrorStyles } = await getGlobalErrorStyles(tree, ctx);
     const isPossiblyPartialHead = workStore.isStaticGeneration && ctx.renderOpts.experimental.isRoutePPREnabled === true;
-    return {
-        b: ctx.sharedContext.buildId,
+    return maybeAppendBuildIdToRSCPayload(ctx, {
         c: prepareInitialCanonicalUrl(url),
         q: getRenderedSearch(query),
         m: undefined,
@@ -974,8 +1131,13 @@ async function getErrorRSCPayload(tree, ctx, ssrError, errorType) {
             GlobalError,
             globalErrorStyles
         ],
-        S: workStore.isStaticGeneration
-    };
+        // Tells the client whether this route supports per-segment prefetching.
+        // With Cache Components, all routes support it. Without it, only fully
+        // static pages do, because their per-segment prefetch responses are
+        // generated during static generation (build or ISR).
+        S: workStore.isStaticGeneration || ctx.renderOpts.cacheComponents,
+        h: (0, _varyparams.getMetadataVaryParamsThenable)()
+    });
 }
 // This component must run in an SSR context. It will render the RSC root component
 function App({ reactServerStream, reactDebugStream, debugEndTime, preinitScripts, ServerInsertedHTMLProvider, nonce, images }) {
@@ -985,9 +1147,7 @@ function App({ reactServerStream, reactDebugStream, debugEndTime, preinitScripts
         // This is not used during hydration, so we don't have to pass a
         // real timestamp.
         navigatedAt: -1,
-        initialFlightData: response.f,
-        initialCanonicalUrlParts: response.c,
-        initialRenderedSearch: response.q,
+        initialRSCPayload: response,
         // location is not initialized in the SSR render
         // it's set to window.location during hydration
         location: null
@@ -1020,9 +1180,7 @@ function ErrorApp({ reactServerStream, preinitScripts, ServerInsertedHTMLProvide
         // This is not used during hydration, so we don't have to pass a
         // real timestamp.
         navigatedAt: -1,
-        initialFlightData: response.f,
-        initialCanonicalUrlParts: response.c,
-        initialRenderedSearch: response.q,
+        initialRSCPayload: response,
         // location is not initialized in the SSR render
         // it's set to window.location during hydration
         location: null
@@ -1048,7 +1206,8 @@ 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 { ComponentMod, nextFontManifest, serverActions, assetPrefix = '', enableTainting, cacheComponents } = renderOpts;
+    const { ComponentMod, nextFontManifest, serverActions, assetPrefix = '', enableTainting, cacheComponents, setIsrStatus } = renderOpts;
+    const { cachedNavigations } = renderOpts.experimental;
     // 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__) {
@@ -1061,7 +1220,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
             if (!cacheComponents) {
                 return false;
             }
-            if (renderOpts.dev) {
+            if (process.env.__NEXT_DEV_SERVER) {
                 return true;
             }
             const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
@@ -1071,6 +1230,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
             switch(workUnitStore.type){
                 case 'prerender':
                 case 'prerender-client':
+                case 'validation-client':
                 case 'prerender-runtime':
                 case 'cache':
                 case 'private-cache':
@@ -1079,6 +1239,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
                 case 'prerender-legacy':
                 case 'request':
                 case 'unstable-cache':
+                case 'generate-static-params':
                     return false;
                 default:
                     workUnitStore;
@@ -1104,10 +1265,10 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         // @ts-expect-error
         globalThis.__next_chunk_load__ = __next_chunk_load__;
     }
-    if (process.env.NODE_ENV === 'development' && renderOpts.setIsrStatus && !cacheComponents) {
+    if (process.env.__NEXT_DEV_SERVER && setIsrStatus && !cacheComponents) {
         // Reset the ISR status at start of request.
         const { pathname } = new URL(req.url || '/', 'http://n');
-        renderOpts.setIsrStatus(pathname, // Only pages using the Node runtime can use ISR, Edge is always dynamic.
+        setIsrStatus(pathname, // Only pages using the Node runtime can use ISR, Edge is always dynamic.
         process.env.NEXT_RUNTIME === 'edge' ? false : undefined);
     }
     if (// The type check here ensures that `req` is correctly typed, and the
@@ -1175,9 +1336,19 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
     // is the request for the HTML document, so we use the request ID also as the
     // HTML request ID.
     htmlRequestId = parsedRequestHeaders.htmlRequestId || requestId;
-    const getDynamicParamFromSegment = makeGetDynamicParamFromSegment(interpolatedParams, fallbackRouteParams);
+    const getDynamicParamFromSegment = makeGetDynamicParamFromSegment(interpolatedParams, fallbackRouteParams, renderOpts.experimental.optimisticRouting);
     const isPossibleActionRequest = (0, _serveractionrequestmeta.getIsPossibleServerAction)(req);
-    const implicitTags = await (0, _implicittags.getImplicitTags)(workStore.page, url, fallbackRouteParams);
+    // For implicit tags, we use the resolved pathname which has dynamic params
+    // interpolated, is decoded, and has trailing slash removed.
+    const resolvedPathname = (0, _requestmeta.getRequestMeta)(req, 'resolvedPathname');
+    if (!resolvedPathname) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('resolvedPathname must be set in request metadata'), "__NEXT_ERROR_CODE", {
+            value: "E981",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const implicitTags = await (0, _implicittags.getImplicitTags)(workStore.page, resolvedPathname, fallbackRouteParams);
     const ctx = {
         componentMod: ComponentMod,
         url,
@@ -1185,6 +1356,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         workStore,
         parsedRequestHeaders,
         getDynamicParamFromSegment,
+        interpolatedParams,
         query,
         isPrefetch: isPrefetchRequest,
         isPossibleServerAction: isPossibleActionRequest,
@@ -1241,36 +1413,44 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
             contentType: _constants1.HTML_CONTENT_TYPE_HEADER
         };
         // If we have pending revalidates, wait until they are all resolved.
-        if (workStore.pendingRevalidates || workStore.pendingRevalidateWrites || workStore.pendingRevalidatedTags) {
-            const pendingPromise = (0, _revalidationutils.executeRevalidates)(workStore).finally(()=>{
+        const maybeRevalidatesPromise = (0, _revalidationutils.executeRevalidates)(workStore);
+        if (maybeRevalidatesPromise !== false) {
+            const revalidatesPromise = maybeRevalidatesPromise.finally(()=>{
                 if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
-                    console.log('pending revalidates promise finished for:', url);
+                    console.log('pending revalidates promise finished for:', url.href);
                 }
             });
             if (renderOpts.waitUntil) {
-                renderOpts.waitUntil(pendingPromise);
+                renderOpts.waitUntil(revalidatesPromise);
             } else {
-                options.waitUntil = pendingPromise;
+                options.waitUntil = revalidatesPromise;
             }
         }
         applyMetadataFromPrerenderResult(response, metadata, workStore);
         if (response.renderResumeDataCache) {
             metadata.renderResumeDataCache = response.renderResumeDataCache;
         }
-        return new _renderresult.default(await (0, _nodewebstreamshelper.streamToString)(response.stream), options);
+        const streamString = await (0, _streamops.streamToString)(response.stream);
+        const result = new _renderresult.default(streamString, options);
+        // Run build-time instant validation if the page has instant configs
+        // TODO(instant-validation-build): This is not a great place to wire this in.
+        if (workStore.cacheComponentsEnabled && workStore.isBuildTimePrerendering && renderOpts.runInstantValidation && await (0, _instantconfig.anySegmentNeedsInstantValidationInBuild)(loaderTree)) {
+            // Throws StaticGenBailoutError if validation failed.
+            await validateInstantConfigsInBuild(ctx, response.renderResumeDataCache ?? null);
+        }
+        return result;
     } else {
         // We're rendering dynamically
         const renderResumeDataCache = renderOpts.renderResumeDataCache ?? (postponedState == null ? void 0 : postponedState.renderResumeDataCache) ?? null;
         const rootParams = (0, _createcomponenttree.getRootParams)(loaderTree, ctx.getDynamicParamFromSegment);
-        const devFallbackParams = (0, _requestmeta.getRequestMeta)(req, 'devFallbackParams') || null;
-        const createRequestStore = _requeststore.createRequestStoreForRender.bind(null, req, res, url, rootParams, implicitTags, renderOpts.onUpdateCookies, renderOpts.previewProps, isHmrRefresh, serverComponentsHmrCache, renderResumeDataCache, devFallbackParams);
+        const fallbackParams = (0, _requestmeta.getRequestMeta)(req, 'fallbackParams') || null;
+        const createRequestStore = _requeststore.createRequestStoreForRender.bind(null, req, res, url, rootParams, implicitTags, renderOpts.onUpdateCookies, renderOpts.previewProps, isHmrRefresh, serverComponentsHmrCache, renderResumeDataCache, fallbackParams);
         const requestStore = createRequestStore();
-        if (process.env.NODE_ENV === 'development' && renderOpts.setIsrStatus && !cacheComponents && // Only pages using the Node runtime can use ISR, so we only need to
+        if (process.env.__NEXT_DEV_SERVER && setIsrStatus && !cacheComponents && // Only pages using the Node runtime can use ISR, so we only need to
         // update the status for those.
         // The type check here ensures that `req` is correctly typed, and the
         // environment variable check provides dead code elimination.
         process.env.NEXT_RUNTIME !== 'edge' && (0, _helpers.isNodeNextRequest)(req)) {
-            const setIsrStatus = renderOpts.setIsrStatus;
             req.originalRequest.on('end', ()=>{
                 const { pathname } = new URL(req.url || '/', 'http://n');
                 const isStatic = !requestStore.usedDynamic && !workStore.forceDynamic;
@@ -1281,8 +1461,10 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
             if (isRuntimePrefetchRequest) {
                 return generateRuntimePrefetchResult(req, ctx, requestStore);
             } else {
-                if (process.env.NODE_ENV === 'development' && process.env.NEXT_RUNTIME !== 'edge' && cacheComponents) {
-                    return generateDynamicFlightRenderResultWithStagesInDev(req, ctx, requestStore, createRequestStore, devFallbackParams);
+                if (process.env.__NEXT_DEV_SERVER && process.env.NEXT_RUNTIME !== 'edge' && cacheComponents) {
+                    return generateDynamicFlightRenderResultWithStagesInDev(req, ctx, requestStore, createRequestStore, fallbackParams);
+                } else if (cacheComponents && cachedNavigations) {
+                    return generateStagedDynamicFlightRenderResult(req, ctx, requestStore);
                 } else {
                     return generateDynamicFlightRenderResult(req, ctx, requestStore);
                 }
@@ -1291,8 +1473,6 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         let didExecuteServerAction = false;
         let formState = null;
         if (isPossibleActionRequest) {
-            // For action requests, we don't want to use the resume data cache.
-            requestStore.renderResumeDataCache = null;
             // For action requests, we handle them differently with a special render result.
             const actionRequestResult = await (0, _actionhandler.handleAction)({
                 req,
@@ -1310,7 +1490,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
                     const notFoundLoaderTree = createNotFoundLoaderTree(loaderTree);
                     res.statusCode = 404;
                     metadata.statusCode = 404;
-                    const stream = await renderToStream(requestStore, req, res, ctx, notFoundLoaderTree, formState, postponedState, metadata, undefined, devFallbackParams);
+                    const stream = await renderToStream(requestStore, req, res, ctx, notFoundLoaderTree, formState, postponedState, metadata, undefined, fallbackParams);
                     return new _renderresult.default(stream, {
                         metadata,
                         contentType: _constants1.HTML_CONTENT_TYPE_HEADER
@@ -1325,8 +1505,6 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
                 }
             }
             didExecuteServerAction = true;
-            // Restore the resume data cache
-            requestStore.renderResumeDataCache = renderResumeDataCache;
         }
         const options = {
             metadata,
@@ -1339,24 +1517,25 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         // Also, the request store might have been mutated by the action (e.g. enabling draftMode)
         // and we currently we don't copy changes over when creating a new store,
         // so the restarted render wouldn't be correct.
-        didExecuteServerAction ? undefined : createRequestStore, devFallbackParams);
+        didExecuteServerAction ? undefined : createRequestStore, fallbackParams);
         // Invalid dynamic usages should only error the request in development.
         // In production, it's better to produce a result.
         // (the dynamic error will still be thrown inside the component tree, but it's catchable by error boundaries)
-        if (workStore.invalidDynamicUsageError && workStore.dev) {
+        if (workStore.invalidDynamicUsageError && process.env.__NEXT_DEV_SERVER) {
             throw workStore.invalidDynamicUsageError;
         }
         // If we have pending revalidates, wait until they are all resolved.
-        if (workStore.pendingRevalidates || workStore.pendingRevalidateWrites || workStore.pendingRevalidatedTags) {
-            const pendingPromise = (0, _revalidationutils.executeRevalidates)(workStore).finally(()=>{
+        const maybeRevalidatesPromise = (0, _revalidationutils.executeRevalidates)(workStore);
+        if (maybeRevalidatesPromise !== false) {
+            const revalidatesPromise = maybeRevalidatesPromise.finally(()=>{
                 if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
-                    console.log('pending revalidates promise finished for:', url);
+                    console.log('pending revalidates promise finished for:', url.href);
                 }
             });
             if (renderOpts.waitUntil) {
-                renderOpts.waitUntil(pendingPromise);
+                renderOpts.waitUntil(revalidatesPromise);
             } else {
-                options.waitUntil = pendingPromise;
+                options.waitUntil = revalidatesPromise;
             }
         }
         // Create the new render result for the response.
@@ -1447,9 +1626,10 @@ function applyMetadataFromPrerenderResult(response, metadata, workStore) {
         };
     }
 }
-async function renderToStream(requestStore, req, res, ctx, tree, formState, postponedState, metadata, createRequestStore, devFallbackParams) {
+async function renderToStream(requestStore, req, res, ctx, tree, formState, postponedState, metadata, createRequestStore, fallbackParams) {
     /* eslint-disable @next/internal/no-ambiguous-jsx -- React Client */ const { assetPrefix, htmlRequestId, nonce, pagePath, renderOpts, requestId, workStore } = ctx;
-    const { basePath, buildManifest, ComponentMod: { createElement, renderToReadableStream: serverRenderToReadableStream }, crossOrigin, dev = false, experimental, nextExport = false, onInstrumentationRequestError, page, reactMaxHeadersLength, setReactDebugChannel, shouldWaitOnAllReady, subresourceIntegrityManifest, supportsDynamicResponse, cacheComponents } = renderOpts;
+    const { basePath, buildManifest, ComponentMod: { createElement }, crossOrigin, experimental, isBuildTimePrerendering = false, onInstrumentationRequestError, page, reactMaxHeadersLength, setReactDebugChannel, shouldWaitOnAllReady, subresourceIntegrityManifest, supportsDynamicResponse, cacheComponents } = renderOpts;
+    const { cachedNavigations } = renderOpts.experimental;
     const { ServerInsertedHTMLProvider, renderServerInsertedHTML } = (0, _serverinsertedhtml.createServerInsertedHTML)();
     const getServerInsertedMetadata = (0, _createserverinsertedmetadata.createServerInsertedMetadata)(nonce);
     const tracingMetadata = (0, _utils1.getTracedMetadata)((0, _tracer.getTracer)().getTracePropagationData(), experimental.clientTraceMetadata);
@@ -1465,7 +1645,9 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
     assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, true), nonce, page);
     // 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;
+    // For MPA navigations (page reload, direct URL entry), the request ID
+    // header is not present, so we generate a random one.
+    const bootstrapScriptContent = process.env.__NEXT_DEV_SERVER ? `self.__next_r=${JSON.stringify(requestId ?? crypto.randomUUID())}` : undefined;
     // 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.
@@ -1497,7 +1679,7 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
         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);
+        const serverComponentsErrorHandler = (0, _createerrorhandler.createReactServerErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, 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.
@@ -1505,23 +1687,23 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
             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);
+        const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, 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
+            if (process.env.__NEXT_DEV_SERVER && // 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)) {
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+                const getPayload = async (requestStore)=>{
+                    const payload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, {
+                        is404: res.statusCode === 404
+                    });
+                    if (isBypassingCachesInDev(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) {
@@ -1538,8 +1720,8 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                 // (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);
+                !isBypassingCachesInDev(requestStore)) {
+                    const { stream: serverStream, accumulatedChunksPromise, syncInterruptReason, startTime, 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();
@@ -1548,14 +1730,15 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     }
                     _consoleasyncstorageexternal.consoleAsyncStorage.run({
                         dim: true
-                    }, spawnStaticShellValidationInDev, accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, ctx, finalRequestStore, devFallbackParams, validationDebugChannelClient);
+                    }, spawnStaticShellValidationInDev, accumulatedChunksPromise, syncInterruptReason, startTime, staticStageEndTime, runtimeStageEndTime, ctx, finalRequestStore, fallbackParams, validationDebugChannelClient);
                     reactServerResult = new _apprenderprerenderutils.ReactServerResult(serverStream);
                     requestStore = finalRequestStore;
                     debugChannel = returnedDebugChannel;
                 } else {
+                    logValidationSkipped(ctx);
                     // We're either bypassing caches or we can't restart the render.
                     // Do a dynamic render, but with (basic) environment labels.
-                    debugChannel = setReactDebugChannel && createDebugChannel();
+                    debugChannel = setReactDebugChannel && (0, _debugchannelserver.createDebugChannel)();
                     const serverStream = await stagedRenderToReadableStreamWithoutCachesInDev(ctx, requestStore, getPayload, {
                         onError: serverComponentsErrorHandler,
                         filterStackFrame,
@@ -1570,10 +1753,72 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         readable: readableBrowser
                     }, htmlRequestId, requestId);
                 }
+            } else if (cacheComponents && cachedNavigations) {
+                // Production Cache Components + Cached Navigations: use staged
+                // rendering so the RSC payload includes the static stage byte length
+                // (`l` field), enabling the client to cache the static subset during
+                // hydration.
+                const { renderToReadableStream } = ctx.componentMod;
+                const selectStaleTime = (0, _staletime.createSelectStaleTime)(experimental);
+                const staleTimeIterable = new _staletime.StaleTimeIterable();
+                // TODO(cached-navs): this assumes that we checked during build that there's no sync IO.
+                // but it can happen e.g. after a revalidation or conditionally for a param that wasn't prerendered.
+                // we should change this to track sync IO, log an error and advance to dynamic.
+                const shouldTrackSyncIO = false;
+                const stageController = new _stagedrendering.StagedRenderingController(null, null, shouldTrackSyncIO);
+                requestStore.stale = _constants1.INFINITE_CACHE;
+                requestStore.stagedRendering = stageController;
+                (0, _staletime.trackStaleTime)(requestStore, staleTimeIterable, selectStaleTime);
+                let resolveStaticStageByteLength;
+                const staticStageByteLengthPromise = new Promise((resolve)=>{
+                    resolveStaticStageByteLength = resolve;
+                });
+                // If the route has runtime prefetching enabled, spawn a runtime
+                // prerender after the resume render fills caches. The result is
+                // embedded in the initial RSC payload so the client can cache
+                // runtime-prefetchable content during hydration.
+                const hasRuntimePrefetch = await (0, _instantconfig.anySegmentHasRuntimePrefetchEnabled)(tree);
+                let runtimePrefetchStream;
+                if (hasRuntimePrefetch) {
+                    const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+                    requestStore.prerenderResumeDataCache = prerenderResumeDataCache;
+                    const cacheSignal = new _cachesignal.CacheSignal();
+                    (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+                    requestStore.cacheSignal = cacheSignal;
+                    const runtimePrefetchTransform = new TransformStream();
+                    runtimePrefetchStream = runtimePrefetchTransform.readable;
+                    void cacheSignal.cacheReady().then(()=>spawnRuntimePrefetchWithFilledCaches(runtimePrefetchTransform.writable, ctx, prerenderResumeDataCache, requestStore, serverComponentsErrorHandler));
+                }
+                const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, {
+                    is404: res.statusCode === 404,
+                    staleTimeIterable,
+                    staticStageByteLengthPromise,
+                    runtimePrefetchStream
+                });
+                const flightStream = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+                    stageController.advanceStage(_stagedrendering.RenderStage.Static);
+                    const stream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, renderToReadableStream, RSCPayload, clientModules, {
+                        onError: serverComponentsErrorHandler,
+                        filterStackFrame
+                    });
+                    const [dynamicStream, staticStream] = stream.tee();
+                    countStaticStageBytes(staticStream, stageController).then(resolveStaticStageByteLength);
+                    return dynamicStream;
+                }, ()=>{
+                    // This is a separate task that doesn't advance a stage. It forces
+                    // draining the microtask queue so that the stale time iterable is
+                    // closed before we advance to the dynamic stage.
+                    void (0, _staletime.finishStaleTimeTracking)(staleTimeIterable);
+                }, ()=>{
+                    stageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
+                });
+                reactServerResult = new _apprenderprerenderutils.ReactServerResult(flightStream);
             } 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();
+                const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, {
+                    is404: res.statusCode === 404
+                });
+                const debugChannel = setReactDebugChannel && (0, _debugchannelserver.createDebugChannel)();
                 if (debugChannel) {
                     const [readableSsr, readableBrowser] = debugChannel.clientSide.readable.tee();
                     reactDebugStream = readableSsr;
@@ -1581,7 +1826,7 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         readable: readableBrowser
                     }, htmlRequestId, requestId);
                 }
-                reactServerResult = new _apprenderprerenderutils.ReactServerResult(_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, serverRenderToReadableStream, RSCPayload, clientModules, {
+                reactServerResult = new _apprenderprerenderutils.ReactServerResult(_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFlightStream, ctx.componentMod, RSCPayload, clientModules, {
                     filterStackFrame,
                     onError: serverComponentsErrorHandler,
                     debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
@@ -1598,15 +1843,14 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     // 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);
+                    const inlinedDataStream = (0, _streamops.createInlinedDataStream)(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)());
+                    return (0, _streamops.chainStreams)(inlinedDataStream, (0, _streamops.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, {
+                    const resumeAppElement = /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                         reactServerStream: reactServerResult.tee(),
                         reactDebugStream: reactDebugStream,
                         debugEndTime: undefined,
@@ -1614,13 +1858,6 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         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,
@@ -1629,21 +1866,33 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         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.
+                    const { stream: htmlStream, allReady } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.resumeToFizzStream, resumeAppElement, postponed, {
+                        onError: htmlRendererErrorHandler,
+                        nonce
+                    });
+                    // End the render span only after React completed rendering (including anything inside Suspense boundaries)
+                    allReady.finally(()=>{
+                        if (renderSpan.isRecording()) renderSpan.end();
+                    });
+                    return await (0, _streamops.continueDynamicHTMLResume)(htmlStream, {
                         delayDataUntilFirstHtmlChunk: preludeState === _postponedstate.DynamicHTMLPreludeState.Empty,
-                        inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consume(), nonce, formState),
+                        inlinedDataStream: (0, _streamops.createInlinedDataStream)(reactServerResult.consume(), nonce, formState),
                         getServerInsertedHTML,
-                        getServerInsertedMetadata
+                        getServerInsertedMetadata,
+                        deploymentId: ctx.sharedContext.deploymentId
                     });
                 }
             }
             // 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, {
+            const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                polyfills,
+                renderServerInsertedHTML,
+                serverCapturedErrors: allCapturedErrors,
+                basePath,
+                tracingMetadata: tracingMetadata
+            });
+            const generateStaticHTML = supportsDynamicResponse !== true || !!shouldWaitOnAllReady;
+            const appElement = /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                 reactServerStream: reactServerResult.tee(),
                 reactDebugStream: reactDebugStream,
                 debugEndTime: undefined,
@@ -1651,7 +1900,8 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                 ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                 nonce: nonce,
                 images: ctx.renderOpts.images
-            }), {
+            });
+            const fizzOptions = {
                 onError: htmlRendererErrorHandler,
                 nonce,
                 onHeaders: (headers)=>{
@@ -1665,43 +1915,20 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     bootstrapScript
                 ],
                 formState
-            });
+            };
+            const { stream: htmlStream, allReady } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFizzStream, appElement, fizzOptions);
             // End the render span only after React completed rendering (including anything inside Suspense boundaries)
-            htmlStream.allReady.finally(()=>{
+            allReady.finally(()=>{
                 if (renderSpan.isRecording()) renderSpan.end();
             });
-            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),
+            return await (0, _streamops.continueFizzStream)(htmlStream, {
+                inlinedDataStream: (0, _streamops.createInlinedDataStream)(reactServerResult.consume(), nonce, formState),
                 isStaticGeneration: generateStaticHTML,
-                isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
-                buildId: ctx.workStore.buildId,
+                allReady,
+                deploymentId: ctx.sharedContext.deploymentId,
                 getServerInsertedHTML,
                 getServerInsertedMetadata,
-                validateRootLayout: dev
+                validateRootLayout: !!process.env.__NEXT_DEV_SERVER
             });
         } 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')) {
@@ -1744,7 +1971,7 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
             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, {
+                errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFlightStream, ctx.componentMod, errorRSCPayload, clientModules, {
                     filterStackFrame,
                     onError: serverComponentsErrorHandler
                 });
@@ -1759,53 +1986,32 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                 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
-                    }
+                const generateStaticHTML = supportsDynamicResponse !== true || !!shouldWaitOnAllReady;
+                const { stream: errorHtmlStream, allReady: errorAllReady } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFizzStream, /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
+                    reactServerStream: errorServerStream,
+                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                    preinitScripts: errorPreinitScripts,
+                    nonce: nonce,
+                    images: ctx.renderOpts.images
+                }), {
+                    nonce,
+                    bootstrapScriptContent,
+                    bootstrapScripts: [
+                        errorBootstrapScript
+                    ],
+                    formState
                 });
                 // End the render span only after React completed rendering (including anything inside Suspense boundaries)
-                fizzStream.allReady.finally(()=>{
+                errorAllReady.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
+                return await (0, _streamops.continueFizzStream)(errorHtmlStream, {
+                    inlinedDataStream: (0, _streamops.createInlinedDataStream)(// 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,
+                    deploymentId: ctx.sharedContext.deploymentId,
                     getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
                         polyfills,
                         renderServerInsertedHTML,
@@ -1814,10 +2020,10 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         tracingMetadata: tracingMetadata
                     }),
                     getServerInsertedMetadata,
-                    validateRootLayout: dev
+                    validateRootLayout: !!process.env.__NEXT_DEV_SERVER
                 });
             } catch (finalErr) {
-                if (process.env.NODE_ENV === 'development' && (0, _httpaccessfallback.isHTTPAccessFallbackError)(finalErr)) {
+                if (process.env.__NEXT_DEV_SERVER && (0, _httpaccessfallback.isHTTPAccessFallbackError)(finalErr)) {
                     const { bailOnRootNotFound } = require('../../client/components/dev-root-http-access-fallback-boundary');
                     bailOnRootNotFound();
                 }
@@ -1828,19 +2034,22 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
     });
 /* eslint-enable @next/internal/no-ambiguous-jsx */ }
 async function renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, createRequestStore, getPayload, onError) {
-    const { htmlRequestId, renderOpts, componentMod: { routeModule: { userland: { loaderTree } } } } = ctx;
+    const { htmlRequestId, renderOpts } = ctx;
     const { ComponentMod, setCacheStatus, setReactDebugChannel } = renderOpts;
-    const hasRuntimePrefetch = await (0, _stagedvalidation.anySegmentHasRuntimePrefetchEnabled)(loaderTree);
+    let startTime = -Infinity;
     // 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.EarlyStatic:
             case _stagedrendering.RenderStage.Static:
                 return 'Prerender';
+            case _stagedrendering.RenderStage.EarlyRuntime:
+                return 'Prefetch';
             case _stagedrendering.RenderStage.Runtime:
-                return hasRuntimePrefetch ? 'Prefetch' : 'Prefetchable';
+                return 'Prefetchable';
             case _stagedrendering.RenderStage.Dynamic:
             case _stagedrendering.RenderStage.Abandoned:
                 return 'Server';
@@ -1869,97 +2078,101 @@ 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, hasRuntimePrefetch);
+    const initialAbandonController = new AbortController() // Controls whether this render is abandoned
+    ;
+    const initialStageController = new _stagedrendering.StagedRenderingController(initialDataController.signal, initialAbandonController, true // track sync IO
+    );
     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.
     requestStore.renderResumeDataCache = null;
     requestStore.stagedRendering = initialStageController;
-    requestStore.asyncApiPromises = createAsyncApiPromisesInDev(initialStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
+    requestStore.asyncApiPromises = createAsyncApiPromises(initialStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
     requestStore.cacheSignal = cacheSignal;
-    let debugChannel = setReactDebugChannel && createDebugChannel();
+    let debugChannel = setReactDebugChannel && (0, _debugchannelserver.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 maybeInitialStreamResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>(0, _apprenderrenderutils.pipelineInSequentialTasks)(()=>{
-            // Static stage
+    const initialStreamResult = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+        initialStageController.advanceStage(_stagedrendering.RenderStage.EarlyStatic);
+        startTime = performance.now() + performance.timeOrigin;
+        const streamPair = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFlightStream, ComponentMod, initialRscPayload, clientModules, {
+            onError,
+            environmentName,
+            startTime,
+            filterStackFrame,
+            debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide,
+            signal: initialReactController.signal
+        }).tee();
+        // If we abort the render, we want to reject the stage-dependent promises as well.
+        // Note that we want to install this listener after the render is started
+        // so that it runs after react is finished running its abort code.
+        initialReactController.signal.addEventListener('abort', ()=>{
+            const { reason } = initialReactController.signal;
+            initialDataController.abort(reason);
+        }, {
+            once: true
+        });
+        const stream = streamPair[0];
+        const accumulatedChunksPromise = accumulateStreamChunks(streamPair[1], initialStageController, initialDataController.signal);
+        initialDataController.signal.addEventListener('abort', ()=>{
+            accumulatedChunksPromise.catch(()=>{});
+            stream.cancel();
+        }, {
+            once: true
+        });
+        return {
+            stream,
+            accumulatedChunksPromise
+        };
+    }, ()=>{
+        if (initialAbandonController.signal.aborted === true) {
+            return;
+        } else if (cacheSignal.hasPendingReads()) {
+            initialAbandonController.abort();
+        } else {
             initialStageController.advanceStage(_stagedrendering.RenderStage.Static);
-            const stream = ComponentMod.renderToReadableStream(initialRscPayload, clientModules, {
-                onError,
-                environmentName,
-                filterStackFrame,
-                debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide,
-                signal: initialReactController.signal
-            });
-            // If we abort the render, we want to reject the stage-dependent promises as well.
-            // Note that we want to install this listener after the render is started
-            // so that it runs after react is finished running its abort code.
-            initialReactController.signal.addEventListener('abort', ()=>{
-                initialDataController.abort(initialReactController.signal.reason);
-            });
-            const [continuationStream, accumulatingStream] = stream.tee();
-            const accumulatedChunksPromise = accumulateStreamChunks(accumulatingStream, initialStageController, initialDataController.signal);
-            return {
-                stream: continuationStream,
-                accumulatedChunksPromise
-            };
-        }, ({ stream, accumulatedChunksPromise })=>{
-            // Runtime stage
-            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 (initialAbandonController.signal.aborted === true) {
+            return;
+        } else if (cacheSignal.hasPendingReads()) {
+            initialAbandonController.abort();
+        } else {
+            initialStageController.advanceStage(_stagedrendering.RenderStage.EarlyRuntime);
+        }
+    }, ()=>{
+        if (initialAbandonController.signal.aborted === true) {
+            return;
+        } else if (cacheSignal.hasPendingReads()) {
+            initialAbandonController.abort();
+        } else {
             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 (cacheSignal.hasPendingReads()) {
-                initialStageController.abandonRender();
-                return null;
-            }
-            // Regardless of whether we are going to abandon this
-            // render we need the unblock runtime b/c it's essential
-            // filling caches.
+        }
+    }, ()=>{
+        if (initialAbandonController.signal.aborted === true) {
+            return;
+        } else if (cacheSignal.hasPendingReads()) {
+            initialAbandonController.abort();
+        } else {
             initialStageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
-            return result;
-        }));
-    if (maybeInitialStreamResult !== null) {
+        }
+    });
+    if (initialStageController.currentStage !== _stagedrendering.RenderStage.Abandoned) {
         // No cache misses. We can use the result as-is.
         return {
-            stream: maybeInitialStreamResult.stream,
-            accumulatedChunksPromise: maybeInitialStreamResult.accumulatedChunksPromise,
-            staticInterruptReason: initialStageController.getStaticInterruptReason(),
-            runtimeInterruptReason: initialStageController.getRuntimeInterruptReason(),
+            stream: initialStreamResult.stream,
+            accumulatedChunksPromise: initialStreamResult.accumulatedChunksPromise,
+            syncInterruptReason: initialStageController.getSyncInterruptReason(),
+            startTime,
             staticStageEndTime: initialStageController.getStaticStageEndTime(),
             runtimeStageEndTime: initialStageController.getRuntimeStageEndTime(),
             debugChannel,
             requestStore
         };
     }
-    if (process.env.NODE_ENV === 'development' && setCacheStatus) {
+    if (process.env.__NEXT_DEV_SERVER && setCacheStatus) {
         setCacheStatus('filling', htmlRequestId);
     }
     // Cache miss. We will use the initial render to fill caches, and discard its result.
@@ -1979,52 +2192,56 @@ async function renderWithRestartOnCacheMissInDev(ctx, initialRequestStore, creat
     // 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);
+    const finalStageController = new _stagedrendering.StagedRenderingController(abortSignal, null, true // track sync IO
+    );
     // We've filled the caches, so now we can render as usual,
     // without any cache-filling mechanics.
     requestStore.prerenderResumeDataCache = null;
     requestStore.renderResumeDataCache = (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache);
     requestStore.stagedRendering = finalStageController;
     requestStore.cacheSignal = null;
-    requestStore.asyncApiPromises = createAsyncApiPromisesInDev(finalStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
+    requestStore.asyncApiPromises = createAsyncApiPromises(finalStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
     // 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();
+    debugChannel = setReactDebugChannel && (0, _debugchannelserver.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 finalStreamResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>(0, _apprenderrenderutils.pipelineInSequentialTasks)(()=>{
-            // Static stage
-            finalStageController.advanceStage(_stagedrendering.RenderStage.Static);
-            const stream = ComponentMod.renderToReadableStream(finalRscPayload, clientModules, {
-                onError,
-                environmentName,
-                filterStackFrame,
-                debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
-            });
-            const [continuationStream, accumulatingStream] = stream.tee();
-            const accumulatedChunksPromise = accumulateStreamChunks(accumulatingStream, finalStageController, null);
-            return {
-                stream: continuationStream,
-                accumulatedChunksPromise
-            };
-        }, (result)=>{
-            // Runtime stage
-            finalStageController.advanceStage(_stagedrendering.RenderStage.Runtime);
-            return result;
-        }, (result)=>{
-            // Dynamic stage
-            finalStageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
-            return result;
-        }));
-    if (process.env.NODE_ENV === 'development' && setCacheStatus) {
+    const finalStreamResult = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+        finalStageController.advanceStage(_stagedrendering.RenderStage.EarlyStatic);
+        startTime = performance.now() + performance.timeOrigin;
+        const streamPair = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFlightStream, ComponentMod, finalRscPayload, clientModules, {
+            onError,
+            environmentName,
+            startTime,
+            filterStackFrame,
+            debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
+        }).tee();
+        return {
+            stream: streamPair[0],
+            accumulatedChunksPromise: accumulateStreamChunks(streamPair[1], finalStageController, null)
+        };
+    }, ()=>{
+        // Static stage
+        finalStageController.advanceStage(_stagedrendering.RenderStage.Static);
+    }, ()=>{
+        // EarlyRuntime stage
+        finalStageController.advanceStage(_stagedrendering.RenderStage.EarlyRuntime);
+    }, ()=>{
+        // Runtime stage
+        finalStageController.advanceStage(_stagedrendering.RenderStage.Runtime);
+    }, ()=>{
+        // Dynamic stage
+        finalStageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
+    });
+    if (process.env.__NEXT_DEV_SERVER && setCacheStatus) {
         setCacheStatus('filled', htmlRequestId);
     }
     return {
         stream: finalStreamResult.stream,
         accumulatedChunksPromise: finalStreamResult.accumulatedChunksPromise,
-        staticInterruptReason: finalStageController.getStaticInterruptReason(),
-        runtimeInterruptReason: finalStageController.getRuntimeInterruptReason(),
+        syncInterruptReason: finalStageController.getSyncInterruptReason(),
+        startTime,
         staticStageEndTime: finalStageController.getStaticStageEndTime(),
         runtimeStageEndTime: finalStageController.getRuntimeStageEndTime(),
         debugChannel,
@@ -2062,9 +2279,11 @@ async function accumulateStreamChunks(stream, stageController, signal) {
                         enumerable: false,
                         configurable: true
                     });
+                case _stagedrendering.RenderStage.EarlyStatic:
                 case _stagedrendering.RenderStage.Static:
                     staticChunks.push(value);
                 // fall through
+                case _stagedrendering.RenderStage.EarlyRuntime:
                 case _stagedrendering.RenderStage.Runtime:
                     runtimeChunks.push(value);
                 // fall through
@@ -2078,8 +2297,13 @@ async function accumulateStreamChunks(stream, stageController, signal) {
                     break;
             }
         }
-    } catch  {
-    // When we release the lock we may reject the read
+    } catch (err) {
+        // When we cancel the reader we may reject the read.
+        // Only swallow errors caused by our intentional cancel();
+        // re-throw unexpected errors to avoid silently returning partial data.
+        if (!cancelled) {
+            throw err;
+        }
     }
     return {
         staticChunks,
@@ -2087,47 +2311,43 @@ async function accumulateStreamChunks(stream, stageController, signal) {
         dynamicChunks
     };
 }
-function createAsyncApiPromisesInDev(stagedRendering, cookies, mutableCookies, headers) {
+async function countStaticStageBytes(stream, stageController) {
+    let byteLength = 0;
+    const reader = stream.getReader();
+    stageController.onStage(_stagedrendering.RenderStage.EarlyRuntime, ()=>{
+        reader.cancel();
+    });
+    while(true){
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        if (stageController.currentStage <= _stagedrendering.RenderStage.Static) {
+            byteLength += value.byteLength;
+        } else {
+            reader.cancel();
+            break;
+        }
+    }
+    return byteLength;
+}
+function createAsyncApiPromises(stagedRendering, cookies, mutableCookies, headers) {
     return {
-        // Runtime APIs
+        // Runtime APIs (for prefetch segments)
         cookies: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.Runtime, 'cookies', cookies),
+        earlyCookies: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.EarlyRuntime, 'cookies', cookies),
         mutableCookies: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.Runtime, 'cookies', mutableCookies),
+        earlyMutableCookies: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.EarlyRuntime, 'cookies', mutableCookies),
         headers: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.Runtime, 'headers', headers),
+        earlyHeaders: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.EarlyRuntime, 'headers', headers),
         // These are not used directly, but we chain other `params`/`searchParams` promises off of them.
         sharedParamsParent: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.Runtime, undefined, '<internal params>'),
+        earlySharedParamsParent: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.EarlyRuntime, undefined, '<internal params>'),
         sharedSearchParamsParent: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.Runtime, undefined, '<internal searchParams>'),
+        earlySharedSearchParamsParent: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.EarlyRuntime, undefined, '<internal searchParams>'),
         connection: stagedRendering.delayUntilStage(_stagedrendering.RenderStage.Dynamic, 'connection', undefined)
     };
 }
-function createDebugChannel() {
-    if (process.env.NODE_ENV === 'production') {
-        return undefined;
-    }
-    let readableController;
-    let clientSideReadable = new ReadableStream({
-        start (controller) {
-            readableController = controller;
-        }
-    });
-    return {
-        serverSide: {
-            writable: new WritableStream({
-                write (chunk) {
-                    readableController == null ? void 0 : readableController.enqueue(chunk);
-                },
-                close () {
-                    readableController == null ? void 0 : readableController.close();
-                },
-                abort (err) {
-                    readableController == null ? void 0 : readableController.error(err);
-                }
-            })
-        },
-        clientSide: {
-            readable: clientSideReadable
-        }
-    };
-}
 /**
  * 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
@@ -2136,7 +2356,7 @@ function createDebugChannel() {
  * 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 { htmlRequestId, renderOpts } = ctx;
     const { sendErrorsToBrowser } = renderOpts;
     const errors = [];
     for (const message of messages){
@@ -2163,11 +2383,64 @@ function createDebugChannel() {
                 configurable: true
             });
         }
+        // Build a Map of error → error code for errors that have one.
+        // React doesn't revive __NEXT_ERROR_CODE during RSC deserialization, so we
+        // send it as a side-channel Map. RSC preserves object identity, so the
+        // deserialized Map keys will reference the same Error objects.
+        const errorCodes = new Map();
+        for (const err of errors){
+            const code = (0, _errortelemetryutils.extractNextErrorCode)(err);
+            if (code !== undefined) {
+                errorCodes.set(err, code);
+            }
+        }
         const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
-        const errorsRscStream = ComponentMod.renderToReadableStream(errors, clientModules, {
+        const errorsFlightStream = (0, _streamops.renderToFlightStream)(ctx.componentMod, {
+            errors,
+            errorCodes
+        }, clientModules, {
             filterStackFrame
         });
-        sendErrorsToBrowser(errorsRscStream, htmlRequestId);
+        sendErrorsToBrowser(errorsFlightStream, htmlRequestId);
+    }
+}
+function logValidationSkipped(ctx) {
+    if (process.env.__NEXT_TEST_MODE && process.env.NEXT_TEST_LOG_VALIDATION) {
+        const requestId = ctx.requestId;
+        const url = ctx.url.href;
+        console.log('<VALIDATION_MESSAGE>' + JSON.stringify({
+            type: 'validation_start',
+            requestId,
+            url
+        }) + '</VALIDATION_MESSAGE>');
+        console.log('<VALIDATION_MESSAGE>' + JSON.stringify({
+            type: 'validation_end',
+            requestId,
+            url
+        }) + '</VALIDATION_MESSAGE>');
+    }
+}
+async function spawnStaticShellValidationInDev(...args) {
+    if (process.env.__NEXT_TEST_MODE && process.env.NEXT_TEST_LOG_VALIDATION) {
+        const ctx = args[5];
+        const requestId = ctx.requestId;
+        const url = ctx.url.href;
+        console.log('<VALIDATION_MESSAGE>' + JSON.stringify({
+            type: 'validation_start',
+            requestId,
+            url
+        }) + '</VALIDATION_MESSAGE>');
+        try {
+            return await spawnStaticShellValidationInDevImpl(...args);
+        } finally{
+            console.log('<VALIDATION_MESSAGE>' + JSON.stringify({
+                type: 'validation_end',
+                requestId,
+                url
+            }) + '</VALIDATION_MESSAGE>');
+        }
+    } else {
+        return await spawnStaticShellValidationInDevImpl(...args);
     }
 }
 /**
@@ -2175,11 +2448,13 @@ function createDebugChannel() {
  * 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 spawnStaticShellValidationInDev(accumulatedChunksPromise, staticInterruptReason, runtimeInterruptReason, staticStageEndTime, runtimeStageEndTime, ctx, requestStore, fallbackRouteParams, debugChannelClient) {
+ */ async function spawnStaticShellValidationInDevImpl(accumulatedChunksPromise, syncInterruptReason, startTime, staticStageEndTime, runtimeStageEndTime, ctx, requestStore, fallbackRouteParams, debugChannelClient) {
+    const debug = process.env.NEXT_PRIVATE_DEBUG_VALIDATION === '1' ? console.log : undefined;
     const { componentMod: ComponentMod, getDynamicParamFromSegment, renderOpts, workStore } = ctx;
-    const { allowEmptyStaticShell = false } = renderOpts;
-    const rootParams = (0, _createcomponenttree.getRootParams)(ComponentMod.routeModule.userland.loaderTree, getDynamicParamFromSegment);
-    const hmrRefreshHash = (0, _workunitasyncstorageexternal.getHmrRefreshHash)(workStore, requestStore);
+    const loaderTree = ComponentMod.routeModule.userland.loaderTree;
+    const allowEmptyStaticShell = (renderOpts.allowEmptyStaticShell ?? false) || await (0, _instantconfig.isPageAllowedToBlock)(loaderTree);
+    const rootParams = (0, _createcomponenttree.getRootParams)(loaderTree, getDynamicParamFromSegment);
+    const hmrRefreshHash = (0, _workunitasyncstorageexternal.getHmrRefreshHash)(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;
@@ -2188,36 +2463,55 @@ function createDebugChannel() {
             invalidDynamicUsageError
         ], ctx);
     }
-    if (staticInterruptReason) {
-        return logMessagesAndSendErrorsToBrowser([
-            staticInterruptReason
-        ], ctx);
-    }
-    if (runtimeInterruptReason) {
+    if (syncInterruptReason) {
         return logMessagesAndSendErrorsToBrowser([
-            runtimeInterruptReason
+            syncInterruptReason
         ], 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));
+        debugChannelClient.on('data', (c)=>{
+            debugChunks.push(c);
+        });
     }
+    const accumulatedChunks = await accumulatedChunksPromise;
+    const { staticChunks, runtimeChunks, dynamicChunks } = accumulatedChunks;
+    const needsInstantValidation = await (0, _instantconfig.anySegmentNeedsInstantValidationInDev)(loaderTree);
+    // `samples` from instant config are only used during build
+    const validationSamples = null;
+    const validationSampleTracking = null;
+    // 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 warmupClientModulesForStagedValidation(// if we're going to be validating prefetches, we'll be rendering some segments in the dynamic stage.
+    // otherwise, for static shell validation, we only need to warm up to the runtime stage.
+    // we also need to use a different store type, because instant validation allows more APIs to resolve.
+    needsInstantValidation ? 'validation-client' : 'prerender-client', needsInstantValidation ? dynamicChunks : runtimeChunks, dynamicChunks, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, validationSamples, validationSampleTracking);
+    debug == null ? void 0 : debug(`Starting static shell validation...`);
     const runtimeResult = await validateStagedShell(runtimeChunks, dynamicChunks, debugChunks, runtimeStageEndTime, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, hmrRefreshHash, _dynamicrendering.trackDynamicHoleInRuntimeShell);
     if (runtimeResult.length > 0) {
+        debug == null ? void 0 : debug(`❌ Failed - ${runtimeResult.length} errors from runtime stage`);
         // We have something to report from the runtime validation
-        // We can skip the static validation
+        // We can skip the rest
         return logMessagesAndSendErrorsToBrowser(runtimeResult, ctx);
     }
     const staticResult = await validateStagedShell(staticChunks, dynamicChunks, debugChunks, staticStageEndTime, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, hmrRefreshHash, _dynamicrendering.trackDynamicHoleInStaticShell);
-    return logMessagesAndSendErrorsToBrowser(staticResult, ctx);
+    if (staticResult.length > 0) {
+        debug == null ? void 0 : debug(`❌ Failed - ${staticResult.length} errors from static stage`);
+        // We have something to report from the static validation
+        // We can skip the rest
+        return logMessagesAndSendErrorsToBrowser(staticResult, ctx);
+    }
+    debug == null ? void 0 : debug(`✅ Passed`);
+    if (needsInstantValidation) {
+        const instantConfigsResult = await validateInstantConfigs(accumulatedChunks, debugChunks, startTime, rootParams, fallbackRouteParams, ctx, hmrRefreshHash, validationSamples);
+        if (instantConfigsResult.length > 0) {
+            return logMessagesAndSendErrorsToBrowser(instantConfigsResult, ctx);
+        }
+    }
 }
-async function warmupModuleCacheForRuntimeValidationInDev(runtimeServerChunks, allServerChunks, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx) {
+async function warmupClientModulesForStagedValidation(storeType, partialServerChunks, allServerChunks, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, validationSamples, validationSampleTracking) {
     const { implicitTags, nonce, workStore } = ctx;
     // Warmup SSR
     const initialClientPrerenderController = new AbortController();
@@ -2225,35 +2519,73 @@ async function warmupModuleCacheForRuntimeValidationInDev(runtimeServerChunks, a
     const initialClientRenderController = new AbortController();
     const preinitScripts = ()=>{};
     const { ServerInsertedHTMLProvider } = (0, _serverinsertedhtml.createServerInsertedHTML)();
-    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
-        ],
-        // TODO should this be removed from client stores?
-        prerenderResumeDataCache: null,
-        renderResumeDataCache: null,
-        hmrRefreshHash: undefined
-    };
-    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
+    let initialClientPrerenderStore;
+    if (storeType === 'prerender-client') {
+        const store = {
+            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
+            ],
+            // TODO should this be removed from client stores?
+            prerenderResumeDataCache: null,
+            renderResumeDataCache: null,
+            hmrRefreshHash: undefined,
+            // Client prerenders don't track server param access
+            varyParamsAccumulator: null
+        };
+        initialClientPrerenderStore = store;
+    } else {
+        const store = {
+            type: 'validation-client',
+            phase: 'render',
+            rootParams,
+            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,
+            revalidate: _constants1.INFINITE_CACHE,
+            expire: _constants1.INFINITE_CACHE,
+            stale: _constants1.INFINITE_CACHE,
+            tags: [
+                ...implicitTags.tags
+            ],
+            // TODO should this be removed from client stores?
+            prerenderResumeDataCache: null,
+            renderResumeDataCache: null,
+            hmrRefreshHash: undefined,
+            // Client prerenders don't track server param access
+            varyParamsAccumulator: null,
+            // We're not rendering any validation boundaries yet.
+            boundaryState: null,
+            validationSamples,
+            validationSampleTracking,
+            fallbackRouteParams
+        };
+        initialClientPrerenderStore = store;
+    }
+    // TODO: maybe conditionally switch between runtime chunks and all chunks?
+    // but warming too much should always be fine, just not always necessary
+    const serverStream = (0, _streamutils.createNodeStreamWithLateRelease)(partialServerChunks, allServerChunks, initialClientReactController.signal);
+    const pendingInitialClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, _streamops.getClientPrerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- React Client
     /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
-        reactServerStream: runtimeServerStream,
+        reactServerStream: serverStream,
         reactDebugStream: undefined,
         debugEndTime: undefined,
         preinitScripts: preinitScripts,
@@ -2334,15 +2666,16 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
         // TODO should this be removed from client stores?
         prerenderResumeDataCache: null,
         renderResumeDataCache: null,
-        hmrRefreshHash
+        hmrRefreshHash,
+        // Client prerenders don't track server param access
+        varyParamsAccumulator: null
     };
-    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;
+    const dynamicValidation = (0, _dynamicrendering.createDynamicValidationState)();
+    const serverStream = (0, _streamutils.createNodeStreamWithLateRelease)(stageChunks, allServerChunks, clientReactController.signal);
+    const debugChannelClient = debugChunks ? (0, _streamutils.createNodeStreamWithLateRelease)(debugChunks, debugChunks, clientReactController.signal) : undefined;
     try {
-        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
+        let { prelude: unprocessedPrelude } = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+            const pendingFinalClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalClientPrerenderStore, _streamops.getClientPrerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- React Client
             /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                 reactServerStream: serverStream,
                 reactDebugStream: debugChannelClient,
@@ -2357,7 +2690,7 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
                     if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || clientReactController.signal.aborted) {
                         const componentStack = errorInfo.componentStack;
                         if (typeof componentStack === 'string') {
-                            trackDynamicHole(workStore, componentStack, runtimeDynamicValidation, clientDynamicTracking);
+                            trackDynamicHole(workStore, componentStack, dynamicValidation, clientDynamicTracking);
                         }
                         return;
                     }
@@ -2381,18 +2714,624 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
         }, ()=>{
             clientReactController.abort();
         });
-        const { preludeIsEmpty } = await (0, _apprenderprerenderutils.processPrelude)(unprocessedPrelude);
-        return (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, runtimeDynamicValidation);
+        const { preludeIsEmpty } = await (0, _streamops.processPrelude)(unprocessedPrelude);
+        return (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, dynamicValidation, // TODO(instant-validation): if allowEmptyStaticShell is true (likely due to blocking configs),
+        // we should probably just skip this altogether
+        allowEmptyStaticShell);
     } catch (thrownValue) {
         // Even if the root errors we still want to report any cache components errors
         // that were discovered before the root errored.
-        let errors = (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, _dynamicrendering.PreludeState.Errored, runtimeDynamicValidation);
+        let errors = (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, _dynamicrendering.PreludeState.Errored, dynamicValidation, // TODO(instant-validation): if allowEmptyStaticShell is true (likely due to blocking configs),
+        // we should probably just skip this altogether
+        allowEmptyStaticShell);
         if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
             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);
         }
         return errors;
     }
 }
+/**
+ * Validates instant configs by iterating URL depths from deepest to
+ * shallowest. At each depth, builds a combined payload where segments
+ * above the boundary use Dynamic stage (already mounted) and segments
+ * below use Static/Runtime stage (being prefetched). If the new subtree
+ * contains any `unstable_instant` configs, the payload is rendered to
+ * detect dynamic holes without Suspense.
+ */ async function validateInstantConfigs(accumulatedChunks, debugChunks, startTime, rootParams, fallbackRouteParams, ctx, hmrRefreshHash, validationSamples) {
+    const debug = process.env.NEXT_PRIVATE_DEBUG_VALIDATION === '1' ? console.log : undefined;
+    const { createCombinedPayloadAtDepth, createCombinedPayloadStream, collectStagedSegmentData, discoverValidationDepths } = ctx.componentMod.InstantValidation();
+    const { createValidationSampleTracking } = require('./instant-validation/instant-samples');
+    debug == null ? void 0 : debug('\nStarting depth-based instant validation...');
+    const loaderTree = ctx.componentMod.routeModule.userland.loaderTree;
+    // Only affects a debug environment name label, not functional behavior.
+    const hasRuntimePrefetch = true;
+    const clientReferenceManifest = (0, _manifestssingleton.getClientReferenceManifest)();
+    const { cache, payload: initialRscPayload, stageEndTimes } = await collectStagedSegmentData({
+        [_stagedrendering.RenderStage.Static]: accumulatedChunks.staticChunks,
+        [_stagedrendering.RenderStage.Runtime]: accumulatedChunks.runtimeChunks,
+        [_stagedrendering.RenderStage.Dynamic]: accumulatedChunks.dynamicChunks
+    }, debugChunks, startTime, hasRuntimePrefetch, clientReferenceManifest);
+    const { implicitTags, nonce, workStore } = ctx;
+    const isDebugChannelEnabled = !!ctx.renderOpts.setReactDebugChannel;
+    /**
+   * Build and validate a combined payload at the given URL depth.
+   *
+   * Returns null if no instant config exists at this depth.
+   * Returns an empty array if validation passed.
+   * Returns a non-empty array of errors if validation failed.
+   *
+   * When the initial validation uses static segments and finds errors,
+   * automatically retries with runtime stages to discriminate between
+   * runtime and dynamic errors, returning the more specific result.
+   */ async function validateAtDepth(depth, groupDepthForValidation) {
+        return validateAtDepthImpl(depth, groupDepthForValidation, null);
+    }
+    async function validateAtDepthImpl(depth, groupDepthForValidation, previousBoundaryState) {
+        const extraChunksController = new AbortController();
+        const boundaryState = (0, _boundarytracking.createValidationBoundaryTracking)();
+        let useRuntimeStageForPartialSegments = false;
+        if (previousBoundaryState) {
+            // We're doing a followup render to better discriminate error types
+            useRuntimeStageForPartialSegments = true;
+            for (const id of previousBoundaryState.expectedIds){
+                boundaryState.expectedIds.add(id);
+            }
+        }
+        const payloadResult = await createCombinedPayloadAtDepth(initialRscPayload, cache, loaderTree, ctx.getDynamicParamFromSegment, ctx.query, depth, groupDepthForValidation, extraChunksController.signal, boundaryState, clientReferenceManifest, stageEndTimes, useRuntimeStageForPartialSegments);
+        if (payloadResult === null) {
+            return null;
+        }
+        const reactController = new AbortController();
+        const renderController = new AbortController();
+        const preinitScripts = ()=>{};
+        const { ServerInsertedHTMLProvider } = (0, _serverinsertedhtml.createServerInsertedHTML)();
+        const { stream: serverStream, debugStream } = await createCombinedPayloadStream(payloadResult.payload, extraChunksController, reactController.signal, clientReferenceManifest, startTime, isDebugChannelEnabled);
+        const instantValidationState = (0, _dynamicrendering.createInstantValidationState)(payloadResult.createInstantStack);
+        const validationSampleTracking = validationSamples !== null ? createValidationSampleTracking() : null;
+        const clientDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(false);
+        const prerenderStore = {
+            type: 'validation-client',
+            phase: 'render',
+            rootParams,
+            implicitTags,
+            renderSignal: renderController.signal,
+            controller: reactController,
+            cacheSignal: null,
+            dynamicTracking: clientDynamicTracking,
+            revalidate: _constants1.INFINITE_CACHE,
+            expire: _constants1.INFINITE_CACHE,
+            stale: _constants1.INFINITE_CACHE,
+            tags: [
+                ...implicitTags.tags
+            ],
+            prerenderResumeDataCache: null,
+            renderResumeDataCache: null,
+            hmrRefreshHash,
+            varyParamsAccumulator: null,
+            boundaryState,
+            fallbackRouteParams,
+            validationSamples,
+            validationSampleTracking
+        };
+        let errors;
+        try {
+            const { prelude: unprocessedPrelude } = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+                const pendingResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderStore, _streamops.getClientPrerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx -- React Client
+                /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                    reactServerStream: serverStream,
+                    reactDebugStream: debugStream ?? undefined,
+                    debugEndTime: undefined,
+                    preinitScripts: preinitScripts,
+                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                    nonce: nonce,
+                    images: ctx.renderOpts.images
+                }), {
+                    signal: reactController.signal,
+                    onError: (err, errorInfo)=>{
+                        if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || reactController.signal.aborted) {
+                            const componentStack = errorInfo.componentStack;
+                            if (typeof componentStack === 'string') {
+                                (0, _dynamicrendering.trackDynamicHoleInNavigation)(workStore, componentStack, instantValidationState, clientDynamicTracking, payloadResult.hasAmbiguousErrors ? _dynamicrendering.DynamicHoleKind.Runtime : _dynamicrendering.DynamicHoleKind.Dynamic, boundaryState);
+                            }
+                            return;
+                        } else if (!reactController.signal.aborted) {
+                            const componentStack = errorInfo.componentStack;
+                            if (typeof componentStack === 'string') {
+                                let errorForDisplay = err;
+                                if (process.env.NODE_ENV === 'production') {
+                                    // In production (i.e. build validation), Flight omits everything except the digest
+                                    // when serializing errors, which makes them very unfriendly for debugging.
+                                    // Map the deserialized errors back to their original error object to make it more useful.
+                                    if (err && typeof err === 'object' && 'digest' in err && typeof err.digest === 'string') {
+                                        const serverError = workStore.reactServerErrorsByDigest.get(err.digest);
+                                        if (serverError !== undefined) {
+                                            errorForDisplay = serverError;
+                                        }
+                                    }
+                                }
+                                (0, _dynamicrendering.trackThrownErrorInNavigation)(workStore, instantValidationState, errorForDisplay, componentStack);
+                            }
+                        }
+                        if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
+                            console.error(err);
+                            return undefined;
+                        }
+                        return (0, _createerrorhandler.getDigestForWellKnownError)(err);
+                    }
+                });
+                reactController.signal.addEventListener('abort', ()=>{
+                    renderController.abort();
+                }, {
+                    once: true
+                });
+                return pendingResult;
+            }, ()=>{
+                reactController.abort();
+            });
+            const { preludeIsEmpty } = await (0, _streamops.processPrelude)(unprocessedPrelude);
+            errors = (0, _dynamicrendering.getNavigationDisallowedDynamicReasons)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, instantValidationState, validationSampleTracking, boundaryState);
+        } catch (thrownValue) {
+            errors = (0, _dynamicrendering.getNavigationDisallowedDynamicReasons)(workStore, _dynamicrendering.PreludeState.Errored, instantValidationState, validationSampleTracking, boundaryState);
+        }
+        // This prerender did not produce any errors
+        if (errors.length === 0) {
+            return [];
+        }
+        if (previousBoundaryState === null && payloadResult.hasAmbiguousErrors) {
+            // This is the first validation attempt. we prepared a payload where dynamic holes might be runtime data dependencies
+            // or dynamic data dependencies. We do a followup validation using a payload with only Runtime segments to discriminate
+            const dynamicOnlyErrors = await validateAtDepthImpl(depth, groupDepthForValidation, boundaryState);
+            if (dynamicOnlyErrors !== null && dynamicOnlyErrors.length > 0) {
+                // The dynamic errors only validation found errors to report so we favor those
+                return dynamicOnlyErrors;
+            }
+        }
+        // If we didn't return some other errors at this point the only thing to return is this validation's errors
+        return errors;
+    }
+    // Discover validation depth bounds from the LoaderTree. The array
+    // length is the max URL depth; each entry is the max group depth
+    // (route group segments) between that URL depth and the next.
+    const groupDepthsByUrlDepth = discoverValidationDepths(loaderTree);
+    const maxDepth = groupDepthsByUrlDepth.length;
+    for(let depth = maxDepth - 1; depth >= 0; depth--){
+        const maxGroupDepth = groupDepthsByUrlDepth[depth];
+        for(let currentGroupDepth = maxGroupDepth; currentGroupDepth >= 0; currentGroupDepth--){
+            debug == null ? void 0 : debug(`Trying depth ${depth}` + (currentGroupDepth > 0 ? ` + groupDepth ${currentGroupDepth}...` : '...'));
+            const errors = await validateAtDepth(depth, currentGroupDepth);
+            if (errors === null) {
+                debug == null ? void 0 : debug(`  No config at depth ${depth}+${currentGroupDepth}, skipping.`);
+                continue;
+            }
+            if (errors.length > 0) {
+                debug == null ? void 0 : debug(`  Depth ${depth}+${currentGroupDepth}: ❌ Failed (${errors.length} errors)`);
+                return errors;
+            }
+            debug == null ? void 0 : debug(`  Depth ${depth}+${currentGroupDepth}: ✅ Passed`);
+        }
+    }
+    debug == null ? void 0 : debug(`✅ All depths passed`);
+    return [];
+}
+/**
+ * Two-pass render for build-time instant validation.
+ * The flow is similar to `renderWithRestartOnCacheMissInDev`: pass 1 warms caches,
+ * pass 2 renders with warm caches. If pass 1 has no cache misses,
+ * its result is returned directly.
+ *
+ * Differences from `renderWithRestartOnCacheMissInDev`:
+ * - both renders are abortable: if we know that we can't use a stream, we can just
+ *   throw it away, we don't have to render a complete result.
+ * - We don't need to tee the stream, we only care about accumulating chunks.
+ */ async function renderWithRestartOnCacheMissInValidation(ctx, initialRequestStore, createRequestStore, getPayload, createOnError, prefilledDataCache) {
+    const { componentMod: ComponentMod } = ctx;
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
+    let startTime = -Infinity;
+    let requestStore = initialRequestStore;
+    //===============================================
+    // Initial render (prospective — may warm caches)
+    //===============================================
+    const cacheSignal = new _cachesignal.CacheSignal();
+    (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+    // The prerender we rean before the validation probably already filled some caches,
+    // so we want to save work and re-use them.
+    const prerenderResumeDataCache = prefilledDataCache ? (0, _resumedatacache.createPrerenderResumeDataCache)(prefilledDataCache) : (0, _resumedatacache.createPrerenderResumeDataCache)();
+    const initialReactController = new AbortController();
+    const initialDataController = new AbortController();
+    const initialAbandonController = new AbortController();
+    const initialStageController = new _stagedrendering.StagedRenderingController(initialDataController.signal, initialAbandonController, true // track sync IO
+    );
+    requestStore.prerenderResumeDataCache = prerenderResumeDataCache;
+    requestStore.renderResumeDataCache = null;
+    requestStore.stagedRendering = initialStageController;
+    requestStore.cacheSignal = cacheSignal;
+    requestStore.asyncApiPromises = createAsyncApiPromises(initialStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
+    // We don't set `requestStore.controller and requestStore.renderSignal here.
+    // Right now, we only abort for sync IO, and in the first render, that's just a restart
+    // (after waiting for caches)
+    requestStore.controller = undefined;
+    requestStore.renderSignal = undefined;
+    const initialRscPayload = await getPayload(requestStore);
+    const advanceStageIfNoCacheMiss = (stage)=>{
+        if (initialAbandonController.signal.aborted === true) {
+            return;
+        } else if (cacheSignal.hasPendingReads()) {
+            initialAbandonController.abort();
+        } else {
+            initialStageController.advanceStage(stage);
+        }
+    };
+    const initialResult = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+        initialStageController.advanceStage(_stagedrendering.RenderStage.EarlyStatic);
+        startTime = performance.now() + performance.timeOrigin;
+        const stream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFlightStream, ComponentMod, initialRscPayload, clientModules, {
+            onError: createOnError(initialReactController.signal, false),
+            startTime,
+            filterStackFrame,
+            signal: initialReactController.signal
+        });
+        initialReactController.signal.addEventListener('abort', ()=>{
+            const { reason } = initialReactController.signal;
+            initialDataController.abort(reason);
+        }, {
+            once: true
+        });
+        const accumulatedChunksPromise = accumulateStreamChunks(stream, initialStageController, initialDataController.signal);
+        accumulatedChunksPromise.catch(()=>{});
+        return {
+            accumulatedChunksPromise
+        };
+    }, ()=>{
+        advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.Static);
+    }, ()=>{
+        advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.EarlyRuntime);
+    }, ()=>{
+        advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.Runtime);
+    }, ()=>{
+        advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.Dynamic);
+    });
+    if (initialStageController.currentStage !== _stagedrendering.RenderStage.Abandoned) {
+        // No cache misses. Use the result as-is.
+        return {
+            accumulatedChunksPromise: initialResult.accumulatedChunksPromise,
+            startTime,
+            stageController: initialStageController,
+            requestStore
+        };
+    }
+    // Cache miss. Wait for caches to fill, then re-render with warm caches.
+    await cacheSignal.cacheReady();
+    initialReactController.abort();
+    //===============================================
+    // Final render (restarted, with warm caches)
+    //===============================================
+    requestStore = createRequestStore();
+    // Unlike dev, where we're re-using the render that'll be visible in the browser,
+    // we *can* abort the validation render.
+    const finalReactController = new AbortController();
+    const finalDataController = new AbortController();
+    const finalStageController = new _stagedrendering.StagedRenderingController(finalDataController.signal, null, true // track sync IO
+    );
+    requestStore.prerenderResumeDataCache = null;
+    requestStore.renderResumeDataCache = (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache);
+    requestStore.stagedRendering = finalStageController;
+    requestStore.cacheSignal = null;
+    requestStore.asyncApiPromises = createAsyncApiPromises(finalStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
+    // Right now, we only abort for sync IO.
+    // If sync IO occurs in a place where it's not allowed, then we have to fail validation,
+    // and we can abort the render immediately, without waiting for anything else..
+    requestStore.controller = finalReactController;
+    requestStore.renderSignal = finalDataController.signal;
+    const finalRscPayload = await getPayload(requestStore);
+    const finalResult = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+        finalStageController.advanceStage(_stagedrendering.RenderStage.EarlyStatic);
+        startTime = performance.now() + performance.timeOrigin;
+        const stream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToFlightStream, ComponentMod, finalRscPayload, clientModules, {
+            onError: createOnError(finalReactController.signal, true),
+            startTime,
+            filterStackFrame,
+            signal: finalReactController.signal
+        });
+        finalReactController.signal.addEventListener('abort', ()=>{
+            finalDataController.abort(finalReactController.signal.reason);
+        }, {
+            once: true
+        });
+        const accumulatedChunksPromise = accumulateStreamChunks(stream, finalStageController, null);
+        accumulatedChunksPromise.catch(()=>{});
+        return {
+            accumulatedChunksPromise
+        };
+    }, ()=>{
+        finalStageController.advanceStage(_stagedrendering.RenderStage.Static);
+    }, ()=>{
+        finalStageController.advanceStage(_stagedrendering.RenderStage.EarlyRuntime);
+    }, ()=>{
+        finalStageController.advanceStage(_stagedrendering.RenderStage.Runtime);
+    }, ()=>{
+        finalStageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
+    });
+    return {
+        accumulatedChunksPromise: finalResult.accumulatedChunksPromise,
+        startTime,
+        stageController: finalStageController,
+        requestStore
+    };
+}
+async function validateInstantConfigsInBuild(ctx, prefilledDataCache) {
+    const run = async ()=>{
+        let success;
+        try {
+            // The validation renders are separate renders, and use a separate WorkStore.
+            // However, we defensively exit the existing workStore to avoid relying on something from there
+            // before we shadow it.
+            success = await _workasyncstorageexternal.workAsyncStorage.exit(async ()=>validateInstantConfigsInBuildImpl(ctx, prefilledDataCache));
+        } catch (err) {
+            console.error(Object.defineProperty(new _invarianterror.InvariantError('An unexpected error occcured during instant validation', {
+                cause: err
+            }), "__NEXT_ERROR_CODE", {
+                value: "E1097",
+                enumerable: false,
+                configurable: true
+            }));
+            success = false;
+        }
+        if (!success) {
+            console.error('Stopping prerender due to instant validation errors.');
+            throw new _staticgenerationbailout.StaticGenBailoutError();
+        }
+    };
+    if (process.env.__NEXT_TEST_MODE && process.env.NEXT_TEST_LOG_VALIDATION) {
+        // In tests, we use these markers to extract the relevant portion of the CLI logs.
+        // We want consistent ordering of these messages and other console.error calls,
+        // so we use console.error here as well. Using console.log leads to non-deterministic
+        // log order, likely stdout/stderr can interleave in non-deterministic ways.
+        const requestId = Date.now();
+        const route = ctx.workStore.route;
+        console.error('<VALIDATION_MESSAGE>' + JSON.stringify({
+            type: 'validation_start',
+            requestId,
+            url: route
+        }) + '</VALIDATION_MESSAGE>');
+        try {
+            return await run();
+        } finally{
+            console.error('<VALIDATION_MESSAGE>' + JSON.stringify({
+                type: 'validation_end',
+                requestId,
+                url: route
+            }) + '</VALIDATION_MESSAGE>');
+        }
+    } else {
+        return await run();
+    }
+}
+/**
+ * Runs instant validation at build time using the `samples` from `unstable_instant`.
+ *
+ * For each sample, this creates a staged RSC render with a synthetic `RequestStore`
+ * populated from sample data, then feeds the accumulated chunks to
+ * `validateInstantConfigs` which handles the actual validation.
+ */ async function validateInstantConfigsInBuildImpl(ctx, prefilledDataCache) {
+    const debug = process.env.NEXT_PRIVATE_DEBUG_VALIDATION === '1' ? console.log : undefined;
+    const { workStore: outerWorkStore } = ctx;
+    const route = outerWorkStore.route;
+    const loaderTree = ctx.componentMod.routeModule.userland.loaderTree;
+    let samples = await (0, _instantconfig.resolveInstantConfigSamplesForPage)(loaderTree);
+    if (!samples || samples.length === 0) {
+        // No samples defined; use a single empty sample to still run validation
+        samples = [
+            {}
+        ];
+    }
+    debug == null ? void 0 : debug('Resolved samples:', samples);
+    const allPossibleFallbackRouteParams = (0, _fallbackparams.getFallbackRouteParams)(route, ctx.componentMod.routeModule);
+    for(let sampleIndex = 0; sampleIndex < samples.length; sampleIndex++){
+        const sample = samples[sampleIndex];
+        debug == null ? void 0 : debug(`Validating sample (${sampleIndex + 1}/${samples.length}):`, sample);
+        let errors;
+        try {
+            errors = await _consoleasyncstorageexternal.consoleAsyncStorage.run({
+                dim: true
+            }, ()=>validateInstantConfigInBuildWithSample(ctx, sample, allPossibleFallbackRouteParams, prefilledDataCache));
+        } catch (err) {
+            if ((0, _instantvalidationerror.isInstantValidationError)(err)) {
+                errors = [
+                    err
+                ];
+            } else {
+                throw err;
+            }
+        }
+        if (errors.length > 0) {
+            debug == null ? void 0 : debug(`❌ Sample failed validation (${errors.length} errors)`);
+            const sampleDesc = samples.length > 1 ? ` (sample ${sampleIndex + 1} of ${samples.length})` : '';
+            for (const err of errors){
+                console.error(err);
+            }
+            console.error(`Build-time instant validation failed for route "${route}"${sampleDesc}.`);
+            return false;
+        } else {
+            debug == null ? void 0 : debug('✅ Sample validated successfully');
+        }
+    }
+    return true;
+}
+async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossibleFallbackRouteParams, prefilledDataCache) {
+    // The flow for build mirrors what we do when validating in dev.
+    // We have to perform a full dynamic render to get the RSC chunks for each stage.
+    // In order to do that, we have to set up a mock AppRenderContext, workStore, and requestStore
+    // based on the `sample` we're using.
+    const { workStore: outerWorkStore } = outerCtx;
+    const loaderTree = outerCtx.componentMod.routeModule.userland.loaderTree;
+    const route = outerWorkStore.route;
+    const { createCookiesFromSample, createHeadersFromSample, createDraftModeForValidation, createRelativeURLFromSamples, createValidationSampleTracking } = require('./instant-validation/instant-samples');
+    // TODO(instant-validation-build): it feels like this should happen higher up
+    // and go through existing URL parsing/generation logic?
+    const sampleUrl = createRelativeURLFromSamples(route, sample.params, sample.searchParams);
+    const sampleParams = sample.params ?? {};
+    let fallbackRouteParams = null;
+    if (allPossibleFallbackRouteParams) {
+        const fallbackRouteParamsMut = new Map();
+        for (const [paramKey, value] of allPossibleFallbackRouteParams){
+            if (!(paramKey in sampleParams)) {
+                fallbackRouteParamsMut.set(paramKey, value);
+            }
+        }
+        fallbackRouteParams = fallbackRouteParamsMut;
+    }
+    const getDynamicParamFromSegment = makeGetDynamicParamFromSegment(sampleParams, fallbackRouteParams, false);
+    const sampleRootParams = (0, _createcomponenttree.getRootParams)(loaderTree, getDynamicParamFromSegment);
+    let sampleUrlWithoutQuery;
+    let sampleQuery;
+    ({ query: sampleQuery, ...sampleUrlWithoutQuery } = sampleUrl);
+    const { AfterContext } = require('../after/after-context');
+    // NOTE: Matching the field order in `createWorkStore` to avoid deopting.
+    const workStore = {
+        isStaticGeneration: false,
+        page: outerWorkStore.page,
+        route: outerWorkStore.route,
+        incrementalCache: outerWorkStore.incrementalCache,
+        cacheLifeProfiles: outerWorkStore.cacheLifeProfiles,
+        isBuildTimePrerendering: false,
+        fetchCache: outerWorkStore.fetchCache,
+        isOnDemandRevalidate: false,
+        isDraftMode: false,
+        isPrefetchRequest: false,
+        buildId: outerWorkStore.buildId,
+        reactLoadableManifest: outerWorkStore.reactLoadableManifest,
+        assetPrefix: outerWorkStore.assetPrefix,
+        nonce: outerWorkStore.nonce,
+        // Never run `after()` for this validation render. by definition, `after` can't affect the rendered output.
+        afterContext: new AfterContext({
+            waitUntil (promise) {
+                promise.catch(()=>{});
+            },
+            onClose () {},
+            onTaskError () {}
+        }),
+        cacheComponentsEnabled: outerWorkStore.cacheComponentsEnabled,
+        previouslyRevalidatedTags: [],
+        refreshTagsByCacheKind: new Map(),
+        runInCleanSnapshot: outerWorkStore.runInCleanSnapshot,
+        shouldTrackFetchMetrics: false,
+        reactServerErrorsByDigest: new Map()
+    };
+    return _workasyncstorageexternal.workAsyncStorage.run(workStore, async ()=>{
+        // NOTE: match field order in renderToHTMLOrFlightImpl to avoid deopts
+        const validationCtx = {
+            componentMod: outerCtx.componentMod,
+            url: sampleUrlWithoutQuery,
+            renderOpts: outerCtx.renderOpts,
+            workStore,
+            parsedRequestHeaders: outerCtx.parsedRequestHeaders,
+            getDynamicParamFromSegment,
+            interpolatedParams: sampleParams,
+            query: sampleQuery,
+            isPrefetch: false,
+            isPossibleServerAction: false,
+            requestTimestamp: outerCtx.requestTimestamp,
+            appUsingSizeAdjustment: outerCtx.appUsingSizeAdjustment,
+            flightRouterState: undefined,
+            requestId: outerCtx.requestId,
+            htmlRequestId: outerCtx.htmlRequestId,
+            pagePath: outerCtx.pagePath,
+            assetPrefix: outerCtx.assetPrefix,
+            isNotFoundPath: outerCtx.isNotFoundPath,
+            nonce: outerCtx.nonce,
+            res: outerCtx.res,
+            sharedContext: outerCtx.sharedContext,
+            implicitTags: outerCtx.implicitTags
+        };
+        const validationSamples = {
+            params: sample.params,
+            searchParams: sample.searchParams
+        };
+        const createRequestStore = ()=>{
+            // Create exhaustive request data from sample
+            const sampleCookies = createCookiesFromSample(sample.cookies, route);
+            // We don't have to bother initializing these, pages can't access them anyway,
+            // we just need them because RequestStore requires them.
+            const unusedMutableCookies = new _cookies.ResponseCookies(new Headers());
+            // Create headers.
+            const sampleHeaders = createHeadersFromSample(sample.headers, sample.cookies, route);
+            const draftMode = createDraftModeForValidation();
+            return {
+                type: 'request',
+                phase: 'render',
+                implicitTags: outerCtx.implicitTags,
+                url: {
+                    pathname: sampleUrl.pathname,
+                    search: sampleUrl.search
+                },
+                headers: sampleHeaders,
+                cookies: sampleCookies,
+                mutableCookies: unusedMutableCookies,
+                userspaceMutableCookies: unusedMutableCookies,
+                draftMode,
+                rootParams: sampleRootParams,
+                validationSamples,
+                validationSampleTracking: createValidationSampleTracking(),
+                // These will be set when rendering
+                renderResumeDataCache: null,
+                prerenderResumeDataCache: null,
+                stagedRendering: null,
+                asyncApiPromises: undefined
+            };
+        };
+        // Track server errors. If one of them surfaces during the client render
+        // in the deserialized form (with no message/stack) we'll use this to map it
+        // back to the original.
+        const onServerError = (0, _createerrorhandler.createReactServerErrorHandler)(true, true, workStore.reactServerErrorsByDigest, ()=>{} // Don't report anything here. If needed, it will be reported in the client render.
+        );
+        const { accumulatedChunksPromise, startTime, stageController, requestStore: finalServerStore } = await renderWithRestartOnCacheMissInValidation(validationCtx, createRequestStore(), createRequestStore, (requestStore)=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, loaderTree, validationCtx, {
+                is404: false
+            }), (signal)=>function onError(err) {
+                const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
+                if (digest) {
+                    return digest;
+                }
+                if (signal.aborted) {
+                    return;
+                }
+                return onServerError(err);
+            }, prefilledDataCache);
+        const accumulatedChunks = await accumulatedChunksPromise;
+        const debugChunks = null // TODO(instant-validation-build): support debugChannel
+        ;
+        // Missing sample errors take priority over everything else,
+        // because they prevent us from rendering everything we need to validate.
+        const serverValidationSampleTracking = finalServerStore.validationSampleTracking;
+        if (serverValidationSampleTracking.missingSampleErrors.length > 0) {
+            return serverValidationSampleTracking.missingSampleErrors;
+        }
+        // We also error for sync IO. This runs after the prerender,
+        // so if we get sync IO errors here, they're likely from the runtime stage --
+        // the prerender probably discovered sync IO in the static stage
+        if (stageController.currentStage === _stagedrendering.RenderStage.Abandoned && stageController.syncInterruptReason) {
+            return [
+                stageController.syncInterruptReason
+            ];
+        }
+        const allowEmptyStaticShell = (validationCtx.renderOpts.allowEmptyStaticShell ?? false) || await (0, _instantconfig.isPageAllowedToBlock)(loaderTree);
+        // Now we the chunks of a fully rendered page, just like in dev.
+        // We can use them to validate all the navigations required by `instant` configs.
+        // Note that we're not performing static shell validation here -- that happens
+        // implicitly as part of the static prerender.
+        // The static prerender has warmed some client modules already,
+        // but we'll be reaching Runtime/Dynamic stages and thus rendering more content,
+        // so we need to warm again.
+        // TODO(instant-validation-build): This might warm too much, possibly hitting errors on code that didn't expect
+        // to run at build time. For example, we generally don't need to render leaf segments (e.g. __PAGE__) in
+        // the Dynamic stage, they're Runtime at best.
+        const warmupValidationSamplesTracking = createValidationSampleTracking();
+        await warmupClientModulesForStagedValidation('validation-client', accumulatedChunks.dynamicChunks, accumulatedChunks.dynamicChunks, sampleRootParams, fallbackRouteParams, allowEmptyStaticShell, validationCtx, validationSamples, warmupValidationSamplesTracking);
+        if (warmupValidationSamplesTracking.missingSampleErrors.length > 0) {
+            return warmupValidationSamplesTracking.missingSampleErrors;
+        }
+        return await validateInstantConfigs(accumulatedChunks, debugChunks, startTime, sampleRootParams, fallbackRouteParams, validationCtx, undefined, validationSamples);
+    });
+}
 /**
  * Determines whether we should generate static flight data.
  */ function shouldGenerateStaticFlightData(workStore) {
@@ -2406,7 +3345,9 @@ 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, ComponentMod, crossOrigin, dev = false, experimental, isDebugDynamicAccesses, nextExport = false, onInstrumentationRequestError, page, reactMaxHeadersLength, subresourceIntegrityManifest, cacheComponents } = renderOpts;
+    const { basePath, buildManifest, ComponentMod, crossOrigin, experimental, isDebugDynamicAccesses, isBuildTimePrerendering = false, onInstrumentationRequestError, page, reactMaxHeadersLength, subresourceIntegrityManifest, cacheComponents } = renderOpts;
+    const { cachedNavigations } = renderOpts.experimental;
+    const allowEmptyStaticShell = (renderOpts.allowEmptyStaticShell ?? false) || await (0, _instantconfig.isPageAllowedToBlock)(tree);
     const rootParams = (0, _createcomponenttree.getRootParams)(tree, getDynamicParamFromSegment);
     const { ServerInsertedHTMLProvider, renderServerInsertedHTML } = (0, _serverinsertedhtml.createServerInsertedHTML)();
     const getServerInsertedMetadata = (0, _createserverinsertedmetadata.createServerInsertedMetadata)(nonce);
@@ -2429,7 +3370,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'), silenceLog);
         }
     }
-    const serverComponentsErrorHandler = (0, _createerrorhandler.createReactServerErrorHandler)(dev, nextExport, reactServerErrorsByDigest, onHTMLRenderRSCError);
+    const serverComponentsErrorHandler = (0, _createerrorhandler.createReactServerErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, reactServerErrorsByDigest, onHTMLRenderRSCError);
     function onHTMLRenderSSRError(err) {
         if (reportErrors) {
             // We don't need to silence logs here. onHTMLRenderSSRError won't be
@@ -2439,7 +3380,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
         }
     }
     const allCapturedErrors = [];
-    const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(dev, nextExport, reactServerErrorsByDigest, allCapturedErrors, onHTMLRenderSSRError);
+    const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, reactServerErrorsByDigest, allCapturedErrors, onHTMLRenderSSRError);
     let reactServerPrerenderResult = null;
     const setMetadataHeader = (name)=>{
         metadata.headers ??= {};
@@ -2460,7 +3401,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
         }
         setMetadataHeader(name);
     };
-    const selectStaleTime = createSelectStaleTime(experimental);
+    const selectStaleTime = (0, _staletime.createSelectStaleTime)(experimental);
     const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     let prerenderStore = null;
     try {
@@ -2500,19 +3441,10 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             // The cacheSignal helps us track whether caches are still filling or we are ready
             // to cut the render off.
             const cacheSignal = new _cachesignal.CacheSignal();
-            let resumeDataCache;
-            let renderResumeDataCache = null;
-            let prerenderResumeDataCache = null;
-            if (renderOpts.renderResumeDataCache) {
-                // If a prefilled immutable render resume data cache is provided, e.g.
-                // when prerendering an optional fallback shell after having prerendered
-                // pages with defined params, we use this instead of a prerender resume
-                // data cache.
-                resumeDataCache = renderResumeDataCache = renderOpts.renderResumeDataCache;
-            } else {
-                // Otherwise we create a new mutable prerender resume data cache.
-                resumeDataCache = prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
-            }
+            // Always start with a fresh prerender RDC so warmup can fill misses,
+            // even when we have a prefilled render RDC to seed from.
+            const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+            let renderResumeDataCache = renderOpts.renderResumeDataCache ?? null;
             const initialServerPayloadPrerenderStore = {
                 type: 'prerender',
                 phase: 'render',
@@ -2540,11 +3472,15 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ],
                 prerenderResumeDataCache,
                 renderResumeDataCache,
-                hmrRefreshHash: undefined
+                hmrRefreshHash: undefined,
+                // We don't track vary params during initial prerender, only the final one
+                varyParamsAccumulator: null
             };
             // 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, res.statusCode === 404);
+            const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPayloadPrerenderStore, getRSCPayload, tree, ctx, {
+                is404: res.statusCode === 404
+            });
             const initialServerPrerenderStore = prerenderStore = {
                 type: 'prerender',
                 phase: 'render',
@@ -2567,9 +3503,11 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ],
                 prerenderResumeDataCache,
                 renderResumeDataCache,
-                hmrRefreshHash: undefined
+                hmrRefreshHash: undefined,
+                // We don't track vary params during initial prerender, only the final one
+                varyParamsAccumulator: null
             };
-            const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientModules, {
+            const initialPrerenderOptions = {
                 filterStackFrame,
                 onError: (err)=>{
                     const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
@@ -2593,7 +3531,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // a different signal to this render call than is used by dynamic APIs to signify
                 // transitioning out of the prerender environment
                 signal: initialServerReactController.signal
-            });
+            };
+            const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, (0, _streamops.getServerPrerender)(ComponentMod), initialServerPayload, clientModules, initialPrerenderOptions);
             // 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.
@@ -2650,10 +3589,11 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     ],
                     prerenderResumeDataCache,
                     renderResumeDataCache,
-                    hmrRefreshHash: undefined
+                    hmrRefreshHash: undefined,
+                    // Client prerenders don't track server param access
+                    varyParamsAccumulator: null
                 };
-                const prerender = require('react-dom/static').prerender;
-                const pendingInitialClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, prerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
+                const pendingInitialClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, _streamops.getClientPrerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
                 /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                     reactServerStream: initialServerResult.asUnclosingStream(),
                     reactDebugStream: undefined,
@@ -2709,8 +3649,13 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 await cacheSignal.cacheReady();
                 initialClientReactController.abort();
             }
+            if (renderOpts.renderResumeDataCache) {
+                // Swap to the warmed cache so the final render uses entries produced during warmup.
+                renderResumeDataCache = (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache);
+            }
             const finalServerReactController = new AbortController();
             const finalServerRenderController = new AbortController();
+            const varyParamsAccumulator = (0, _varyparams.createResponseVaryParamsAccumulator)();
             const finalServerPayloadPrerenderStore = {
                 type: 'prerender',
                 phase: 'render',
@@ -2736,9 +3681,17 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ],
                 prerenderResumeDataCache,
                 renderResumeDataCache,
-                hmrRefreshHash: undefined
+                hmrRefreshHash: undefined,
+                varyParamsAccumulator
             };
-            const finalAttemptRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPayloadPrerenderStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+            const finalAttemptRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPayloadPrerenderStore, getRSCPayload, tree, ctx, {
+                is404: res.statusCode === 404
+            });
+            let staleTimeIterable;
+            if (cachedNavigations) {
+                staleTimeIterable = new _staletime.StaleTimeIterable();
+                finalAttemptRSCPayload.s = staleTimeIterable;
+            }
             const serverDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
             let serverIsDynamic = false;
             const finalServerPrerenderStore = prerenderStore = {
@@ -2761,20 +3714,56 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ],
                 prerenderResumeDataCache,
                 renderResumeDataCache,
-                hmrRefreshHash: undefined
+                hmrRefreshHash: undefined,
+                varyParamsAccumulator
             };
+            if (staleTimeIterable !== undefined) {
+                (0, _staletime.trackStaleTime)(finalServerPrerenderStore, staleTimeIterable, selectStaleTime);
+            }
             let prerenderIsPending = true;
-            const reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)((0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasks)(async ()=>{
+            const finalRSCPrerenderOptions = {
+                filterStackFrame,
+                onError: (err)=>{
+                    return serverComponentsErrorHandler(err);
+                },
+                signal: finalServerReactController.signal
+            };
+            const finalRSCAbortCallback = async ()=>{
+                // Now that the prerendering is complete, we know the final stale
+                // time and vary params. Close the stale time iterable and resolve
+                // the vary params thenable so Flight can serialize their values
+                // into the stream. The timing here is important: both were
+                // included in the Flight payload, but they can only be serialized
+                // at the very end, after all the components have finished.
+                //
+                // We resolve these directly here instead of reading from the work
+                // unit store because this callback runs in a separate task (via
+                // setTimeout) and may not have access to the async storage context.
+                const pendingFinishes = [
+                    (0, _varyparams.finishAccumulatingVaryParams)(varyParamsAccumulator)
+                ];
+                if (staleTimeIterable !== undefined) {
+                    pendingFinishes.push((0, _staletime.finishStaleTimeTracking)(staleTimeIterable));
+                }
+                await Promise.all(pendingFinishes);
+                if (finalServerReactController.signal.aborted) {
+                    // If the server controller is already aborted we must have called something
+                    // that required aborting the prerender synchronously such as with new Date()
+                    serverIsDynamic = true;
+                    return;
+                }
+                if (prerenderIsPending) {
+                    // If prerenderIsPending then we have blocked for longer than a Task and we assume
+                    // there is something unfinished.
+                    serverIsDynamic = true;
+                }
+                finalServerReactController.abort();
+            };
+            const finalRSCPrerenderFn = 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, clientModules, {
-                    filterStackFrame,
-                    onError: (err)=>{
-                        return serverComponentsErrorHandler(err);
-                    },
-                    signal: finalServerReactController.signal
-                });
+                (0, _streamops.getServerPrerender)(ComponentMod), // ... the arguments for the function to run
+                finalAttemptRSCPayload, clientModules, finalRSCPrerenderOptions);
                 // 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.
@@ -2786,20 +3775,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 const prerenderResult = await pendingPrerenderResult;
                 prerenderIsPending = false;
                 return prerenderResult;
-            }, ()=>{
-                if (finalServerReactController.signal.aborted) {
-                    // If the server controller is already aborted we must have called something
-                    // that required aborting the prerender synchronously such as with new Date()
-                    serverIsDynamic = true;
-                    return;
-                }
-                if (prerenderIsPending) {
-                    // If prerenderIsPending then we have blocked for longer than a Task and we assume
-                    // there is something unfinished.
-                    serverIsDynamic = true;
-                }
-                finalServerReactController.abort();
-            }));
+            };
+            const reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)((0, _apprenderrenderutils.runInSequentialTasks)(finalRSCPrerenderFn, finalRSCAbortCallback));
             const clientDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
             const finalClientReactController = new AbortController();
             const finalClientRenderController = new AbortController();
@@ -2823,12 +3800,14 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ],
                 prerenderResumeDataCache,
                 renderResumeDataCache,
-                hmrRefreshHash: undefined
+                hmrRefreshHash: undefined,
+                // Client prerenders don't track server param access
+                varyParamsAccumulator: null
             };
             let dynamicValidation = (0, _dynamicrendering.createDynamicValidationState)();
-            const prerender = require('react-dom/static').prerender;
-            let { prelude: unprocessedPrelude, postponed } = await (0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasks)(()=>{
-                const pendingFinalClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalClientPrerenderStore, prerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
+            const finalClientOnHeaders = (0, _streamops.createOnHeadersCallback)(appendHeader);
+            let { prelude: unprocessedPrelude, postponed } = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+                const pendingFinalClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalClientPrerenderStore, _streamops.getClientPrerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
                 /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                     reactServerStream: reactServerResult.asUnclosingStream(),
                     reactDebugStream: undefined,
@@ -2849,11 +3828,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                         }
                         return htmlRendererErrorHandler(err, errorInfo);
                     },
-                    onHeaders: (headers)=>{
-                        headers.forEach((value, key)=>{
-                            appendHeader(key, value);
-                        });
-                    },
+                    onHeaders: finalClientOnHeaders,
                     maxHeadersLength: reactMaxHeadersLength,
                     bootstrapScripts: [
                         bootstrapScript
@@ -2871,7 +3846,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             }, ()=>{
                 finalClientReactController.abort();
             });
-            const { prelude, preludeIsEmpty } = await (0, _apprenderprerenderutils.processPrelude)(unprocessedPrelude);
+            const { prelude, preludeIsEmpty } = await (0, _streamops.processPrelude)(unprocessedPrelude);
             // If we've disabled throwing on empty static shell, then we don't need to
             // track any dynamic access that occurs above the suspense boundary because
             // we'll do so in the route shell.
@@ -2885,9 +3860,10 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 basePath,
                 tracingMetadata: tracingMetadata
             });
-            const flightData = await (0, _nodewebstreamshelper.streamToBuffer)(reactServerResult.asStream());
-            metadata.flightData = flightData;
-            metadata.segmentData = await collectSegmentData(flightData, finalServerPrerenderStore, ComponentMod, renderOpts);
+            metadata.flightData = await (0, _streamops.streamToBuffer)(cachedNavigations ? prependIsPartialByte(reactServerResult.asStream(), serverIsDynamic) : reactServerResult.asStream());
+            // collectSegmentData needs the raw flight data without the marker byte.
+            const flightData = cachedNavigations ? metadata.flightData.subarray(1) : metadata.flightData;
+            await collectSegmentData(flightData, finalServerPrerenderStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
             if (serverIsDynamic) {
                 // Dynamic case
                 // We will always need to perform a "resume" render of some kind when this route is accessed
@@ -2896,26 +3872,28 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // concatenated to the static shell.
                 if (postponed != null) {
                     // Dynamic HTML case
-                    metadata.postponed = await (0, _postponedstate.getDynamicHTMLPostponedState)(postponed, preludeIsEmpty ? _postponedstate.DynamicHTMLPreludeState.Empty : _postponedstate.DynamicHTMLPreludeState.Full, fallbackRouteParams, resumeDataCache, cacheComponents);
+                    metadata.postponed = await (0, _postponedstate.getDynamicHTMLPostponedState)(postponed, preludeIsEmpty ? _postponedstate.DynamicHTMLPreludeState.Empty : _postponedstate.DynamicHTMLPreludeState.Full, fallbackRouteParams, prerenderResumeDataCache, cacheComponents);
                 } else {
                     // Dynamic Data case
-                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(resumeDataCache, cacheComponents);
+                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(prerenderResumeDataCache, cacheComponents);
                 }
                 reactServerResult.consume();
+                const continueDynamicPrerenderOpts = {
+                    getServerInsertedHTML,
+                    getServerInsertedMetadata,
+                    deploymentId: ctx.sharedContext.deploymentId
+                };
                 return {
                     digestErrorsMap: reactServerErrorsByDigest,
                     ssrErrors: allCapturedErrors,
-                    stream: await (0, _nodewebstreamshelper.continueDynamicPrerender)(prelude, {
-                        getServerInsertedHTML,
-                        getServerInsertedMetadata
-                    }),
+                    stream: await (0, _streamops.continueDynamicPrerender)(prelude, continueDynamicPrerenderOpts),
                     dynamicAccess: (0, _dynamicrendering.consumeDynamicAccess)(serverDynamicTracking, clientDynamicTracking),
                     // TODO: Should this include the SSR pass?
                     collectedRevalidate: finalServerPrerenderStore.revalidate,
                     collectedExpire: finalServerPrerenderStore.expire,
                     collectedStale: selectStaleTime(finalServerPrerenderStore.stale),
                     collectedTags: finalServerPrerenderStore.tags,
-                    renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache)
+                    renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache)
                 };
             } else {
                 // Static case
@@ -2932,11 +3910,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 if (postponed != null) {
                     // We postponed but nothing dynamic was used. We resume the render now and immediately abort it
                     // so we can set all the postponed boundaries to client render mode before we store the HTML response
-                    const resume = require('react-dom/server').resume;
-                    // We don't actually want to render anything so we just pass a stream
-                    // that never resolves. The resume call is going to abort immediately anyway
-                    const foreverStream = new ReadableStream();
-                    const resumeStream = await resume(// eslint-disable-next-line @next/internal/no-ambiguous-jsx
+                    const foreverStream = (0, _streamops.createPendingStream)();
+                    const resumePrelude = await (0, _streamops.resumeAndAbort)(// eslint-disable-next-line @next/internal/no-ambiguous-jsx
                     /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                         reactServerStream: foreverStream,
                         reactDebugStream: undefined,
@@ -2951,7 +3926,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                         nonce
                     });
                     // First we write everything from the prerender, then we write everything from the aborted resume render
-                    htmlStream = (0, _nodewebstreamshelper.chainStreams)(prelude, resumeStream);
+                    htmlStream = (0, _streamops.chainStreams)(prelude, resumePrelude);
                 }
                 let finalStream;
                 const hasFallbackRouteParams = fallbackRouteParams && fallbackRouteParams.size > 0;
@@ -2972,25 +3947,23 @@ 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([], clientModules, {
+                    const emptyReactServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)((0, _streamops.renderToFlightStream)(ComponentMod, [], clientModules, {
                         filterStackFrame,
                         onError: serverComponentsErrorHandler
                     }));
-                    finalStream = await (0, _nodewebstreamshelper.continueStaticFallbackPrerender)(htmlStream, {
-                        inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(emptyReactServerResult.consumeAsStream(), nonce, formState),
+                    finalStream = await (0, _streamops.continueStaticFallbackPrerender)(htmlStream, {
+                        inlinedDataStream: (0, _streamops.createInlinedDataStream)(emptyReactServerResult.consumeAsStream(), nonce, formState),
                         getServerInsertedHTML,
                         getServerInsertedMetadata,
-                        isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
-                        buildId: ctx.workStore.buildId
+                        deploymentId: ctx.sharedContext.deploymentId
                     });
                 } else {
                     // Normal static prerender case, no fallback param handling needed
-                    finalStream = await (0, _nodewebstreamshelper.continueStaticPrerender)(htmlStream, {
-                        inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consumeAsStream(), nonce, formState),
+                    finalStream = await (0, _streamops.continueStaticPrerender)(htmlStream, {
+                        inlinedDataStream: (0, _streamops.createInlinedDataStream)(reactServerResult.consumeAsStream(), nonce, formState),
                         getServerInsertedHTML,
                         getServerInsertedMetadata,
-                        isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
-                        buildId: ctx.workStore.buildId
+                        deploymentId: ctx.sharedContext.deploymentId
                     });
                 }
                 return {
@@ -3003,7 +3976,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     collectedExpire: finalServerPrerenderStore.expire,
                     collectedStale: selectStaleTime(finalServerPrerenderStore.stale),
                     collectedTags: finalServerPrerenderStore.tags,
-                    renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache)
+                    renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache)
                 };
             }
         } else if (experimental.isRoutePPREnabled) {
@@ -3025,9 +3998,11 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ],
                 prerenderResumeDataCache
             };
-            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, clientModules, {
+            const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(reactServerPrerenderStore, getRSCPayload, tree, ctx, {
+                is404: res.statusCode === 404
+            });
+            let reactServerResult;
+            reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(reactServerPrerenderStore, _streamops.renderToFlightStream, ComponentMod, RSCPayload, clientModules, {
                 filterStackFrame,
                 onError: serverComponentsErrorHandler
             }));
@@ -3046,8 +4021,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ],
                 prerenderResumeDataCache
             };
-            const prerender = require('react-dom/static').prerender;
-            const { prelude: unprocessedPrelude, postponed } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(ssrPrerenderStore, prerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
+            const pprOnHeaders = (0, _streamops.createOnHeadersCallback)(appendHeader);
+            const { prelude: unprocessedPrelude, postponed } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(ssrPrerenderStore, _streamops.getClientPrerender, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
             /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                 reactServerStream: reactServerResult.asUnclosingStream(),
                 reactDebugStream: undefined,
@@ -3058,11 +4033,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 images: ctx.renderOpts.images
             }), {
                 onError: htmlRendererErrorHandler,
-                onHeaders: (headers)=>{
-                    headers.forEach((value, key)=>{
-                        appendHeader(key, value);
-                    });
-                },
+                onHeaders: pprOnHeaders,
                 maxHeadersLength: reactMaxHeadersLength,
                 bootstrapScripts: [
                     bootstrapScript
@@ -3078,12 +4049,12 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             // After awaiting here we've waited for the entire RSC render to complete. Crucially this means
             // that when we detect whether we've used dynamic APIs below we know we'll have picked up even
             // parts of the React Server render that might not be used in the SSR render.
-            const flightData = await (0, _nodewebstreamshelper.streamToBuffer)(reactServerResult.asStream());
+            const flightData = await (0, _streamops.streamToBuffer)(reactServerResult.asStream());
             if (shouldGenerateStaticFlightData(workStore)) {
                 metadata.flightData = flightData;
-                metadata.segmentData = await collectSegmentData(flightData, ssrPrerenderStore, ComponentMod, renderOpts);
+                await collectSegmentData(flightData, ssrPrerenderStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
             }
-            const { prelude, preludeIsEmpty } = await (0, _apprenderprerenderutils.processPrelude)(unprocessedPrelude);
+            const { prelude, preludeIsEmpty } = await (0, _streamops.processPrelude)(unprocessedPrelude);
             /**
        * When prerendering there are three outcomes to consider
        *
@@ -3111,13 +4082,15 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // It is possible in the set of stream transforms for Dynamic HTML vs Dynamic Data may differ but currently both states
                 // require the same set so we unify the code path here
                 reactServerResult.consume();
+                const pprDynamicOpts = {
+                    getServerInsertedHTML,
+                    getServerInsertedMetadata,
+                    deploymentId: ctx.sharedContext.deploymentId
+                };
                 return {
                     digestErrorsMap: reactServerErrorsByDigest,
                     ssrErrors: allCapturedErrors,
-                    stream: await (0, _nodewebstreamshelper.continueDynamicPrerender)(prelude, {
-                        getServerInsertedHTML,
-                        getServerInsertedMetadata
-                    }),
+                    stream: await (0, _streamops.continueDynamicPrerender)(prelude, pprDynamicOpts),
                     dynamicAccess: dynamicTracking.dynamicAccesses,
                     // TODO: Should this include the SSR pass?
                     collectedRevalidate: reactServerPrerenderStore.revalidate,
@@ -3128,13 +4101,15 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             } else if (fallbackRouteParams && fallbackRouteParams.size > 0) {
                 // Rendering the fallback case.
                 metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(prerenderResumeDataCache, cacheComponents);
+                const pprFallbackDynamicOpts = {
+                    getServerInsertedHTML,
+                    getServerInsertedMetadata,
+                    deploymentId: ctx.sharedContext.deploymentId
+                };
                 return {
                     digestErrorsMap: reactServerErrorsByDigest,
                     ssrErrors: allCapturedErrors,
-                    stream: await (0, _nodewebstreamshelper.continueDynamicPrerender)(prelude, {
-                        getServerInsertedHTML,
-                        getServerInsertedMetadata
-                    }),
+                    stream: await (0, _streamops.continueDynamicPrerender)(prelude, pprFallbackDynamicOpts),
                     dynamicAccess: dynamicTracking.dynamicAccesses,
                     // TODO: Should this include the SSR pass?
                     collectedRevalidate: reactServerPrerenderStore.revalidate,
@@ -3156,11 +4131,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 if (postponed != null) {
                     // We postponed but nothing dynamic was used. We resume the render now and immediately abort it
                     // so we can set all the postponed boundaries to client render mode before we store the HTML response
-                    const resume = require('react-dom/server').resume;
-                    // We don't actually want to render anything so we just pass a stream
-                    // that never resolves. The resume call is going to abort immediately anyway
-                    const foreverStream = new ReadableStream();
-                    const resumeStream = await resume(// eslint-disable-next-line @next/internal/no-ambiguous-jsx
+                    const foreverStream = (0, _streamops.createPendingStream)();
+                    const resumePrelude = await (0, _streamops.resumeAndAbort)(// eslint-disable-next-line @next/internal/no-ambiguous-jsx
                     /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                         reactServerStream: foreverStream,
                         reactDebugStream: undefined,
@@ -3175,17 +4147,16 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                         nonce
                     });
                     // First we write everything from the prerender, then we write everything from the aborted resume render
-                    htmlStream = (0, _nodewebstreamshelper.chainStreams)(prelude, resumeStream);
+                    htmlStream = (0, _streamops.chainStreams)(prelude, resumePrelude);
                 }
                 return {
                     digestErrorsMap: reactServerErrorsByDigest,
                     ssrErrors: allCapturedErrors,
-                    stream: await (0, _nodewebstreamshelper.continueStaticPrerender)(htmlStream, {
-                        inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consumeAsStream(), nonce, formState),
+                    stream: await (0, _streamops.continueStaticPrerender)(htmlStream, {
+                        inlinedDataStream: (0, _streamops.createInlinedDataStream)(reactServerResult.consumeAsStream(), nonce, formState),
                         getServerInsertedHTML,
                         getServerInsertedMetadata,
-                        isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
-                        buildId: ctx.workStore.buildId
+                        deploymentId: ctx.sharedContext.deploymentId
                     }),
                     dynamicAccess: dynamicTracking.dynamicAccesses,
                     // TODO: Should this include the SSR pass?
@@ -3210,13 +4181,15 @@ 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, clientModules, {
+            const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getRSCPayload, tree, ctx, {
+                is404: res.statusCode === 404
+            });
+            let reactServerResult;
+            reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _streamops.renderToFlightStream, ComponentMod, RSCPayload, clientModules, {
                 filterStackFrame,
                 onError: serverComponentsErrorHandler
             }));
-            const renderToReadableStream = require('react-dom/server').renderToReadableStream;
-            const htmlStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, renderToReadableStream, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
+            const { stream: htmlStream } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _streamops.renderToFizzStream, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
             /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                 reactServerStream: reactServerResult.asUnclosingStream(),
                 reactDebugStream: undefined,
@@ -3233,9 +4206,9 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 ]
             });
             if (shouldGenerateStaticFlightData(workStore)) {
-                const flightData = await (0, _nodewebstreamshelper.streamToBuffer)(reactServerResult.asStream());
+                const flightData = await (0, _streamops.streamToBuffer)(reactServerResult.asStream());
                 metadata.flightData = flightData;
-                metadata.segmentData = await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts);
+                await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
             }
             const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
                 polyfills,
@@ -3247,13 +4220,12 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             return {
                 digestErrorsMap: reactServerErrorsByDigest,
                 ssrErrors: allCapturedErrors,
-                stream: await (0, _nodewebstreamshelper.continueFizzStream)(htmlStream, {
-                    inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consumeAsStream(), nonce, formState),
+                stream: await (0, _streamops.continueFizzStream)(htmlStream, {
+                    inlinedDataStream: (0, _streamops.createInlinedDataStream)(reactServerResult.consumeAsStream(), nonce, formState),
                     isStaticGeneration: true,
-                    isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
-                    buildId: ctx.workStore.buildId,
                     getServerInsertedHTML,
-                    getServerInsertedMetadata
+                    getServerInsertedMetadata,
+                    deploymentId: ctx.sharedContext.deploymentId
                 }),
                 // TODO: Should this include the SSR pass?
                 collectedRevalidate: prerenderLegacyStore.revalidate,
@@ -3314,51 +4286,39 @@ 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, clientModules, {
+        const errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _streamops.renderToFlightStream, ComponentMod, errorRSCPayload, clientModules, {
             filterStackFrame,
             onError: serverComponentsErrorHandler
         });
         try {
-            // TODO we should use the same prerender semantics that we initially rendered
-            // with in this case too. The only reason why this is ok atm is because it's essentially
-            // an empty page and no user code runs.
-            const fizzStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _nodewebstreamshelper.renderToInitialFizzStream, {
-                ReactDOMServer: require('react-dom/server'),
-                element: // eslint-disable-next-line @next/internal/no-ambiguous-jsx
-                /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
-                    reactServerStream: errorServerStream,
-                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
-                    preinitScripts: errorPreinitScripts,
-                    nonce: nonce,
-                    images: ctx.renderOpts.images
-                }),
-                streamOptions: {
-                    nonce,
-                    // Include hydration scripts in the HTML
-                    bootstrapScripts: [
-                        errorBootstrapScript
-                    ],
-                    formState
-                }
+            const { stream: errorHtmlStream } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _streamops.renderToFizzStream, // eslint-disable-next-line @next/internal/no-ambiguous-jsx
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
+                reactServerStream: errorServerStream,
+                ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                preinitScripts: errorPreinitScripts,
+                nonce: nonce,
+                images: ctx.renderOpts.images
+            }), {
+                nonce,
+                bootstrapScripts: [
+                    errorBootstrapScript
+                ],
+                formState
             });
             if (shouldGenerateStaticFlightData(workStore)) {
-                const flightData = await (0, _nodewebstreamshelper.streamToBuffer)(reactServerPrerenderResult.asStream());
+                const flightData = await (0, _streamops.streamToBuffer)(reactServerPrerenderResult.asStream());
                 metadata.flightData = flightData;
-                metadata.segmentData = await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts);
+                await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
             }
             // This is intentionally using the readable datastream from the main
             // render rather than the flight data from the error page render
             const flightStream = reactServerPrerenderResult.consumeAsStream();
             return {
-                // Returning the error that was thrown so it can be used to handle
-                // the response in the caller.
                 digestErrorsMap: reactServerErrorsByDigest,
                 ssrErrors: allCapturedErrors,
-                stream: await (0, _nodewebstreamshelper.continueFizzStream)(fizzStream, {
-                    inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(flightStream, nonce, formState),
+                stream: await (0, _streamops.continueFizzStream)(errorHtmlStream, {
+                    inlinedDataStream: (0, _streamops.createInlinedDataStream)(flightStream, nonce, formState),
                     isStaticGeneration: true,
-                    isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
-                    buildId: ctx.workStore.buildId,
                     getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
                         polyfills,
                         renderServerInsertedHTML,
@@ -3367,7 +4327,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                         tracingMetadata: tracingMetadata
                     }),
                     getServerInsertedMetadata,
-                    validateRootLayout: dev
+                    validateRootLayout: !!process.env.__NEXT_DEV_SERVER,
+                    deploymentId: ctx.sharedContext.deploymentId
                 }),
                 dynamicAccess: null,
                 collectedRevalidate: prerenderStore !== null ? prerenderStore.revalidate : _constants1.INFINITE_CACHE,
@@ -3376,7 +4337,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 collectedTags: prerenderStore !== null ? prerenderStore.tags : null
             };
         } catch (finalErr) {
-            if (process.env.NODE_ENV === 'development' && (0, _httpaccessfallback.isHTTPAccessFallbackError)(finalErr)) {
+            if (process.env.__NEXT_DEV_SERVER && (0, _httpaccessfallback.isHTTPAccessFallbackError)(finalErr)) {
                 const { bailOnRootNotFound } = require('../../client/components/dev-root-http-access-fallback-boundary');
                 bailOnRootNotFound();
             }
@@ -3385,23 +4346,27 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
     }
 }
 const getGlobalErrorStyles = async (tree, ctx)=>{
-    const { modules: { 'global-error': globalErrorModule } } = (0, _parseloadertree.parseLoaderTree)(tree);
-    const { componentMod: { createElement } } = ctx;
-    const GlobalErrorComponent = ctx.componentMod.GlobalError;
-    let globalErrorStyles;
-    if (globalErrorModule) {
-        const [, styles] = await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
-            ctx,
-            filePath: globalErrorModule[1],
-            getComponent: globalErrorModule[0],
-            injectedCSS: new Set(),
-            injectedJS: new Set()
+    const globalErrorModule = (0, _parseloadertree.parseLoaderTree)(tree).modules['global-error'];
+    if (!globalErrorModule) {
+        throw Object.defineProperty(new Error('Invariant: global-error module is required but not found in loader tree'), "__NEXT_ERROR_CODE", {
+            value: "E983",
+            enumerable: false,
+            configurable: true
         });
-        globalErrorStyles = styles;
     }
-    if (ctx.renderOpts.dev) {
+    const { componentMod: { createElement } } = ctx;
+    // Get the GlobalError component and styles from the loader tree
+    const [GlobalErrorComponent, styles] = await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: globalErrorModule[1],
+        getComponent: globalErrorModule[0],
+        injectedCSS: new Set(),
+        injectedJS: new Set()
+    });
+    let globalErrorStyles = styles;
+    if (process.env.__NEXT_DEV_SERVER) {
         const dir = (process.env.NEXT_RUNTIME === 'edge' ? process.env.__NEXT_EDGE_PROJECT_DIR : ctx.renderOpts.dir) || '';
-        const globalErrorModulePath = (0, _segmentexplorerpath.normalizeConventionFilePath)(dir, globalErrorModule == null ? void 0 : globalErrorModule[1]);
+        const globalErrorModulePath = (0, _segmentexplorerpath.normalizeConventionFilePath)(dir, globalErrorModule[1]);
         if (globalErrorModulePath) {
             const SegmentViewNode = ctx.componentMod.SegmentViewNode;
             globalErrorStyles = // This will be rendered next to GlobalError component under ErrorBoundary,
@@ -3418,13 +4383,7 @@ const getGlobalErrorStyles = async (tree, ctx)=>{
         styles: globalErrorStyles
     };
 };
-function createSelectStaleTime(experimental) {
-    return (stale)=>{
-        var _experimental_staleTimes;
-        return stale === _constants1.INFINITE_CACHE && typeof ((_experimental_staleTimes = experimental.staleTimes) == null ? void 0 : _experimental_staleTimes.static) === 'number' ? experimental.staleTimes.static : stale;
-    };
-}
-async function collectSegmentData(fullPageDataBuffer, prerenderStore, ComponentMod, renderOpts) {
+async function collectSegmentData(fullPageDataBuffer, prerenderStore, ComponentMod, renderOpts, pagePath, metadata) {
     // Per-segment prefetch data
     //
     // All of the segments for a page are generated simultaneously, including
@@ -3449,12 +4408,35 @@ async function collectSegmentData(fullPageDataBuffer, prerenderStore, ComponentM
         moduleMap: isEdgeRuntime ? edgeRscModuleMapping : rscModuleMapping,
         serverModuleMap: (0, _manifestssingleton.getServerModuleMap)()
     };
-    const selectStaleTime = createSelectStaleTime(renderOpts.experimental);
+    const selectStaleTime = (0, _staletime.createSelectStaleTime)(renderOpts.experimental);
     const staleTime = selectStaleTime(prerenderStore.stale);
-    return await ComponentMod.collectSegmentData(renderOpts.cacheComponents, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest);
+    // Resolve prefetch hints. At runtime (next start / ISR), the precomputed
+    // hints are already loaded from the prefetch-hints.json manifest. During
+    // build, compute them by measuring segment gzip sizes and write them to
+    // metadata so the build pipeline can persist them to the manifest.
+    let hints;
+    const prefetchInlining = renderOpts.experimental.prefetchInlining;
+    if (!prefetchInlining) {
+        hints = null;
+    } else if (renderOpts.isBuildTimePrerendering) {
+        // Build time: compute fresh hints and store in metadata for the manifest.
+        hints = await ComponentMod.collectPrefetchHints(fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, prefetchInlining.maxSize, prefetchInlining.maxBundleSize);
+        metadata.prefetchHints = hints;
+    } else {
+        var _renderOpts_prefetchHints;
+        // Runtime: use hints from the manifest. Never compute fresh hints
+        // during ISR/revalidation.
+        hints = ((_renderOpts_prefetchHints = renderOpts.prefetchHints) == null ? void 0 : _renderOpts_prefetchHints[pagePath]) ?? null;
+    }
+    // Pass the resolved hints so collectSegmentData can union them into
+    // the TreePrefetch. During the initial build the FlightRouterState in
+    // the buffer doesn't have inlining hints yet (they were just computed
+    // above), so we need to merge them in here. At runtime/ISR the hints
+    // are already embedded in the FlightRouterState, so this is null.
+    metadata.segmentData = await ComponentMod.collectSegmentData(renderOpts.cacheComponents, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, Boolean(renderOpts.experimental.prefetchInlining), hints);
 }
-function isBypassingCachesInDev(renderOpts, requestStore) {
-    return process.env.NODE_ENV === 'development' && !!renderOpts.dev && requestStore.headers.get('cache-control') === 'no-cache';
+function isBypassingCachesInDev(requestStore) {
+    return !!process.env.__NEXT_DEV_SERVER && requestStore.headers.get('cache-control') === 'no-cache';
 }
 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`);
@@ -3483,44 +4465,5 @@ function nodeStreamFromReadableStream(stream) {
         });
     }
 }
-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