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

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     PrefetchingMode: null,
+    prerenderToHTMLOrFlight: null,
     renderToHTMLOrFlight: null,
     runValidationInDevFromSnapshot: null,
     toValidationRenderContext: null
@@ -18,6 +19,9 @@ _export(exports, {
     PrefetchingMode: function() {
         return PrefetchingMode;
     },
+    prerenderToHTMLOrFlight: function() {
+        return prerenderToHTMLOrFlight;
+    },
     renderToHTMLOrFlight: function() {
         return renderToHTMLOrFlight;
     },
@@ -33,15 +37,17 @@ const _approutertypes = require("../../shared/lib/app-router-types");
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _getpagefiles = require("../get-page-files");
 const _entryconstants = require("../../shared/lib/entry-constants");
+const _constants = require("../use-cache/constants");
 const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
 const _renderresult = /*#__PURE__*/ _interop_require_default(require("../render-result"));
 const _streamops = require("./stream-ops");
+const _renderinbrowser = require("./render-in-browser");
 const _instanttestbootstrap = require("./instant-test-bootstrap");
 const _internalutils = require("../internal-utils");
+const _querystring = require("../../shared/lib/router/utils/querystring");
 const _approuterheaders = require("../../client/components/app-router-headers");
 const _metadatacontext = require("../../lib/metadata/metadata-context");
 const _requeststore = require("../async-storage/request-store");
-const _isrscrequest = require("../lib/is-rsc-request");
 const _workstore = require("../async-storage/work-store");
 const _devvalidationevents = require("./dev-validation-events");
 const _asynclocalstorage = require("./async-local-storage");
@@ -51,7 +57,7 @@ const _httpaccessfallback = require("../../client/components/http-access-fallbac
 const _redirect = require("../../client/components/redirect");
 const _redirecterror = require("../../client/components/redirect-error");
 const _implicittags = require("../lib/implicit-tags");
-const _constants = require("../lib/trace/constants");
+const _constants1 = require("../lib/trace/constants");
 const _requestinsightsidentity = require("../lib/trace/request-insights-identity");
 const _tracer = require("../lib/trace/tracer");
 const _localspanrecorder = require("../lib/trace/local-span-recorder");
@@ -60,11 +66,10 @@ const _flightrenderresult = require("./flight-render-result");
 const _createerrorhandler = require("./create-error-handler");
 const _getshortdynamicparamtype = require("./get-short-dynamic-param-type");
 const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
-const _getscriptnoncefromheader = require("./get-script-nonce-from-header");
-const _parseandvalidateflightrouterstate = require("./parse-and-validate-flight-router-state");
-const _createflightrouterstatefromloadertree = require("./create-flight-router-state-from-loader-tree");
+const _createtransporttreefromloadertree = require("./create-transport-tree-from-loader-tree");
 const _actionhandler = require("./action-handler");
 const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
+const _reactbrowserbailout = require("../../shared/lib/lazy-dynamic/react-browser-bailout");
 const _log = require("../../build/output/log");
 const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
 const _headers = require("../web/spec-extension/adapters/headers");
@@ -78,10 +83,10 @@ const _getassetquerystring = require("./get-asset-query-string");
 const _manifestssingleton = require("./manifests-singleton");
 const _postponedstate = require("./postponed-state");
 const _hooksservercontext = require("../../client/components/hooks-server-context");
+const _serveractionrequestmeta = require("../lib/server-action-request-meta");
 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 _blockingroutemessages = require("./blocking-route-messages");
 const _clientcomponentrendererlogger = require("../client-component-renderer-logger");
@@ -91,7 +96,6 @@ const _devvalidationscheduler = require("./dev-validation-scheduler");
 const _nextrequest = require("../web/spec-extension/adapters/next-request");
 const _parserelativeurl = require("../../shared/lib/router/utils/parse-relative-url");
 const _approuter = /*#__PURE__*/ _interop_require_default(require("../../client/components/app-router"));
-const _serveractionrequestmeta = require("../lib/server-action-request-meta");
 const _createinitialrouterstate = require("../../client/components/router-reducer/create-initial-router-state");
 const _approuterinstance = require("../../client/components/app-router-instance");
 const _utils = require("../instrumentation/utils");
@@ -104,17 +108,18 @@ 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 _fastsetimmediateexternal = require("../node-environment-extensions/fast-set-immediate.external");
 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 _constants2 = require("../../lib/constants");
 const _createcomponentstylesandscripts = require("./create-component-styles-and-scripts");
 const _parseloadertree = require("../../shared/lib/router/utils/parse-loader-tree");
 const _resumedatacache = require("../resume-data-cache/resume-data-cache");
-const _iserror = /*#__PURE__*/ _interop_require_default(require("../../lib/is-error"));
+const _cachestore = require("../resume-data-cache/cache-store");
+const _iserror = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/is-error"));
 const _createserverinsertedmetadata = require("./metadata-insertion/create-server-inserted-metadata");
-const _serverutils = require("../server-utils");
 const _revalidationutils = require("../revalidation-utils");
 const _trackmoduleloadingexternal = require("./module-loading/track-module-loading.external");
 const _reactlargeshellerror = require("./react-large-shell-error");
@@ -125,6 +130,7 @@ const _imageconfigcontextsharedruntime = require("../../shared/lib/image-config-
 const _imageconfig = require("../../shared/lib/image-config");
 const _stagedrendering = require("./staged-rendering");
 const _instantconfig = require("./instant-validation/instant-config");
+const _ensurestatic = require("./segment-config/ensure-static");
 const _warnonce = require("../../shared/lib/utils/warn-once");
 const _debugchannelserver = require("./debug-channel-server");
 const _streamutils = require("./instant-validation/stream-utils");
@@ -133,7 +139,6 @@ const _cookies = require("../web/spec-extension/cookies");
 const _instantvalidationerror = require("./instant-validation/instant-validation-error");
 const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
-const _paramsutils = require("../lib/params-utils");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -192,47 +197,6 @@ const flightDataPathHeadKey = 'h';
 const getFlightViewportKey = (requestId)=>requestId + 'v';
 const getFlightMetadataKey = (requestId)=>requestId + 'm';
 const filterStackFrame = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').filterStackFrameDEV : undefined;
-function parseRequestHeaders(headers, options) {
-    const isRSCRequest = (0, _isrscrequest.isRSCRequestHeader)(headers[_approuterheaders.RSC_HEADER]);
-    // runtime prefetch requests are *not* treated as prefetch requests
-    // (TODO: this is confusing, we should refactor this to express this better)
-    const isPrefetchRequest = isRSCRequest && headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '1';
-    const isAppShellPrefetchRequest = isRSCRequest && headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '3';
-    // App Shell prefetches are a subtype of runtime prefetch — same code path,
-    // but with less resolved content (omitting link data)
-    const isRuntimePrefetchRequest = isRSCRequest && (headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '2' || isAppShellPrefetchRequest);
-    const isHmrRefresh = headers[_approuterheaders.NEXT_HMR_REFRESH_HEADER] !== undefined;
-    const shouldProvideFlightRouterState = isRSCRequest && (!isPrefetchRequest || !options.isRoutePPREnabled);
-    const flightRouterState = shouldProvideFlightRouterState ? (0, _parseandvalidateflightrouterstate.parseAndValidateFlightRouterState)(headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]) : undefined;
-    // Checks if this is a prefetch of the Route Tree by the Segment Cache
-    const isRouteTreePrefetchRequest = isRSCRequest && headers[_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER] === '/_tree';
-    const csp = headers['content-security-policy'] || headers['content-security-policy-report-only'];
-    const nonce = typeof csp === 'string' ? (0, _getscriptnoncefromheader.getScriptNonceFromHeader)(csp) : undefined;
-    const previouslyRevalidatedTags = (0, _serverutils.getPreviouslyRevalidatedTags)(headers, options.previewModeId);
-    let requestId;
-    let htmlRequestId;
-    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).
-        requestId = typeof headers[_approuterheaders.NEXT_REQUEST_ID_HEADER] === 'string' ? headers[_approuterheaders.NEXT_REQUEST_ID_HEADER] : undefined;
-        htmlRequestId = typeof headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] === 'string' ? headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] : undefined;
-    }
-    return {
-        flightRouterState,
-        isPrefetchRequest,
-        isRuntimePrefetchRequest,
-        isAppShellPrefetchRequest,
-        isRouteTreePrefetchRequest,
-        isHmrRefresh,
-        isRSCRequest,
-        nonce,
-        previouslyRevalidatedTags,
-        requestId,
-        htmlRequestId
-    };
-}
 /**
  * Walks the loader tree to find the minimum `unstable_dynamicStaleTime` exported by
  * any page module. Returns null if no page exports the config.
@@ -330,13 +294,11 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
  * This function is only called on "dynamic" requests (ie, there wasn't already a static response).
  * It uses request headers (namely `next-router-state-tree`) to determine where to start rendering.
  */ async function generateDynamicRSCPayload(ctx, options) {
-    // Flight data that is going to be passed to the browser.
-    // Currently a single item array but in the future multiple patches might be combined in a single request.
-    // We initialize `flightData` to an empty string because the client router knows how to tolerate
-    // it (treating it as an MPA navigation). The only time this function wouldn't generate flight data
-    // 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 = '';
+    // Transport data that is going to be passed to the browser. Undefined when
+    // the response renders nothing: server actions, if the server action
+    // handler instructs this function to skip rendering. When the server action
+    // reducer sees an absent tree, it resolves the action with no data.
+    let transportData = undefined;
     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)) {
@@ -367,7 +329,7 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
         }), createElement(Metadata, {
             key: getFlightMetadataKey(requestId)
         }));
-        flightData = (needsFullTree ? await (0, _walktreewithflightrouterstate.createFullTreeFlightDataForNavigation)({
+        const responseTree = needsFullTree ? await (0, _walktreewithflightrouterstate.createFullTreeForNavigation)({
             ctx,
             loaderTree,
             rscHead,
@@ -389,8 +351,17 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
             preloadCallbacks,
             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
-        ;
+        });
+        if (responseTree !== null) {
+            transportData = {
+                t: responseTree.tree,
+                h: {
+                    r: responseTree.head,
+                    p: responseTree.isHeadPartial,
+                    v: (0, _varyparams.getMetadataVaryParamsAccumulator)()
+                }
+            };
+        }
     }
     // In dev, the Vary header may not reliably reflect whether a route can
     // be intercepted, because interception routes are compiled on demand.
@@ -401,22 +372,30 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
     // 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 maybeAppendBuildIdToRSCPayload(ctx, {
+        const actionResponse = {
             a: options.actionResult,
-            f: flightData,
-            q: getRenderedSearch(query),
+            q: (0, _querystring.getRenderedSearch)(query),
             i: !!couldBeIntercepted
-        });
+        };
+        if (transportData !== undefined) {
+            actionResponse.t = transportData;
+        }
+        return maybeAppendBuildIdToRSCPayload(ctx, actionResponse);
     }
     // Otherwise, it's a regular RSC response.
     const baseResponse = maybeAppendBuildIdToRSCPayload(ctx, {
-        f: flightData,
-        q: getRenderedSearch(query),
+        q: (0, _querystring.getRenderedSearch)(query),
         i: !!couldBeIntercepted,
-        S: workStore.isStaticGeneration,
-        h: (0, _varyparams.getMetadataVaryParamsAccumulator)(),
+        // 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: ctx.renderCapabilities.supportsPerSegmentPrefetching,
         r: (0, _varyparams.getRootParamsVaryParamsAccumulator)() ?? undefined
     });
+    if (transportData !== undefined) {
+        baseResponse.t = transportData;
+    }
     if ((options == null ? void 0 : options.staleTimeIterable) !== undefined) {
         baseResponse.s = options.staleTimeIterable;
     }
@@ -427,42 +406,51 @@ function NonIndex({ createElement, pagePath, statusCode, isPossibleServerAction
         baseResponse.a = options.shellByteLengthPromise;
     }
     if ((options == null ? void 0 : options.shellUsedSessionDataPromise) !== undefined) {
-        baseResponse.u = options.shellUsedSessionDataPromise;
+        baseResponse.w = options.shellUsedSessionDataPromise;
     }
     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.
+    // Include the per-page dynamic stale time from unstable_dynamicStaleTime. This
+    // function only generates payloads for dynamic requests, and the client treats
+    // the field's 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;
-        }
+    const dynamicStaleTime = await getDynamicStaleTime(ctx.componentMod.routeModule.userland.loaderTree);
+    if (dynamicStaleTime !== null) {
+        baseResponse.d = dynamicStaleTime;
     }
     return baseResponse;
 }
-function createErrorContext(ctx, renderSource) {
+function createRequestErrorContext(ctx, renderSource) {
+    return createErrorContext(ctx, renderSource, (0, _utils.getRevalidateReason)({
+        isOnDemandRevalidate: ctx.workStore.isOnDemandRevalidate
+    }));
+}
+function createPrerenderErrorContext(ctx, renderSource) {
+    return createErrorContext(ctx, renderSource, (0, _utils.getRevalidateReason)({
+        isOnDemandRevalidate: ctx.workStore.isOnDemandRevalidate,
+        isStaticGeneration: true
+    }));
+}
+function createErrorContext(ctx, renderSource, revalidateReason) {
     return {
         routerKind: 'App Router',
         routePath: ctx.pagePath,
         // TODO: is this correct if `isPossibleServerAction` is a false positive?
         routeType: ctx.isPossibleServerAction ? 'action' : 'render',
         renderSource,
-        revalidateReason: (0, _utils.getRevalidateReason)(ctx.workStore)
+        revalidateReason
     };
 }
 /**
  * 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) {
+ */ async function generateDynamicFlightRenderResult(ctx, requestStore, options) {
     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);
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, createRequestErrorContext(ctx, 'react-server-components-payload'), silenceLog);
     }
     const onError = (0, _createerrorhandler.createReactServerErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
     // With Server Components HMR cancellation enabled, a superseded HMR refresh
@@ -511,28 +499,28 @@ function createErrorContext(ctx, renderSource) {
  * Production-only staged dynamic flight render for cache components (Node.js
  * streams). Uses staged rendering to separate static (RDC-backed) from
  * runtime/dynamic content.
- */ async function generateStagedDynamicFlightRenderResultNode(req, ctx, requestStore) {
+ */ async function generateStagedDynamicFlightRenderResultNode(ctx, requestStore) {
     const { componentMod, workStore, renderOpts } = ctx;
     const { 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);
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, createRequestErrorContext(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();
+    const prefetchMode = await getPrefetchingModeForPage(renderOpts, loaderTree);
     const stageController = new _stagedrendering.StagedRenderingController({
         abortSignal: null,
         abandonController: null,
-        // 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.
-        syncIO: _stagedrendering.SyncIOMode.Untracked,
+        // Synchronous request-time data ends the static stage before its result can
+        // enter the Cached Navigation.
+        syncIO: getSyncIOMode(prefetchMode),
         finalStage: null
     });
     // Initialize stale time tracking on the request store.
-    requestStore.stale = _constants1.INFINITE_CACHE;
+    requestStore.stale = _constants2.INFINITE_CACHE;
     requestStore.stagedRendering = stageController;
     requestStore.varyParamsAccumulator = (0, _varyparams.createResponseVaryParamsAccumulator)();
     requestStore.asyncApiPromises = createAsyncApiPromises(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
@@ -540,18 +528,25 @@ function createErrorContext(ctx, renderSource) {
     const shellByteLengthDeferred = (0, _promisewithresolvers.createPromiseWithResolvers)();
     const staticStageByteLengthDeferred = (0, _promisewithresolvers.createPromiseWithResolvers)();
     let runtimePrefetchStream;
+    let startRuntimePrefetchRender;
+    // Partial prefetching waits for cacheReady() before starting an embedded
+    // runtime prefetch. Track React's native immediates so that this wait
+    // includes Flight work that can discover more cache reads. Other prefetch
+    // modes do not wait for cacheReady() here.
+    const immediateTracker = prefetchMode === 2 ? new _fastsetimmediateexternal.ImmediateTracker() : null;
     // Check if this route should runtime-cache its navigation. This happens when
     // Partial Prefetching is enabled for the route, either per segment (a
-    // `prefetch` of 'partial' or 'unstable_eager') or globally (the
+    // `prefetch` of 'partial') or globally (the
     // `partialPrefetching` config). 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 because it adds extra server
     // processing and increases the response payload size.
-    if (Boolean(renderOpts.partialPrefetching) || await (0, _instantconfig.anySegmentHasPartialPrefetchingEnabled)(loaderTree)) {
+    if (prefetchMode === 2) {
         // Create a mutable cache that gets filled during the dynamic render.
-        const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+        const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)(// Prefill the mutable cache from the RDC if available.
+        requestStore.resumeDataCache ?? undefined);
         requestStore.resumeDataCache = prerenderResumeDataCache;
-        const cacheSignal = new _cachesignal.CacheSignal();
+        const cacheSignal = new _cachesignal.CacheSignal(immediateTracker);
         (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
         requestStore.cacheSignal = cacheSignal;
         // Create a deferred stream for the runtime prefetch result. Its readable
@@ -560,18 +555,20 @@ function createErrorContext(ctx, renderSource) {
         // 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));
+        startRuntimePrefetchRender = async ()=>{
+            await cacheSignal.cacheReady();
+            return spawnRuntimePrefetchWithFilledCaches(runtimePrefetchTransform.writable, ctx, prerenderResumeDataCache, requestStore, onError);
+        };
     }
-    const rscPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, {
+    const rscPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, immediateTracker === null ? generateDynamicRSCPayload : _fastsetimmediateexternal.runWithNativeImmediateTracking.bind(null, immediateTracker, generateDynamicRSCPayload), ctx, {
         staleTimeIterable,
         staticStageByteLengthPromise: staticStageByteLengthDeferred.promise,
         shellByteLengthPromise: shellByteLengthDeferred.promise,
         runtimePrefetchStream
     });
     const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
-    const flightStream = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+    const runRenderTasks = immediateTracker === null ? _apprenderrenderutils.runInSequentialTasks : _fastsetimmediateexternal.runWithNativeImmediateTracking.bind(null, immediateTracker, _apprenderrenderutils.runInSequentialTasks);
+    const flightStream = await runRenderTasks(()=>{
         stageController.advanceStage(_stagedrendering.RenderStage.ShellStatic);
         const sourceStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToNodeFlightStream, ctx.componentMod, rscPayload, clientModules, {
             onError,
@@ -585,9 +582,8 @@ function createErrorContext(ctx, renderSource) {
             shellByteLengthDeferred.resolve(byteLengths[_stagedrendering.RenderStage.ShellStatic]);
         });
         return dynamicStream;
-    }, ()=>{
-        stageController.advanceStage(_stagedrendering.RenderStage.Static);
-    }, ()=>{
+    }, // Fold `PrefetchStatic_prefetchApi` into `PrefetchStatic` - no discrimination needed here
+    ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.NavigationStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>{
         // This is a separate task that doesn't advance a stage. It forces
         // draining the immediate queue so that the stale time iterable and vary
         // params accumulators are flushed before we advance to the dynamic stage.
@@ -595,9 +591,8 @@ function createErrorContext(ctx, renderSource) {
         if (requestStore.varyParamsAccumulator) {
             (0, _varyparams.finishAccumulatingVaryParams)(requestStore.varyParamsAccumulator);
         }
-    }, ()=>{
-        stageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
-    });
+    }, ()=>stageController.advanceStage(_stagedrendering.RenderStage.Dynamic));
+    void (startRuntimePrefetchRender == null ? void 0 : startRuntimePrefetchRender());
     return new _flightrenderresult.FlightRenderResult(flightStream, {
         fetchMetrics: workStore.fetchMetrics
     });
@@ -614,13 +609,13 @@ function createErrorContext(ctx, renderSource) {
         const staleTimeIterable = new _staletime.StaleTimeIterable();
         // We want to be able to rewind the result to a session shell.
         const mode = {
-            type: 'rewindable-session-shell',
+            type: 'navigation',
             shellUsedSessionDataDeferred: (0, _promisewithresolvers.createPromiseWithResolvers)(),
             shellByteLengthDeferred: (0, _promisewithresolvers.createPromiseWithResolvers)()
         };
         const { result } = await finalRuntimeServerPrerender(mode, ctx, generateDynamicRSCPayload.bind(null, ctx, {
             staleTimeIterable,
-            shellByteLengthPromise: mode.type === 'rewindable-session-shell' ? mode.shellByteLengthDeferred.promise : undefined,
+            shellByteLengthPromise: mode.shellByteLengthDeferred.promise,
             shellUsedSessionDataPromise: mode.shellUsedSessionDataDeferred.promise
         }), prerenderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode, onError, staleTimeIterable, // This path is only reached on the production Cache Components + Cached
         // Navigations renders (the staged Flight response and the HTML hydration
@@ -665,42 +660,39 @@ async function stagedRenderWithoutCachesInDevNode(ctx, requestStore, getPayload,
             ...options,
             environmentName
         });
-    }, ()=>{
-        stageController.advanceStage(_stagedrendering.RenderStage.Static);
-    }, ()=>{
-        stageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
-    });
+    }, ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic_prefetchApi), ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.NavigationStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Dynamic));
 }
 function getEnvironmentNameForStageWithoutCaches(stage) {
     switch(stage){
         case _stagedrendering.RenderStage.Before:
         case _stagedrendering.RenderStage.ShellStatic:
+        case _stagedrendering.RenderStage.PrefetchStatic_prefetchApi:
+        case _stagedrendering.RenderStage.PrefetchStatic:
+        case _stagedrendering.RenderStage.NavigationStatic:
         case _stagedrendering.RenderStage.Static:
             return 'Prerender';
         case _stagedrendering.RenderStage.ShellRuntime:
-        case _stagedrendering.RenderStage.Runtime:
+        case _stagedrendering.RenderStage.PrefetchRuntime_prefetchApi:
+        case _stagedrendering.RenderStage.PrefetchRuntime:
+        case _stagedrendering.RenderStage.NavigationRuntime:
         case _stagedrendering.RenderStage.Dynamic:
         case _stagedrendering.RenderStage.Abandoned:
             return 'Server';
         default:
             stage;
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
-                value: "E881",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Invalid render stage: ${stage}`);
     }
 }
 /**
  * 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, fallbackParams) {
+ */ async function generateDynamicFlightRenderResultWithStagesInDev(ctx, initialRequestStore, createRequestStore, stagedFallbackParams) {
     const { htmlRequestId, renderOpts, requestId, workStore, componentMod: { createElement, routeModule: { userland: { loaderTree } } }, url } = ctx;
     const { onInstrumentationRequestError, setReactDebugChannel, setCacheStatus, isBuildTimePrerendering = false } = renderOpts;
     let didErrorObservably = false;
     function onFlightDataRenderError(err, silenceLog) {
         didErrorObservably = true;
-        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, createRequestErrorContext(ctx, 'react-server-components-payload'), silenceLog);
     }
     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
@@ -736,23 +728,28 @@ function getEnvironmentNameForStageWithoutCaches(stage) {
             setCacheStatus('ready', htmlRequestId);
         }
         const prefetchMode = await getPrefetchingModeForPage(renderOpts, loaderTree);
-        // A client navigation into a Partial Prefetching route extends the shell
-        // through the runtime-prefetchable content: it has already settled on the
-        // client (via the prefetch) by the time it navigates, so it belongs in this
-        // response's shell. Everything else uses the static shell, like an initial
-        // load: plain navigations, and HMR refreshes (a fresh render of the current
-        // page, with no settled prefetch to draw on). Dynamic content always
-        // streams in after the shell.
+        const ensureStaticLevel = await (0, _ensurestatic.resolveEnsureStaticLevel)(loaderTree, /* partialPrefetching */ prefetchMode === 2);
+        // We try to match the client router's prefetching behavior in dev
+        // by avoiding showing contents that would've been prefetched.
+        // (see stream blocking logic in `streamStagedRenderInDev` for more).
+        // Determine how much content would've been prefetched, which varies
+        // between Cache Components and PartialPrefetching.
+        // (HMR refreshes act like a full page navigation, which would use the static PPR shell)
         let prefetchStage;
         if (initialRequestStore.isHmrRefresh === true) {
             prefetchStage = _stagedrendering.RenderStage.Static;
         } else {
             if (prefetchMode === 2) {
-                // TODO(app-shells): model `partialPrefetching: "unstable_eager"`
                 // TODO(app-shells): if this navigation came from <Link prefetch={true} />,
-                // we should show the shell for a speculative prefetch
+                // we should show the content for a speculative prefetch
                 // (which can have more data than the app shell)
-                prefetchStage = _stagedrendering.RenderStage.ShellRuntime;
+                if (ensureStaticLevel >= _ensurestatic.EnsureStaticLevel.Shell) {
+                    // TODO(ensure-static): this is overly conservative and may show less content
+                    // than we would in practice
+                    prefetchStage = _stagedrendering.RenderStage.ShellStatic;
+                } else {
+                    prefetchStage = _stagedrendering.RenderStage.ShellRuntime;
+                }
             } else {
                 prefetchStage = _stagedrendering.RenderStage.Static;
             }
@@ -787,7 +784,7 @@ function getEnvironmentNameForStageWithoutCaches(stage) {
             getPayload,
             onError,
             shouldValidate,
-            fallbackRouteParams: fallbackParams,
+            fallbackRouteParams: stagedFallbackParams,
             getDevRenderDidError: ()=>didErrorObservably,
             navigationKind: {
                 type: 'prefetched-client',
@@ -818,12 +815,12 @@ function getEnvironmentNameForStageWithoutCaches(stage) {
         fetchMetrics: workStore.fetchMetrics
     });
 }
-async function generateRuntimePrefetchResult(req, ctx, requestStore, isShellPrefetch) {
+async function generateRuntimePrefetchResult(ctx, requestStore, isShellPrefetch) {
     const { workStore, renderOpts, htmlRequestId, requestId } = ctx;
     const { isBuildTimePrerendering = false, onInstrumentationRequestError, setReactDebugChannel } = 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);
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, // TODO(runtime-ppr): should we use a different value?
+        createRequestErrorContext(ctx, 'react-server-components-payload'), silenceLog);
     }
     const onError = (0, _createerrorhandler.createReactServerErrorHandler)(false, isBuildTimePrerendering, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
     const metadata = {};
@@ -832,8 +829,8 @@ async function generateRuntimePrefetchResult(req, ctx, requestStore, isShellPref
     const rootParams = (0, _createcomponenttree.getRootParams)(loaderTree, getDynamicParamFromSegment);
     // We need to share caches between the prospective prerender and the final prerender,
     // but we're not going to persist this anywhere.
-    const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
-    await prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, generateDynamicRSCPayload.bind(null, ctx), prerenderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode);
+    const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)(// Prefill the mutable cache from the RDC if available.
+    requestStore.resumeDataCache ?? undefined);
     const mode = isShellPrefetch ? {
         type: 'session-shell-only',
         shellUsedSessionDataDeferred: (0, _promisewithresolvers.createPromiseWithResolvers)()
@@ -842,6 +839,7 @@ async function generateRuntimePrefetchResult(req, ctx, requestStore, isShellPref
         shellUsedSessionDataDeferred: (0, _promisewithresolvers.createPromiseWithResolvers)(),
         shellByteLengthDeferred: (0, _promisewithresolvers.createPromiseWithResolvers)()
     };
+    await prospectiveRuntimeServerPrerender(ctx, getFinalStageForRuntimePrerenderMode(mode), generateDynamicRSCPayload.bind(null, ctx), prerenderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode);
     const debugChannel = setReactDebugChannel ? (0, _debugchannelserver.createWebDebugChannel)() : undefined;
     if (debugChannel && setReactDebugChannel) {
         setReactDebugChannel(debugChannel.clientSide, htmlRequestId, requestId);
@@ -855,7 +853,7 @@ async function generateRuntimePrefetchResult(req, ctx, requestStore, isShellPref
     metadata.fetchMetrics = ctx.workStore.fetchMetrics;
     return new _flightrenderresult.FlightRenderResult(response.result.prelude, metadata);
 }
-async function prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, getPayload, resumeDataCache, rootParams, headers, cookies, draftMode) {
+async function prospectiveRuntimeServerPrerender(ctx, finalStage, getPayload, resumeDataCache, rootParams, headers, cookies, draftMode) {
     const { implicitTags, renderOpts, workStore } = ctx;
     const { ComponentMod } = renderOpts;
     // Prerender controller represents the lifetime of the prerender.
@@ -869,7 +867,8 @@ async function prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, getPayloa
     const initialServerRenderController = new AbortController();
     // The cacheSignal helps us track whether caches are still filling or we are ready
     // to cut the render off.
-    const cacheSignal = new _cachesignal.CacheSignal();
+    const immediateTracker = new _fastsetimmediateexternal.ImmediateTracker();
+    const cacheSignal = new _cachesignal.CacheSignal(immediateTracker);
     const initialServerPrerenderStore = {
         type: 'prerender-runtime',
         phase: 'render',
@@ -887,7 +886,7 @@ async function prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, getPayloa
         // so we set `expire` and `revalidate` to their minimum values just in case.
         revalidate: 1,
         expire: 0,
-        stale: _constants1.INFINITE_CACHE,
+        stale: _constants2.INFINITE_CACHE,
         tags: [
             ...implicitTags.tags
         ],
@@ -895,9 +894,10 @@ async function prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, getPayloa
         hmrRefreshHash: undefined,
         // We don't track vary params during initial prerender, only the final one
         varyParamsAccumulator: null,
-        // No stage sequencing needed for prospective renders.
+        // We don't use sequencing needed for prospective renders, but we need to
+        // track where the final prerender is going to end to avoid warming too much.
         stagedRendering: null,
-        isSessionShell: isShellPrefetch,
+        finalStage,
         // These are not present in regular prerenders, but allowed in a runtime
         // prerender.
         // Any cache keyed on headers() or cookies() needs to be invalidated.
@@ -909,7 +909,7 @@ async function prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, getPayloa
     const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     // We're not going to use the result of this render because the only time it could be used
     // is if it completes in a microtask and that's likely very rare for any non-trivial app
-    const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, getPayload);
+    const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, _fastsetimmediateexternal.runWithNativeImmediateTracking.bind(null, immediateTracker, getPayload));
     const prerenderOptions = {
         filterStackFrame,
         onError: (err)=>{
@@ -930,7 +930,7 @@ async function prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, getPayloa
         // transitioning out of the prerender environment
         signal: initialServerRenderController.signal
     };
-    const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, (0, _streamops.getServerPrerender)(ComponentMod), initialServerPayload, clientModules, prerenderOptions);
+    const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, _fastsetimmediateexternal.runWithNativeImmediateTracking.bind(null, immediateTracker, (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();
@@ -974,16 +974,16 @@ async function finalRuntimeServerPrerender(mode, ctx, getPayload, resumeDataCach
     let resultIsPartial = false;
     const finalServerController = new AbortController();
     const serverDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
-    const finalStageController = new _stagedrendering.StagedRenderingController({
+    const finalStage = getFinalStageForRuntimePrerenderMode(mode);
+    const stageController = new _stagedrendering.StagedRenderingController({
         abortSignal: finalServerController.signal,
         abandonController: null,
-        // In dynamic renders, we allow Sync IO in the Runtime stage
+        // In dynamic renders, we allow Sync IO in runtime stages
         // if partialPrefetching is not enabled. However, a runtime prerender
         // (or App Shell) is stricter and never allows sync IO in any stage
         // that we go through here (i.e. < Dynamic)
         syncIO: _stagedrendering.SyncIOMode.AllowedInDynamic,
-        // we only reach the runtime stage if we're doing a rewindable render
-        finalStage: mode.type === 'session-shell-only' ? _stagedrendering.RenderStage.ShellRuntime : _stagedrendering.RenderStage.Runtime
+        finalStage
     });
     const varyParamsAccumulator = (0, _varyparams.createResponseVaryParamsAccumulator)();
     const finalServerPrerenderStore = {
@@ -1000,15 +1000,15 @@ async function finalRuntimeServerPrerender(mode, ctx, getPayload, resumeDataCach
         // so we set `expire` and `revalidate` to their minimum values just in case.
         revalidate: 1,
         expire: 0,
-        stale: _constants1.INFINITE_CACHE,
+        stale: _constants2.INFINITE_CACHE,
         tags: [
             ...implicitTags.tags
         ],
         resumeDataCache,
         hmrRefreshHash: undefined,
         varyParamsAccumulator,
-        stagedRendering: finalStageController,
-        isSessionShell: mode.type === 'session-shell-only',
+        stagedRendering: stageController,
+        finalStage,
         // These are not present in regular prerenders, but allowed in a runtime
         // prerender.
         headers: _headers.HeadersAdapter.fresh(headers),
@@ -1023,7 +1023,7 @@ async function finalRuntimeServerPrerender(mode, ctx, getPayload, resumeDataCach
     const stageByteLengths = createStageByteLengths();
     const collectChunk = (chunk)=>{
         collectPrerenderChunk(collectedChunks, finalServerController.signal, chunk);
-        increaseChunkByteLengths(stageByteLengths, finalStageController.currentStage, chunk.byteLength);
+        increaseChunkByteLengths(stageByteLengths, stageController.currentStage, chunk.byteLength);
     };
     let didHandleUnexpectedAbort = false;
     /**
@@ -1043,6 +1043,12 @@ async function finalRuntimeServerPrerender(mode, ctx, getPayload, resumeDataCach
     };
     const onUnexpectedAbort = ()=>{
         resultIsPartial = true;
+        const syncInterruptReason = serverDynamicTracking.syncDynamicErrorWithStack;
+        if (syncInterruptReason) {
+            console.error(syncInterruptReason);
+        } else {
+            console.error(new _invarianterror.InvariantError('A runtime prerender was aborted synchronously, but Next.js could not determine the reason.'));
+        }
         // FIXME(NAR-810): If we're already aborted due to Sync IO, there should be no need to
         // finish the accumulators. However, it seems like in `--debug-prerender`
         // the stream will stay open if we don't close the iterable here.
@@ -1054,7 +1060,7 @@ async function finalRuntimeServerPrerender(mode, ctx, getPayload, resumeDataCach
         }
     };
     await (0, _apprenderrenderutils.runInSequentialTasks)(async ()=>{
-        finalStageController.advanceStage(_stagedrendering.RenderStage.ShellStatic);
+        stageController.advanceStage(_stagedrendering.RenderStage.ShellStatic);
         let stream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPrerenderStore, ComponentMod.renderToReadableStream, finalRSCPayload, clientModules, {
             filterStackFrame,
             onError,
@@ -1066,39 +1072,53 @@ async function finalRuntimeServerPrerender(mode, ctx, getPayload, resumeDataCach
         await iterateStreamingPrerenderChunks(stream, finalServerController.signal, collectChunk, streamState);
     }, ()=>{
         if (checkUnexpectedAbort()) return;
-        finalStageController.advanceStage(_stagedrendering.RenderStage.Static);
+        // Fold `PrefetchStatic_prefetchApi` into `PrefetchStatic` - no discrimination needed here
+        stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic);
     }, ()=>{
         if (checkUnexpectedAbort()) return;
-        finalStageController.advanceStage(_stagedrendering.RenderStage.ShellRuntime);
+        stageController.advanceStage(_stagedrendering.RenderStage.NavigationStatic);
     }, ()=>{
         if (checkUnexpectedAbort()) return;
-        if (mode.type === 'session-shell-only') {
-            // We're only rendering a shell, so we do not advance to stages where link data is resolved.
-            return;
-        }
-        finalStageController.advanceStage(_stagedrendering.RenderStage.Runtime);
+        stageController.advanceStage(_stagedrendering.RenderStage.Static);
+    }, ()=>{
+        if (checkUnexpectedAbort()) return;
+        stageController.advanceStage(_stagedrendering.RenderStage.ShellRuntime);
+    }, ()=>{
+        if (checkUnexpectedAbort()) return;
+        // We may not reach this stage depending on the mode.
+        if (finalStage < _stagedrendering.RenderStage.PrefetchRuntime) return;
+        // Fold `PrefetchRuntime_prefetchApi` into `PrefetchRuntime` - no discrimination needed here
+        stageController.advanceStage(_stagedrendering.RenderStage.PrefetchRuntime);
     }, ()=>{
         if (checkUnexpectedAbort()) return;
-        // Finish the accumulators. We need to wait for Flight to flush the result into the stream,
-        // which is scheduled in a (fast) immediate, so we do this in a separate task
-        // (fast immediates will be drained at the end of the task, so in the next task we know we're done flushing)
         // Check if session data unblocked new content in the shell.
         const didSessionDataUnblockNewContent = stageByteLengths[_stagedrendering.RenderStage.ShellRuntime] > stageByteLengths[_stagedrendering.RenderStage.Static];
         mode.shellUsedSessionDataDeferred.resolve(didSessionDataUnblockNewContent);
-        if (mode.type === 'rewindable-session-shell') {
-            // If advancing to the runtime stage didn't unblock new content,
+        if ('shellByteLengthDeferred' in mode) {
+            // If advancing to the PrefetchRuntime stage didn't unblock new content,
             // then the result does not depend on link data and can be used as a shell (indicated via `null`).
             // Otherwise, send a byte length to indicate where the shell content ends.
-            const didLinkDataUnblockNewContent = stageByteLengths[_stagedrendering.RenderStage.Runtime] > stageByteLengths[_stagedrendering.RenderStage.ShellRuntime];
+            const didLinkDataUnblockNewContent = stageByteLengths[_stagedrendering.RenderStage.PrefetchRuntime] > stageByteLengths[_stagedrendering.RenderStage.ShellRuntime];
             mode.shellByteLengthDeferred.resolve(didLinkDataUnblockNewContent ? stageByteLengths[_stagedrendering.RenderStage.ShellRuntime] : null);
         }
+    }, ()=>{
+        if (checkUnexpectedAbort()) return;
+        // We may not reach this stage depending on the mode.
+        if (finalStage < _stagedrendering.RenderStage.NavigationRuntime) return;
+        stageController.advanceStage(_stagedrendering.RenderStage.NavigationRuntime);
+    }, ()=>{
+        // Finish the accumulators. We need to wait for Flight to flush the result into the stream,
+        // which is scheduled in a (fast) immediate, so we do this in a separate task
+        // (fast immediates will be drained at the end of the task, so in the next task we know we're done flushing)
         staleTimeIterable.close();
         (0, _varyparams.finishAccumulatingVaryParams)(varyParamsAccumulator);
     }, ()=>{
         if (checkUnexpectedAbort()) return;
         if (streamState.isPending) {
-            // If the prerender is still pending then it must depend on dynamic data
-            // (or, if this is a shell prefetch, link data)
+            // If the prerender is still pending then it must be blocked by
+            // - prefetch(), navigation(), or dynamic data (for shell prefetches)
+            // - navigation() or dynamic data (for runtime prefetches)
+            // - dynamic data (for runtime prefetch streams embedded in navigations)
             resultIsPartial = true;
         }
         _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPrerenderStore, finalServerController.abort.bind(finalServerController));
@@ -1118,6 +1138,16 @@ async function finalRuntimeServerPrerender(mode, ctx, getPayload, resumeDataCach
         collectedTags: finalServerPrerenderStore.tags
     };
 }
+function getFinalStageForRuntimePrerenderMode(mode) {
+    switch(mode.type){
+        case 'session-shell-only':
+            return _stagedrendering.RenderStage.ShellRuntime;
+        case 'rewindable-session-shell':
+            return _stagedrendering.RenderStage.PrefetchRuntime;
+        case 'navigation':
+            return _stagedrendering.RenderStage.NavigationRuntime;
+    }
+}
 /**
  * Crawlers will inadvertently think the canonicalUrl in the RSC payload should be crawled
  * when our intention is to just seed the router state with the current URL.
@@ -1126,37 +1156,10 @@ async function finalRuntimeServerPrerender(mode, ctx, getPayload, resumeDataCach
  */ function prepareInitialCanonicalUrl(url) {
     return (url.pathname + url.search).split('/');
 }
-function getRenderedSearch(query) {
-    // Inlined implementation of querystring.encode, which is not available in
-    // the Edge runtime.
-    const pairs = [];
-    for(const key in query){
-        const value1 = query[key];
-        if (value1 == null) continue;
-        if (Array.isArray(value1)) {
-            for (const v of value1){
-                pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(v))}`);
-            }
-        } else {
-            pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value1))}`);
-        }
-    }
-    // The result should match the format of a web URL's `search` property, since
-    // this is the format that's stored in the App Router state.
-    // TODO: We're a bit inconsistent about this. The x-nextjs-rewritten-query
-    // header omits the leading question mark. Should refactor to always do
-    // that instead.
-    if (pairs.length === 0) {
-        // If the search string is empty, return an empty string.
-        return '';
-    }
-    // Prepend '?' to the search params string.
-    return '?' + pairs.join('&');
-}
 // This is the data necessary to render <AppRouter /> when no SSR errors are encountered
 async function getRSCPayload(tree, ctx, options) {
     var _ctx_renderOpts_prefetchHints;
-    const { is404, staleTimeIterable, staticStageByteLengthPromise, shellByteLengthPromise, runtimePrefetchStream } = options;
+    const { is404, isPrerendering, staleTimeIterable, staticStageByteLengthPromise, shellByteLengthPromise, runtimePrefetchStream } = options;
     const injectedCSS = new Set();
     const injectedJS = new Set();
     const injectedFontPreloadTags = new Set();
@@ -1165,10 +1168,8 @@ async function getRSCPayload(tree, ctx, options) {
     if (process.env.__NEXT_DEV_SERVER) {
         missingSlots = new Set();
     }
-    const { getDynamicParamFromSegment, query, appUsingSizeAdjustment, componentMod: { createMetadataComponents, createElement, Fragment }, url, workStore } = ctx;
+    const { query, appUsingSizeAdjustment, componentMod: { createMetadataComponents, createElement, Fragment }, url } = ctx;
     const hints = ((_ctx_renderOpts_prefetchHints = ctx.renderOpts.prefetchHints) == null ? void 0 : _ctx_renderOpts_prefetchHints[ctx.pagePath]) ?? null;
-    const prefetchInliningEnabled = Boolean(ctx.renderOpts.experimental.prefetchInlining);
-    const initialTree = await (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(tree, hints, prefetchInliningEnabled, ctx.renderOpts.cacheComponents, ctx.renderOpts.partialPrefetching, workStore.isStaticGeneration, ctx.renderOpts.isBuildTimePrerendering ?? false, getDynamicParamFromSegment, query);
     const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
     const hasGlobalNotFound = !!tree[2]['global-not-found'];
     const { Viewport, Metadata, MetadataOutlet } = createMetadataComponents({
@@ -1186,7 +1187,7 @@ async function getRSCPayload(tree, ctx, options) {
         serveStreamingMetadata
     });
     const preloadCallbacks = [];
-    const seedData = await (0, _createcomponenttree.createComponentTree)({
+    const initialTree = await (0, _createcomponenttree.createFullComponentTree)({
         ctx,
         loaderTree: tree,
         parentParams: {},
@@ -1199,7 +1200,9 @@ async function getRSCPayload(tree, ctx, options) {
         missingSlots,
         preloadCallbacks,
         authInterrupts: ctx.renderOpts.experimental.authInterrupts,
-        MetadataOutlet
+        MetadataOutlet,
+        isPrerendering,
+        hintTree: hints
     });
     // 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
@@ -1226,24 +1229,24 @@ async function getRSCPayload(tree, ctx, options) {
     // client Segment Cache after a prefetch to determine if it can skip the
     // second request to fill in the dynamic data.
     //
-    // See similar comment in create-component-tree.tsx for more context.
-    const isPossiblyPartialHead = workStore.isStaticGeneration && ctx.renderOpts.experimental.isRoutePPREnabled === true;
+    // See AppRenderCapabilities.isPossiblyPartialResponse for more context.
+    const isPossiblyPartialHead = ctx.renderCapabilities.isPossiblyPartialResponse;
     return maybeAppendBuildIdToRSCPayload(ctx, {
         // See the comment above the `Preloads` component (below) for why this is part of the payload
         P: createElement(Preloads, {
             preloadCallbacks: preloadCallbacks
         }),
         c: prepareInitialCanonicalUrl(url),
-        q: getRenderedSearch(query),
+        q: (0, _querystring.getRenderedSearch)(query),
         i: !!couldBeIntercepted,
-        f: [
-            [
-                initialTree,
-                seedData,
-                initialHead,
-                isPossiblyPartialHead
-            ]
-        ],
+        t: {
+            t: initialTree,
+            h: {
+                r: initialHead,
+                p: isPossiblyPartialHead,
+                v: (0, _varyparams.getMetadataVaryParamsAccumulator)()
+            }
+        },
         m: missingSlots,
         G: [
             GlobalError,
@@ -1253,8 +1256,7 @@ async function getRSCPayload(tree, ctx, options) {
         // 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.getMetadataVaryParamsAccumulator)(),
+        S: ctx.renderCapabilities.supportsPerSegmentPrefetching,
         r: (0, _varyparams.getRootParamsVaryParamsAccumulator)() ?? undefined,
         s: staleTimeIterable,
         a: shellByteLengthPromise,
@@ -1265,7 +1267,7 @@ async function getRSCPayload(tree, ctx, options) {
         // 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
+        d: !isPrerendering ? await getDynamicStaleTime(tree) ?? undefined : undefined
     });
 }
 /**
@@ -1280,7 +1282,7 @@ async function getRSCPayload(tree, ctx, options) {
 // This is the data necessary to render <AppRouter /> when an error state is triggered
 async function getErrorRSCPayload(tree, ctx, ssrError, errorType, shouldRenderMetadataAndViewport) {
     var _ctx_renderOpts_prefetchHints;
-    const { getDynamicParamFromSegment, query, componentMod: { createMetadataComponents, createElement, Fragment }, url, workStore } = ctx;
+    const { getDynamicParamFromSegment, query, componentMod: { createMetadataComponents, createElement, Fragment }, url } = ctx;
     let Viewport = null;
     let Metadata = null;
     if (shouldRenderMetadataAndViewport) {
@@ -1310,45 +1312,43 @@ async function getErrorRSCPayload(tree, ctx, ssrError, errorType, shouldRenderMe
     }), Metadata ? createElement(Metadata, null) : null);
     const errorHints = ((_ctx_renderOpts_prefetchHints = ctx.renderOpts.prefetchHints) == null ? void 0 : _ctx_renderOpts_prefetchHints[ctx.pagePath]) ?? null;
     const errorPrefetchInliningEnabled = Boolean(ctx.renderOpts.experimental.prefetchInlining);
-    const initialTree = await (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(tree, errorHints, errorPrefetchInliningEnabled, ctx.renderOpts.cacheComponents, ctx.renderOpts.partialPrefetching, workStore.isStaticGeneration, ctx.renderOpts.isBuildTimePrerendering ?? false, getDynamicParamFromSegment, query);
     let err = undefined;
     if (ssrError) {
-        err = (0, _iserror.default)(ssrError) ? ssrError : Object.defineProperty(new Error(ssrError + ''), "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
+        err = (0, _iserror.default)(ssrError) ? ssrError : new Error(ssrError + '');
     }
     // For metadata notFound error there's no global not found boundary on top
     // so we create a not found page with AppRouter
-    const seedData = [
-        createElement('html', {
-            id: '__next_error__'
-        }, 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
-        }) : null)),
-        {},
-        null,
-        false,
-        null
-    ];
+    const errorShell = createElement('html', {
+        id: '__next_error__'
+    }, 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
+    }) : null));
+    const partialPrefetching = Boolean(ctx.renderOpts.partialPrefetching) || await (0, _instantconfig.anySegmentHasPartialPrefetchingEnabled)(tree);
+    const initialTree = await (0, _createtransporttreefromloadertree.createFullTransportTreeFromLoaderTree)(tree, errorHints, errorPrefetchInliningEnabled, ctx.missingPrefetchHintPolicy, partialPrefetching, getDynamicParamFromSegment, ctx.renderOpts.notFoundParams);
+    // Attach the error shell as the root's render output. Vary params are not
+    // tracked for error pages.
+    initialTree.d = {
+        r: errorShell,
+        p: false,
+        v: null
+    };
     const { GlobalError, styles: globalErrorStyles } = await getGlobalErrorStyles(tree, ctx);
-    const isPossiblyPartialHead = workStore.isStaticGeneration && ctx.renderOpts.experimental.isRoutePPREnabled === true;
+    const isPossiblyPartialHead = ctx.renderCapabilities.isPossiblyPartialResponse;
     return maybeAppendBuildIdToRSCPayload(ctx, {
         c: prepareInitialCanonicalUrl(url),
-        q: getRenderedSearch(query),
+        q: (0, _querystring.getRenderedSearch)(query),
         m: undefined,
         i: false,
-        f: [
-            [
-                initialTree,
-                seedData,
-                initialHead,
-                isPossiblyPartialHead
-            ]
-        ],
+        t: {
+            t: initialTree,
+            h: {
+                r: initialHead,
+                p: isPossiblyPartialHead,
+                v: (0, _varyparams.getMetadataVaryParamsAccumulator)()
+            }
+        },
         G: [
             GlobalError,
             globalErrorStyles
@@ -1357,8 +1357,7 @@ async function getErrorRSCPayload(tree, ctx, ssrError, errorType, shouldRenderMe
         // 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.getMetadataVaryParamsAccumulator)(),
+        S: ctx.renderCapabilities.supportsPerSegmentPrefetching,
         r: (0, _varyparams.getRootParamsVaryParamsAccumulator)() ?? undefined
     });
 }
@@ -1421,13 +1420,13 @@ function ErrorApp({ reactServerStream, preinitScripts, ServerInsertedHTMLProvide
 /* eslint-enable @next/internal/no-ambiguous-jsx -- React Client */ }
 /**
  * Extracted to a separate function to prevent V8 from retaining the entire
- * `renderToHTMLOrFlightImpl` closure scope through globalThis.__next_require__.
+ * the render initialization scope through globalThis.__next_require__.
  * V8 shares a single Context object per scope for all closures; by creating
  * these closures in their own function scope, the globalThis references only
  * retain `instrumented` and `cacheComponents`, not request-specific data like
  * req/res/workStore.
- */ function installGlobalModuleLoadingHandlers(ComponentMod, cacheComponents, isTracingEnabled) {
-    const instrumented = (0, _clientcomponentrendererlogger.wrapClientComponentLoader)(ComponentMod, isTracingEnabled);
+ */ function installGlobalModuleLoadingHandlers(ComponentMod, cacheComponents) {
+    const instrumented = (0, _clientcomponentrendererlogger.wrapClientComponentLoader)(ComponentMod);
     // When we are prerendering if there is a cacheSignal for tracking
     // cache reads we track calls to `loadChunk` and `require`. This allows us
     // to treat chunk/module loading with similar semantics as cache reads to avoid
@@ -1451,11 +1450,10 @@ function ErrorApp({ reactServerStream, preinitScripts, ServerInsertedHTMLProvide
             case 'cache':
             case 'private-cache':
                 return true;
-            case 'prerender-ppr':
             case 'prerender-legacy':
             case 'request':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 return false;
             default:
                 workUnitStore;
@@ -1478,7 +1476,40 @@ function ErrorApp({ reactServerStream, preinitScripts, ServerInsertedHTMLProvide
         return loadingChunk;
     };
 }
-async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, postponedState, serverComponentsHmrCache, sharedContext, interpolatedParams, fallbackRouteParams) {
+const generateRenderRequestId = ()=>{
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        return crypto.randomUUID();
+    } else {
+        return require('next/dist/compiled/nanoid').nanoid();
+    }
+};
+const generatePrerenderRequestId = async (req)=>{
+    return Buffer.from(await crypto.subtle.digest('SHA-1', Buffer.from(req.url))).toString('hex');
+};
+function initializeClientComponentLoadTracking(renderOpts, workStore) {
+    if (!renderOpts.ComponentMod.__next_app__) return undefined;
+    // Capture the request's span before the HTML render creates its own span.
+    const parentSpan = (0, _tracer.getTracer)().getActiveScopeSpan();
+    const isTracingEnabled = (parentSpan == null ? void 0 : parentSpan.isRecording()) ?? false;
+    let tracker;
+    if ('performance' in globalThis && (process.env.NEXT_OTEL_PERFORMANCE_PREFIX || isTracingEnabled)) {
+        tracker = new _clientcomponentrendererlogger.ClientComponentLoadTracker((metrics)=>{
+            if (process.env.NEXT_RUNTIME !== 'edge' && isTracingEnabled && metrics && metrics.clientComponentLoadEnd >= metrics.clientComponentLoadStart) {
+                (0, _tracer.getTracer)().startSpan(_constants1.NextNodeServerSpan.clientComponentLoading, {
+                    parentSpan,
+                    startTime: metrics.clientComponentLoadStart,
+                    attributes: {
+                        'next.clientComponentLoadCount': metrics.clientComponentLoadCount,
+                        'next.span_type': _constants1.NextNodeServerSpan.clientComponentLoading
+                    }
+                }).end(metrics.clientComponentLoadEnd);
+            }
+        });
+        workStore.clientComponentLoadTracker = tracker;
+    }
+    return tracker;
+}
+async function prepareAppPageRender(req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, sharedContext, interpolatedParams, fallbackRouteParams, routeMatch, generateRequestId, missingPrefetchHintPolicy, renderCapabilities) {
     const isNotFoundPath = pagePath === '/404';
     if (isNotFoundPath) {
         res.statusCode = 404;
@@ -1488,21 +1519,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
     // avoid that resources can be deduped by React Float if the same resource is
     // rendered or preloaded multiple times: `<link href="a.css?v={Date.now()}"/>`.
     const requestTimestamp = Date.now();
-    const { 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__) {
-        var _getTracer_getActiveScopeSpan;
-        const isTracingEnabled = ((_getTracer_getActiveScopeSpan = (0, _tracer.getTracer)().getActiveScopeSpan()) == null ? void 0 : _getTracer_getActiveScopeSpan.isRecording()) ?? false;
-        installGlobalModuleLoadingHandlers(ComponentMod, cacheComponents, isTracingEnabled);
-    }
-    if (process.env.__NEXT_DEV_SERVER && setIsrStatus && !cacheComponents) {
-        // Reset the ISR status at start of request.
-        const { pathname } = new URL(req.url || '/', 'http://n');
-        setIsrStatus(pathname, // Only pages using the Node runtime can use ISR, Edge is always dynamic.
-        process.env.NEXT_RUNTIME === 'edge' ? false : undefined);
-    }
+    const { ComponentMod, nextFontManifest, assetPrefix = '', enableTainting } = renderOpts;
     if (// 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)) {
@@ -1511,22 +1528,6 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
             // report them at that time.
             workStore.shouldTrackFetchMetrics = false;
         });
-        req.originalRequest.on('end', ()=>{
-            if ('performance' in globalThis) {
-                const metrics = (0, _clientcomponentrendererlogger.getClientComponentLoaderMetrics)({
-                    reset: true
-                });
-                if (metrics) {
-                    (0, _tracer.getTracer)().startSpan(_constants.NextNodeServerSpan.clientComponentLoading, {
-                        startTime: metrics.clientComponentLoadStart,
-                        attributes: {
-                            'next.clientComponentLoadCount': metrics.clientComponentLoadCount,
-                            'next.span_type': _constants.NextNodeServerSpan.clientComponentLoading
-                        }
-                    }).end(metrics.clientComponentLoadStart + metrics.clientComponentLoadTimes);
-                }
-            }
-        });
     }
     const metadata = {
         statusCode: isNotFoundPath ? 404 : undefined,
@@ -1546,11 +1547,10 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         ...query
     };
     (0, _internalutils.stripInternalQueries)(query);
-    const { isStaticGeneration } = workStore;
     let requestId;
     let htmlRequestId;
     const requestInsightsIdentity = process.env.__NEXT_REQUEST_INSIGHTS ? (0, _requestinsightsidentity.getRequestInsightsIdentity)() : undefined;
-    const { flightRouterState, isPrefetchRequest, isRuntimePrefetchRequest, isAppShellPrefetchRequest, isRSCRequest, isHmrRefresh, nonce } = parsedRequestHeaders;
+    const { flightRouterState, isPrefetchRequest, nonce } = parsedRequestHeaders;
     if (parsedRequestHeaders.requestId) {
         // If the client has provided a request ID (in development mode), we use it.
         requestId = parsedRequestHeaders.requestId;
@@ -1560,13 +1560,7 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         requestId = requestInsightsIdentity.requestId;
     } else {
         // Otherwise we generate a new request ID.
-        if (isStaticGeneration) {
-            requestId = Buffer.from(await crypto.subtle.digest('SHA-1', Buffer.from(req.url))).toString('hex');
-        } else if (process.env.NEXT_RUNTIME === 'edge') {
-            requestId = crypto.randomUUID();
-        } else {
-            requestId = require('next/dist/compiled/nanoid').nanoid();
-        }
+        requestId = await generateRequestId(req);
     }
     // If the client has provided an HTML request ID, we use it to associate the
     // request with the HTML document from which it originated, which is used to
@@ -1578,22 +1572,14 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
     workStore.htmlRequestId = htmlRequestId;
     const getDynamicParamFromSegment = makeGetDynamicParamFromSegment(interpolatedParams, fallbackRouteParams, renderOpts.experimental.optimisticRouting);
     const isPossibleActionRequest = (0, _serveractionrequestmeta.getIsPossibleServerAction)(req);
-    // 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 implicitTags = await (0, _implicittags.getImplicitTags)(workStore.page, routeMatch.resolvedPathname, fallbackRouteParams);
     const ctx = {
         componentMod: ComponentMod,
         url,
         renderOpts,
         workStore,
+        missingPrefetchHintPolicy,
+        renderCapabilities,
         parsedRequestHeaders,
         getDynamicParamFromSegment,
         interpolatedParams,
@@ -1615,156 +1601,232 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
         implicitTags
     };
     (0, _tracer.getTracer)().setRootSpanAttribute('next.route', pagePath);
-    if (isStaticGeneration) {
-        // We're either building or revalidating. In either case we need to
-        // prerender our page rather than render it.
-        const prerenderToStreamWithTracing = (0, _tracer.getTracer)().wrap(_constants.AppRenderSpan.getBodyResult, {
-            spanName: `prerender route (app) ${pagePath}`,
-            attributes: {
-                'next.route': pagePath
-            }
-        }, prerenderToStream);
-        const response = await prerenderToStreamWithTracing(req, res, ctx, metadata, loaderTree, fallbackRouteParams);
-        // If we're debugging partial prerendering, print all the dynamic API accesses
-        // that occurred during the render.
-        // @TODO move into renderToStream function
-        if (response.dynamicAccess && (0, _dynamicrendering.accessedDynamicData)(response.dynamicAccess) && renderOpts.isDebugDynamicAccesses) {
-            (0, _log.warn)('The following dynamic usage was detected:');
-            for (const access of (0, _dynamicrendering.formatDynamicAPIAccesses)(response.dynamicAccess)){
-                (0, _log.warn)(access);
-            }
-        }
-        // If we encountered any unexpected errors during build we fail the
-        // prerendering phase and the build.
-        if (workStore.invalidDynamicUsageError) {
-            (0, _dynamicrendering.logDisallowedDynamicError)(workStore, workStore.invalidDynamicUsageError);
-            throw new _staticgenerationbailout.StaticGenBailoutError();
-        }
-        if (response.digestErrorsMap.size) {
-            const buildFailingError = response.digestErrorsMap.values().next().value;
-            if (buildFailingError) throw buildFailingError;
+    return {
+        req,
+        ctx,
+        metadata,
+        loaderTree
+    };
+}
+async function prerenderAppPage({ ctx, metadata, loaderTree }) {
+    const { res, pagePath, renderOpts, workStore, url, fallbackRouteParams } = ctx;
+    // We're either building or revalidating. In either case we need to
+    // prerender our page rather than render it.
+    const prerenderToStreamWithTracing = (0, _tracer.getTracer)().wrap(_constants1.AppRenderSpan.getBodyResult, {
+        spanName: `prerender route (app) ${pagePath}`,
+        attributes: {
+            'next.route': pagePath
         }
-        // Pick first userland SSR error, which is also not a RSC error.
-        if (response.ssrErrors.length) {
-            const buildFailingError = response.ssrErrors.find((err)=>(0, _createerrorhandler.isUserLandError)(err));
-            if (buildFailingError) throw buildFailingError;
+    }, prerenderToStream);
+    const tracker = initializeClientComponentLoadTracking(renderOpts, workStore);
+    metadata.clientComponentLoadTracker = tracker;
+    let response;
+    try {
+        response = await prerenderToStreamWithTracing(res, ctx, metadata, loaderTree, fallbackRouteParams);
+    } finally{
+        tracker == null ? void 0 : tracker.finish();
+    }
+    // If we're debugging partial prerendering, print all the dynamic API accesses
+    // that occurred during the render.
+    // @TODO move into renderToStream function
+    if (response.dynamicAccess && (0, _dynamicrendering.accessedDynamicData)(response.dynamicAccess) && renderOpts.isDebugDynamicAccesses) {
+        (0, _log.warn)('The following dynamic usage was detected:');
+        for (const access of (0, _dynamicrendering.formatDynamicAPIAccesses)(response.dynamicAccess)){
+            (0, _log.warn)(access);
         }
-        const options = {
-            metadata,
-            contentType: _constants1.HTML_CONTENT_TYPE_HEADER
+    }
+    if (workStore.invalidDynamicUsageError) {
+        (0, _dynamicrendering.logDisallowedDynamicError)(workStore, workStore.invalidDynamicUsageError);
+        throw new _staticgenerationbailout.StaticGenBailoutError();
+    }
+    let renderError = response.error;
+    const firstReactServerError = response.digestErrorsMap.values().next();
+    if (!firstReactServerError.done) {
+        renderError = {
+            thrownValue: firstReactServerError.value
         };
-        // If we have pending revalidates, wait until they are all resolved.
-        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.href);
-                }
-            });
-            if (renderOpts.waitUntil) {
-                renderOpts.waitUntil(revalidatesPromise);
-            } else {
-                options.waitUntil = revalidatesPromise;
+    }
+    // Pick first userland SSR error, which is also not a RSC error.
+    if (renderError === undefined) {
+        for (const ssrError of response.ssrErrors){
+            if ((0, _createerrorhandler.isUserLandError)(ssrError, renderOpts.experimental.reactBrowserBailout)) {
+                renderError = {
+                    thrownValue: ssrError
+                };
+                break;
             }
         }
-        applyMetadataFromPrerenderResult(response, metadata, workStore);
-        if (response.renderResumeDataCache) {
-            metadata.renderResumeDataCache = response.renderResumeDataCache;
-        }
-        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);
+    }
+    // Build failures still throw, even if recovery produced a usable response.
+    if (renderError !== undefined && renderOpts.isBuildTimePrerendering) {
+        throw renderError.thrownValue;
+    }
+    const options = {
+        metadata,
+        contentType: _constants2.HTML_CONTENT_TYPE_HEADER
+    };
+    // If we have pending revalidates, wait until they are all resolved.
+    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.href);
+            }
+        });
+        if (renderOpts.waitUntil) {
+            renderOpts.waitUntil(revalidatesPromise);
+        } else {
+            options.waitUntil = revalidatesPromise;
         }
-        return result;
+    }
+    if (renderError !== undefined) {
+        res.statusCode = 500;
+        metadata.statusCode = 500;
     } 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 fallbackParams = (0, _requestmeta.getRequestMeta)(req, 'fallbackParams') || null;
-        const hmrRefreshHash = (0, _requestmeta.getRequestMeta)(req, 'hmrRefreshHash');
-        const createRequestStore = _requeststore.createRequestStoreForRender.bind(null, req, res, url, rootParams, implicitTags, renderOpts.onUpdateCookies, renderOpts.previewProps, isHmrRefresh, serverComponentsHmrCache, renderResumeDataCache, fallbackParams, hmrRefreshHash);
-        const requestStore = createRequestStore();
-        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)) {
-            req.originalRequest.on('end', ()=>{
-                const { pathname } = new URL(req.url || '/', 'http://n');
-                const isStatic = !requestStore.usedDynamic && !workStore.forceDynamic;
-                setIsrStatus(pathname, isStatic);
-            });
+        applyMetadataFromPrerenderResult(response, metadata, workStore);
+    }
+    const streamString = await (0, _streamops.streamToString)(response.stream);
+    // Copy only the delivery metadata. Partial recovery includes its resume data
+    // cache in the serialized postponed state, so it needs no live cache below.
+    if (renderError !== undefined) {
+        return {
+            error: (0, _iserror.getProperError)(renderError.thrownValue),
+            result: new _renderresult.default(streamString, {
+                contentType: _constants2.HTML_CONTENT_TYPE_HEADER,
+                waitUntil: options.waitUntil,
+                metadata: {
+                    headers: metadata.headers,
+                    flightData: metadata.flightData,
+                    fetchMetrics: metadata.fetchMetrics,
+                    postponed: metadata.postponed
+                }
+            })
+        };
+    }
+    if (response.renderResumeDataCache) {
+        metadata.renderResumeDataCache = response.renderResumeDataCache;
+    }
+    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;
+}
+async function renderAppPage({ req, ctx, metadata, loaderTree }, postponedState, dev) {
+    const { res, url, renderOpts, workStore, parsedRequestHeaders, componentMod: ComponentMod, implicitTags } = ctx;
+    const { cacheComponents, setIsrStatus, serverActions } = renderOpts;
+    const { cachedNavigations } = renderOpts.experimental;
+    const { isHmrRefresh, isPrefetchRequest, isRSCRequest, isRuntimePrefetchRequest, isAppShellPrefetchRequest, isRouteTreePrefetchRequest } = parsedRequestHeaders;
+    const isPossibleActionRequest = ctx.isPossibleServerAction;
+    // We're rendering dynamically
+    const renderResumeDataCache = renderOpts.renderResumeDataCache ?? (postponedState == null ? void 0 : postponedState.renderResumeDataCache) ?? null;
+    const rootParams = (0, _createcomponenttree.getRootParams)(loaderTree, ctx.getDynamicParamFromSegment);
+    // Keep the placeholder map for dev's separate prerender validation. The
+    // request store only needs names to defer params during a staged render.
+    const stagedFallbackParams = (0, _requestmeta.getRequestMeta)(req, 'stagedFallbackParams') ?? null;
+    const stagedFallbackParamNames = (postponedState == null ? void 0 : postponedState.stagedFallbackParams) !== undefined ? postponedState.stagedFallbackParams : stagedFallbackParams ? new Set(stagedFallbackParams.keys()) : null;
+    const createRequestStore = _requeststore.createRequestStoreForRender.bind(null, req, res, url, rootParams, implicitTags, renderOpts.onUpdateCookies, renderOpts.previewProps, isHmrRefresh, dev == null ? void 0 : dev.serverComponentsHmrCache, renderResumeDataCache, stagedFallbackParamNames, dev == null ? void 0 : dev.hmrRefreshHash);
+    const requestStore = createRequestStore();
+    const setDevIsrStatus = process.env.__NEXT_DEV_SERVER && setIsrStatus && !cacheComponents && !isPossibleActionRequest && !isPrefetchRequest && !isRuntimePrefetchRequest && !isAppShellPrefetchRequest && !isRouteTreePrefetchRequest ? setIsrStatus : undefined;
+    if (setDevIsrStatus) {
+        if (process.env.NEXT_RUNTIME === 'edge') {
+            // Edge routes cannot use ISR, so there is no dynamic transition to watch.
+            setDevIsrStatus(url.pathname, false);
+        } else {
+            // The indicator remains pending until the output has finished rendering.
+            setDevIsrStatus(url.pathname, undefined);
         }
-        // MARK: RSC request
-        if (isRSCRequest) {
-            if (isRuntimePrefetchRequest) {
-                // MARK: RSC runtimePrefetch
-                return generateRuntimePrefetchResult(req, ctx, requestStore, isAppShellPrefetchRequest);
+    }
+    // MARK: RSC request
+    if (isRSCRequest) {
+        if (isRuntimePrefetchRequest) {
+            // MARK: RSC runtimePrefetch
+            return generateRuntimePrefetchResult(ctx, requestStore, isAppShellPrefetchRequest);
+        } else {
+            if (process.env.__NEXT_DEV_SERVER && process.env.NEXT_RUNTIME !== 'edge' && cacheComponents) {
+                // MARK: RSC devCacheComponents
+                return generateDynamicFlightRenderResultWithStagesInDev(ctx, requestStore, createRequestStore, stagedFallbackParams);
+            } else if (cacheComponents && cachedNavigations) {
+                // MARK: RSC cacheComponents
+                return generateStagedDynamicFlightRenderResultNode(ctx, requestStore);
             } else {
-                if (process.env.__NEXT_DEV_SERVER && process.env.NEXT_RUNTIME !== 'edge' && cacheComponents) {
-                    // MARK: RSC devCacheComponents
-                    return generateDynamicFlightRenderResultWithStagesInDev(req, ctx, requestStore, createRequestStore, fallbackParams);
-                } else if (cacheComponents && cachedNavigations) {
-                    // MARK: RSC cacheComponents
-                    return generateStagedDynamicFlightRenderResultNode(req, ctx, requestStore);
-                } else {
-                    // MARK: RSC dynamic
-                    return generateDynamicFlightRenderResult(req, ctx, requestStore);
+                // MARK: RSC dynamic
+                const result = await generateDynamicFlightRenderResult(ctx, requestStore);
+                if (setDevIsrStatus && process.env.NEXT_RUNTIME !== 'edge') {
+                    result.pipeThrough(new TransformStream({
+                        // Only a normally completed output can classify the route.
+                        // Stream errors and cancellation leave the indicator pending.
+                        flush () {
+                            setDevIsrStatus(url.pathname, !requestStore.usedDynamic && !workStore.forceDynamic);
+                        }
+                    }));
                 }
+                return result;
             }
         }
-        let didExecuteServerAction = false;
-        let formState = null;
-        if (isPossibleActionRequest) {
-            // For action requests, we handle them differently with a special render result.
-            const actionRequestResult = await (0, _actionhandler.handleAction)({
-                req,
-                res,
-                ComponentMod,
-                generateFlight: generateDynamicFlightRenderResult,
-                workStore,
-                requestStore,
-                serverActions,
-                ctx,
-                metadata
-            });
-            if (actionRequestResult) {
-                if (actionRequestResult.type === 'not-found') {
-                    const notFoundLoaderTree = createNotFoundLoaderTree(loaderTree);
-                    res.statusCode = 404;
-                    metadata.statusCode = 404;
-                    const stream = await renderToStream(requestStore, req, res, ctx, notFoundLoaderTree, formState, postponedState, metadata, undefined, fallbackParams);
+    }
+    let didExecuteServerAction = false;
+    let formState = null;
+    if (isPossibleActionRequest) {
+        // For action requests, we handle them differently with a special render result.
+        const actionRequestResult = await (0, _actionhandler.handleAction)({
+            req,
+            res,
+            ComponentMod,
+            generateFlight: generateDynamicFlightRenderResult,
+            workStore,
+            requestStore,
+            serverActions,
+            ctx,
+            metadata
+        });
+        if (actionRequestResult) {
+            if (actionRequestResult.type === 'not-found') {
+                const notFoundLoaderTree = createNotFoundLoaderTree(loaderTree);
+                res.statusCode = 404;
+                metadata.statusCode = 404;
+                const tracker = initializeClientComponentLoadTracking(renderOpts, workStore);
+                metadata.clientComponentLoadTracker = tracker;
+                try {
+                    const stream = await renderToStream(requestStore, res, ctx, notFoundLoaderTree, formState, postponedState, metadata, undefined, stagedFallbackParams, tracker);
                     return new _renderresult.default(stream, {
                         metadata,
-                        contentType: _constants1.HTML_CONTENT_TYPE_HEADER
+                        contentType: _constants2.HTML_CONTENT_TYPE_HEADER
                     });
-                } else if (actionRequestResult.type === 'done') {
-                    if (actionRequestResult.result) {
-                        actionRequestResult.result.assignMetadata(metadata);
-                        return actionRequestResult.result;
-                    } else if (actionRequestResult.formState) {
-                        formState = actionRequestResult.formState;
-                    }
+                } catch (renderError) {
+                    // Failed setup may never reach the SSR readiness callback.
+                    tracker == null ? void 0 : tracker.finish();
+                    throw renderError;
+                }
+            } else if (actionRequestResult.type === 'done') {
+                if (actionRequestResult.result) {
+                    actionRequestResult.result.assignMetadata(metadata);
+                    return actionRequestResult.result;
+                } else if (actionRequestResult.formState) {
+                    formState = actionRequestResult.formState;
                 }
             }
-            didExecuteServerAction = true;
         }
-        const options = {
-            metadata,
-            contentType: _constants1.HTML_CONTENT_TYPE_HEADER
-        };
+        didExecuteServerAction = true;
+    }
+    const options = {
+        metadata,
+        contentType: _constants2.HTML_CONTENT_TYPE_HEADER
+    };
+    const tracker = initializeClientComponentLoadTracking(renderOpts, workStore);
+    metadata.clientComponentLoadTracker = tracker;
+    try {
         const stream = await renderToStream(// NOTE: in Cache Components (dev), if the render is restarted, it will use a different requestStore
         // than the one that we're passing in here.
-        requestStore, req, res, ctx, loaderTree, formState, postponedState, metadata, // If we're rendering HTML after an action, we don't want restartable-render behavior
+        requestStore, res, ctx, loaderTree, formState, postponedState, metadata, // If we're rendering HTML after an action, we don't want restartable-render behavior
         // because the result should be dynamic, like it is in prod.
         // 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, fallbackParams);
+        didExecuteServerAction ? undefined : createRequestStore, stagedFallbackParams, tracker);
         // Forward an invalid-dynamic-usage error recorded by `'use cache'` only
         // when userland caught it (try/catch around the cache call). If userland
         // didn't catch, the rejection propagated into the React render, and React's
@@ -1796,50 +1858,80 @@ async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOp
             }
         }
         // Create the new render result for the response.
-        return new _renderresult.default(stream, options);
+        const result = new _renderresult.default(stream, options);
+        if (setDevIsrStatus && process.env.NEXT_RUNTIME !== 'edge') {
+            result.pipeThrough(new TransformStream({
+                flush () {
+                    setDevIsrStatus(url.pathname, !requestStore.usedDynamic && !workStore.forceDynamic);
+                }
+            }));
+        }
+        return result;
+    } catch (renderError) {
+        // Returning a stream may precede SSR readiness, which finishes success.
+        // Only failures finish here; a finally would seal successful renders early.
+        tracker == null ? void 0 : tracker.finish();
+        throw renderError;
+    }
+}
+async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, postponedState, dev, sharedContext, interpolatedParams, fallbackRouteParams, routeMatch) {
+    if (renderOpts.ComponentMod.__next_app__) {
+        installGlobalModuleLoadingHandlers(renderOpts.ComponentMod, renderOpts.cacheComponents);
     }
+    const prepared = await prepareAppPageRender(req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, sharedContext, interpolatedParams, fallbackRouteParams, routeMatch, generateRenderRequestId, (0, _createtransporttreefromloadertree.getMissingPrefetchHintPolicy)(renderOpts.isBuildTimePrerendering ?? false, false, renderOpts.cacheComponents), {
+        isPossiblyPartialResponse: false,
+        supportsPerSegmentPrefetching: renderOpts.cacheComponents
+    });
+    return renderAppPage(prepared, postponedState, dev);
 }
-const renderToHTMLOrFlight = (req, res, pagePath, query, fallbackRouteParams, renderOpts, serverComponentsHmrCache, sharedContext)=>{
-    var _renderOpts_previewProps;
+async function prerenderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, sharedContext, interpolatedParams, fallbackRouteParams, routeMatch) {
+    if (renderOpts.ComponentMod.__next_app__) {
+        installGlobalModuleLoadingHandlers(renderOpts.ComponentMod, renderOpts.cacheComponents);
+    }
+    const isRoutePPREnabled = renderOpts.experimental.isRoutePPREnabled === true;
+    const prepared = await prepareAppPageRender(req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, sharedContext, interpolatedParams, fallbackRouteParams, routeMatch, generatePrerenderRequestId, (0, _createtransporttreefromloadertree.getMissingPrefetchHintPolicy)(renderOpts.isBuildTimePrerendering ?? false, true, renderOpts.cacheComponents), {
+        isPossiblyPartialResponse: isRoutePPREnabled,
+        supportsPerSegmentPrefetching: true
+    });
+    return prerenderAppPage(prepared);
+}
+function prepareAppPage(req, pagePath, fallbackRouteParams, renderOpts) {
     if (!req.url) {
-        throw Object.defineProperty(new Error('Invalid URL'), "__NEXT_ERROR_CODE", {
-            value: "E182",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invalid URL');
     }
     const url = (0, _parserelativeurl.parseRelativeUrl)(req.url, undefined, false);
-    // We read these values from the request object as, in certain cases,
-    // base-server will strip them to opt into different rendering behavior.
-    const parsedRequestHeaders = parseRequestHeaders(req.headers, {
-        isRoutePPREnabled: renderOpts.experimental.isRoutePPREnabled === true,
-        previewModeId: (_renderOpts_previewProps = renderOpts.previewProps) == null ? void 0 : _renderOpts_previewProps.previewModeId
-    });
-    const { isPrefetchRequest, previouslyRevalidatedTags, nonce } = parsedRequestHeaders;
-    let interpolatedParams;
-    let postponedState = null;
+    const interpolatedParams = (0, _getdynamicparam.interpolateParallelRouteParams)(renderOpts.ComponentMod.routeModule.userland.loaderTree, renderOpts.params ?? {}, pagePath, fallbackRouteParams);
     // If provided, the postpone state should be parsed so it can be provided to
     // React.
+    let postponedState = null;
     if (typeof renderOpts.postponed === 'string') {
         if (fallbackRouteParams) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('postponed state should not be provided when fallback params are provided'), "__NEXT_ERROR_CODE", {
-                value: "E592",
-                enumerable: false,
-                configurable: true
-            });
+            if (!(0, _serveractionrequestmeta.getServerActionRequestMetadata)(req).isFetchAction) {
+                throw new _invarianterror.InvariantError('postponed state should not be provided when fallback params are provided');
+            }
+            // A fetch action with fallback params cannot render this page, so its
+            // React postponed state cannot be resumed. The RDC is still useful while
+            // executing cached functions in the action.
+            postponedState = {
+                type: _postponedstate.DynamicState.DATA,
+                renderResumeDataCache: (0, _postponedstate.parseResumeDataCacheFromPostponedState)(renderOpts.postponed, renderOpts.experimental.maxPostponedStateSizeBytes, renderOpts.experimental.disableResumeDataCacheCompression)
+            };
+        } else {
+            postponedState = (0, _postponedstate.parsePostponedState)(renderOpts.postponed, renderOpts.experimental.maxPostponedStateSizeBytes, renderOpts.experimental.disableResumeDataCacheCompression);
         }
-        interpolatedParams = (0, _getdynamicparam.interpolateParallelRouteParams)(renderOpts.ComponentMod.routeModule.userland.loaderTree, renderOpts.params ?? {}, pagePath, fallbackRouteParams);
-        postponedState = (0, _postponedstate.parsePostponedState)(renderOpts.postponed, interpolatedParams, renderOpts.experimental.maxPostponedStateSizeBytes);
-    } else {
-        interpolatedParams = (0, _getdynamicparam.interpolateParallelRouteParams)(renderOpts.ComponentMod.routeModule.userland.loaderTree, renderOpts.params ?? {}, pagePath, fallbackRouteParams);
     }
     if ((postponedState == null ? void 0 : postponedState.renderResumeDataCache) && renderOpts.renderResumeDataCache) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('postponed state and dev warmup immutable resume data cache should not be provided together'), "__NEXT_ERROR_CODE", {
-            value: "E589",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('postponed state and dev warmup immutable resume data cache should not be provided together');
     }
+    return {
+        url,
+        interpolatedParams,
+        postponedState
+    };
+}
+const renderToHTMLOrFlight = (req, res, pagePath, query, fallbackRouteParams, renderOpts, dev, sharedContext, routeMatch, parsedRequestHeaders)=>{
+    const { url, interpolatedParams, postponedState } = prepareAppPage(req, pagePath, fallbackRouteParams, renderOpts);
+    const { isPrefetchRequest, previouslyRevalidatedTags, nonce } = parsedRequestHeaders;
     const workStore = (0, _workstore.createWorkStore)({
         page: renderOpts.routeModule.definition.page,
         renderOpts,
@@ -1850,9 +1942,22 @@ const renderToHTMLOrFlight = (req, res, pagePath, query, fallbackRouteParams, re
         previouslyRevalidatedTags,
         nonce
     });
-    return _workasyncstorageexternal.workAsyncStorage.run(workStore, // The function to run
-    renderToHTMLOrFlightImpl, // all of it's args
-    req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, postponedState, serverComponentsHmrCache, sharedContext, interpolatedParams, fallbackRouteParams);
+    return _workasyncstorageexternal.workAsyncStorage.run(workStore, renderToHTMLOrFlightImpl, req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, postponedState, dev, sharedContext, interpolatedParams, fallbackRouteParams, routeMatch);
+};
+const prerenderToHTMLOrFlight = (req, res, pagePath, query, fallbackRouteParams, renderOpts, _dev, sharedContext, routeMatch, parsedRequestHeaders)=>{
+    const { url, interpolatedParams } = prepareAppPage(req, pagePath, fallbackRouteParams, renderOpts);
+    const { isPrefetchRequest, previouslyRevalidatedTags, nonce } = parsedRequestHeaders;
+    const workStore = (0, _workstore.createPrerenderWorkStore)({
+        page: renderOpts.routeModule.definition.page,
+        renderOpts,
+        // @TODO move to workUnitStore of type Request
+        isPrefetchRequest,
+        buildId: sharedContext.buildId,
+        deploymentId: sharedContext.deploymentId,
+        previouslyRevalidatedTags,
+        nonce
+    });
+    return _workasyncstorageexternal.workAsyncStorage.run(workStore, prerenderToHTMLOrFlightImpl, req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, sharedContext, interpolatedParams, fallbackRouteParams, routeMatch);
 };
 function applyMetadataFromPrerenderResult(response, metadata, workStore) {
     if (response.collectedTags) {
@@ -1872,8 +1977,8 @@ function applyMetadataFromPrerenderResult(response, metadata, workStore) {
     } else {
         // Copy the cache control value onto the render result metadata.
         metadata.cacheControl = {
-            revalidate: response.collectedRevalidate >= _constants1.INFINITE_CACHE ? false : response.collectedRevalidate,
-            expire: response.collectedExpire >= _constants1.INFINITE_CACHE ? undefined : response.collectedExpire
+            revalidate: response.collectedRevalidate >= _constants2.INFINITE_CACHE ? false : response.collectedRevalidate,
+            expire: response.collectedExpire >= _constants2.INFINITE_CACHE ? undefined : response.collectedExpire
         };
     }
     // provide bailout info for debugging
@@ -1884,11 +1989,12 @@ function applyMetadataFromPrerenderResult(response, metadata, workStore) {
         };
     }
 }
-async function renderToStream(requestStore, req, res, ctx, tree, formState, postponedState, metadata, createRequestStore, fallbackParams) {
+async function renderToStream(requestStore, res, ctx, tree, formState, postponedState, metadata, createRequestStore, stagedFallbackParams, tracker) {
     /* eslint-disable @next/internal/no-ambiguous-jsx -- React Client */ // MARK: renderToStream setup
     const { assetPrefix, htmlRequestId, nonce, pagePath, renderOpts, requestId, workStore } = ctx;
     const { basePath, buildManifest, ComponentMod: { createElement }, crossOrigin, experimental, isBuildTimePrerendering = false, onInstrumentationRequestError, page, reactMaxHeadersLength, setReactDebugChannel, subresourceIntegrityManifest, supportsDynamicResponse, cacheComponents } = renderOpts;
     const { cachedNavigations } = renderOpts.experimental;
+    const waitForAllReady = supportsDynamicResponse !== true;
     const { ServerInsertedHTMLProvider, renderServerInsertedHTML } = (0, _serverinsertedhtml.createServerInsertedHTML)();
     const getServerInsertedMetadata = (0, _createserverinsertedmetadata.createServerInsertedMetadata)(nonce);
     const tracingMetadata = (0, _utils1.getTracedMetadata)((0, _tracer.getTracer)().getTracePropagationData(), experimental.clientTraceMetadata);
@@ -1928,10 +2034,14 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
     const renderSpan = (0, _tracer.getTracer)().startSpan(`render route (app) ${pagePath}`, {
         attributes: {
             'next.span_name': `render route (app) ${pagePath}`,
-            'next.span_type': _constants.AppRenderSpan.getBodyResult,
+            'next.span_type': _constants1.AppRenderSpan.getBodyResult,
             'next.route': pagePath
         }
     });
+    const finishHtmlRender = ()=>{
+        if (renderSpan.isRecording()) renderSpan.end();
+        tracker == null ? void 0 : tracker.finish();
+    };
     // Helper to end the span with error status (used when throwing from catch blocks)
     const endSpanWithError = (err)=>{
         if (!renderSpan.isRecording()) return;
@@ -1954,17 +2064,17 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
         let didErrorObservably = false;
         function onHTMLRenderRSCError(err, silenceLog) {
             didErrorObservably = true;
-            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'), silenceLog);
+            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, createRequestErrorContext(ctx, 'react-server-components'), silenceLog);
         }
         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.
             const silenceLog = false;
-            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'server-rendering'), silenceLog);
+            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, createRequestErrorContext(ctx, 'server-rendering'), silenceLog);
         }
         const allCapturedErrors = [];
-        const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, reactServerErrorsByDigest, allCapturedErrors, onHTMLRenderSSRError, renderSpan);
+        const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, ctx.renderOpts.experimental.reactBrowserBailout, reactServerErrorsByDigest, allCapturedErrors, onHTMLRenderSSRError, renderSpan);
         let reactServerResult = null;
         let reactDebugStream;
         const setHeader = res.setHeader.bind(res);
@@ -1974,11 +2084,16 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
             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) {
+                const prefetchMode = await getPrefetchingModeForPage(renderOpts, tree);
+                // We currently don't need the `ensureStatic` level here, but
+                // we want to validate that it's correct.
+                await (0, _ensurestatic.resolveEnsureStaticLevel)(tree, /* partialPrefetching */ prefetchMode === 2);
                 let debugChannelClientStream;
                 // 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
+                        is404: res.statusCode === 404,
+                        isPrerendering: false
                     });
                     if (isBypassingCachesInDev(requestStore, workStore)) {
                         // Mark the RSC payload to indicate that caches were bypassed in dev.
@@ -1999,8 +2114,6 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                 // "disable cache" in devtools, a hard refresh (cache-control: "no-cache"),
                 // or draft mode.
                 !isBypassingCachesInDev(requestStore, workStore)) {
-                    const loaderTree = ctx.componentMod.routeModule.userland.loaderTree;
-                    const prefetchMode = await getPrefetchingModeForPage(renderOpts, loaderTree);
                     const { stream: serverStream, debugChannel: returnedDebugChannel } = await stagedRenderWithCachesInDev({
                         prefetchMode,
                         ctx,
@@ -2009,7 +2122,7 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         getPayload,
                         onError: serverComponentsErrorHandler,
                         shouldValidate: true,
-                        fallbackRouteParams: fallbackParams,
+                        fallbackRouteParams: stagedFallbackParams,
                         getDevRenderDidError: ()=>didErrorObservably,
                         // An initial HTML load serves the static shell; runtime and
                         // dynamic content stream in afterward.
@@ -2051,16 +2164,16 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                 // hydration.
                 const selectStaleTime = (0, _staletime.createSelectStaleTime)(experimental);
                 const staleTimeIterable = new _staletime.StaleTimeIterable();
+                const prefetchMode = await getPrefetchingModeForPage(renderOpts, tree);
                 const stageController = new _stagedrendering.StagedRenderingController({
                     abortSignal: null,
                     abandonController: null,
-                    // 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.
-                    syncIO: _stagedrendering.SyncIOMode.Untracked,
+                    // Synchronous request-time data ends the static stage before its
+                    // result can enter the Cached Navigation.
+                    syncIO: getSyncIOMode(prefetchMode),
                     finalStage: null
                 });
-                requestStore.stale = _constants1.INFINITE_CACHE;
+                requestStore.stale = _constants2.INFINITE_CACHE;
                 requestStore.stagedRendering = stageController;
                 requestStore.asyncApiPromises = createAsyncApiPromises(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
                 requestStore.varyParamsAccumulator = (0, _varyparams.createResponseVaryParamsAccumulator)();
@@ -2068,31 +2181,41 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                 const shellByteLengthDeferred = (0, _promisewithresolvers.createPromiseWithResolvers)();
                 const staticStageByteLengthDeferred = (0, _promisewithresolvers.createPromiseWithResolvers)();
                 let runtimePrefetchStream;
+                let startRuntimePrefetchRender;
+                // Partial prefetching waits for cacheReady() before starting an
+                // embedded runtime prefetch. Track React's native immediates so that
+                // this wait includes Flight work that can discover more cache reads.
+                // Other prefetch modes do not wait for cacheReady() here.
+                const immediateTracker = prefetchMode === 2 ? new _fastsetimmediateexternal.ImmediateTracker() : null;
                 // If the route should runtime-cache its navigation, 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. This is enabled when
-                // Partial Prefetching is on for the route, either per segment (a
-                // `prefetch` of 'partial' or 'unstable_eager') or globally (the
-                // `partialPrefetching` config).
-                if (Boolean(renderOpts.partialPrefetching) || await (0, _instantconfig.anySegmentHasPartialPrefetchingEnabled)(tree)) {
-                    const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+                // runtime-prefetchable content during hydration. This is enabled for
+                // Partial Prefetching routes.
+                if (prefetchMode === 2) {
+                    const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)(// Prefill the mutable cache from the RDC if available.
+                    requestStore.resumeDataCache ?? undefined);
                     requestStore.resumeDataCache = prerenderResumeDataCache;
-                    const cacheSignal = new _cachesignal.CacheSignal();
+                    const cacheSignal = new _cachesignal.CacheSignal(immediateTracker);
                     (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));
+                    startRuntimePrefetchRender = async ()=>{
+                        await cacheSignal.cacheReady();
+                        return spawnRuntimePrefetchWithFilledCaches(runtimePrefetchTransform.writable, ctx, prerenderResumeDataCache, requestStore, serverComponentsErrorHandler);
+                    };
                 }
-                const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, {
+                const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, immediateTracker === null ? getRSCPayload : _fastsetimmediateexternal.runWithNativeImmediateTracking.bind(null, immediateTracker, getRSCPayload), tree, ctx, {
                     is404: res.statusCode === 404,
+                    isPrerendering: false,
                     staleTimeIterable,
                     shellByteLengthPromise: shellByteLengthDeferred.promise,
                     staticStageByteLengthPromise: staticStageByteLengthDeferred.promise,
                     runtimePrefetchStream
                 });
-                const flightStream = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+                const runRenderTasks = immediateTracker === null ? _apprenderrenderutils.runInSequentialTasks : _fastsetimmediateexternal.runWithNativeImmediateTracking.bind(null, immediateTracker, _apprenderrenderutils.runInSequentialTasks);
+                const flightStream = await runRenderTasks(()=>{
                     stageController.advanceStage(_stagedrendering.RenderStage.ShellStatic);
                     const stream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToNodeFlightStream, ctx.componentMod, RSCPayload, clientModules, {
                         onError: serverComponentsErrorHandler,
@@ -2106,9 +2229,8 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         shellByteLengthDeferred.resolve(byteLengths[_stagedrendering.RenderStage.ShellStatic]);
                     });
                     return dynamicStream;
-                }, ()=>{
-                    stageController.advanceStage(_stagedrendering.RenderStage.Static);
-                }, ()=>{
+                }, // Fold `PrefetchStatic_prefetchApi` into `PrefetchStatic` - no discrimination needed here
+                ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.NavigationStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>{
                     // This is a separate task that doesn't advance a stage. It forces
                     // draining the immediate queue so that the stale time iterable and vary
                     // params accumulators are flushed before we advance to the dynamic stage.
@@ -2116,16 +2238,16 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     if (requestStore.varyParamsAccumulator) {
                         (0, _varyparams.finishAccumulatingVaryParams)(requestStore.varyParamsAccumulator);
                     }
-                }, ()=>{
-                    stageController.advanceStage(_stagedrendering.RenderStage.Dynamic);
-                });
+                }, ()=>stageController.advanceStage(_stagedrendering.RenderStage.Dynamic));
+                void (startRuntimePrefetchRender == null ? void 0 : startRuntimePrefetchRender());
                 reactServerResult = new _apprenderprerenderutils.ReactServerResult(flightStream);
             } else {
                 // MARK: nodeStreams RSC
                 if (process.env.__NEXT_USE_NODE_STREAMS) {
                     // 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, {
-                        is404: res.statusCode === 404
+                        is404: res.statusCode === 404,
+                        isPrerendering: false
                     });
                     const debugChannel = setReactDebugChannel && (0, _debugchannelserver.createNodeDebugChannel)();
                     if (debugChannel) {
@@ -2144,7 +2266,8 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     // MARK: webStreams RSC
                     // 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, {
-                        is404: res.statusCode === 404
+                        is404: res.statusCode === 404,
+                        isPrerendering: false
                     });
                     const debugChannel = setReactDebugChannel && (0, _debugchannelserver.createWebDebugChannel)();
                     if (debugChannel) {
@@ -2175,8 +2298,8 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         // still include the new server component render because it was not included
                         // in the static prelude.
                         const inlinedDataStream = (0, _streamops.createNodeInlinedDataStream)(reactServerResult.tee(), nonce, formState);
-                        // End the span since there's no async rendering in this path
-                        if (renderSpan.isRecording()) renderSpan.end();
+                        // There's no async HTML rendering in this path.
+                        finishHtmlRender();
                         return (0, _streamops.chainStreams)(inlinedDataStream, (0, _streamops.createDocumentClosingStream)());
                     } else if (postponedState) {
                         // We assume we have dynamic HTML requiring a resume render to complete
@@ -2197,14 +2320,11 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                             basePath,
                             tracingMetadata: tracingMetadata
                         });
-                        const { stream: htmlStream, allReady } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.resumeToFizzStream, resumeAppElement, postponed, {
+                        const { stream: htmlStream } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.resumeToFizzStream, resumeAppElement, postponed, {
                             onError: htmlRendererErrorHandler,
+                            onAllReady: finishHtmlRender,
                             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.continueDynamicHTMLResumeNode)(htmlStream, {
                             delayDataUntilFirstHtmlChunk: preludeState === _postponedstate.DynamicHTMLPreludeState.Empty,
                             inlinedDataStream: (0, _streamops.createNodeInlinedDataStream)(reactServerResult.consume(), nonce, formState),
@@ -2222,7 +2342,6 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     basePath,
                     tracingMetadata: tracingMetadata
                 });
-                const generateStaticHTML = supportsDynamicResponse !== true;
                 const appElement = /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                     reactServerStream: reactServerResult.tee(),
                     // TODO: Pass Node.js debugStream
@@ -2235,6 +2354,7 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                 });
                 const fizzOptions = {
                     onError: htmlRendererErrorHandler,
+                    onAllReady: finishHtmlRender,
                     nonce,
                     onHeaders: (headers)=>{
                         for(const key in headers){
@@ -2248,16 +2368,12 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     ],
                     formState
                 };
-                const { stream: htmlStream, allReady } = await (0, _tracer.getTracer)().trace(_constants.AppRenderSpan.renderToNodeFizzStream, ()=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToNodeFizzStream, appElement, fizzOptions, {
-                        waitForAllReady: generateStaticHTML
+                const { stream: htmlStream, allReady } = await (0, _tracer.getTracer)().trace(_constants1.AppRenderSpan.renderToNodeFizzStream, ()=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToNodeFizzStream, appElement, fizzOptions, {
+                        waitForAllReady
                     }));
-                // 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.continueFizzStream)(htmlStream, {
                     inlinedDataStream: (0, _streamops.createNodeInlinedDataStream)(reactServerResult.consume(), nonce, formState),
-                    isStaticGeneration: generateStaticHTML,
+                    waitForAllReady,
                     allReady,
                     deploymentId: ctx.sharedContext.deploymentId,
                     getServerInsertedHTML,
@@ -2274,8 +2390,8 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         // still include the new server component render because it was not included
                         // in the static prelude.
                         const inlinedDataStream = (0, _streamops.createWebInlinedDataStream)(reactServerResult.tee(), nonce, formState);
-                        // End the span since there's no async rendering in this path
-                        if (renderSpan.isRecording()) renderSpan.end();
+                        // There's no async HTML rendering in this path.
+                        finishHtmlRender();
                         return (0, _streamops.chainStreams)(inlinedDataStream, (0, _streamops.createDocumentClosingStream)());
                     } else if (postponedState) {
                         // We assume we have dynamic HTML requiring a resume render to complete
@@ -2300,10 +2416,8 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                             onError: htmlRendererErrorHandler,
                             nonce
                         });
-                        // End the render span only after React completed rendering (including anything inside Suspense boundaries)
-                        allReady.finally(()=>{
-                            if (renderSpan.isRecording()) renderSpan.end();
-                        });
+                        // Finish after React renders everything inside Suspense boundaries.
+                        void allReady.then(finishHtmlRender, finishHtmlRender);
                         return await (0, _streamops.continueDynamicHTMLResumeWeb)(htmlStream, {
                             delayDataUntilFirstHtmlChunk: preludeState === _postponedstate.DynamicHTMLPreludeState.Empty,
                             inlinedDataStream: (0, _streamops.createWebInlinedDataStream)(reactServerResult.consume(), nonce, formState),
@@ -2321,7 +2435,6 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     basePath,
                     tracingMetadata: tracingMetadata
                 });
-                const generateStaticHTML = supportsDynamicResponse !== true;
                 const appElement = /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
                     reactServerStream: reactServerResult.tee(),
                     reactDebugStream: reactDebugStream,
@@ -2347,13 +2460,11 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     formState
                 };
                 const { stream: htmlStream, allReady } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToWebFizzStream, appElement, fizzOptions);
-                // End the render span only after React completed rendering (including anything inside Suspense boundaries)
-                allReady.finally(()=>{
-                    if (renderSpan.isRecording()) renderSpan.end();
-                });
+                // Finish after React renders everything inside Suspense boundaries.
+                void allReady.then(finishHtmlRender, finishHtmlRender);
                 return await (0, _streamops.continueFizzStream)(htmlStream, {
                     inlinedDataStream: (0, _streamops.createWebInlinedDataStream)(reactServerResult.consume(), nonce, formState),
-                    isStaticGeneration: generateStaticHTML,
+                    waitForAllReady,
                     allReady,
                     deploymentId: ctx.sharedContext.deploymentId,
                     getServerInsertedHTML,
@@ -2428,8 +2539,7 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     throw setupErr;
                 }
                 try {
-                    const generateStaticHTML = supportsDynamicResponse !== true;
-                    const { stream: errorHtmlStream, allReady: errorAllReady } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToNodeFizzStream, /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
+                    const { stream: errorHtmlStream } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToNodeFizzStream, /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
                         reactServerStream: errorServerStream,
                         ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                         preinitScripts: errorPreinitScripts,
@@ -2441,19 +2551,17 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         bootstrapScripts: [
                             errorBootstrapScript
                         ],
-                        formState
+                        formState,
+                        onAllReady: finishHtmlRender
                     }, {
-                        waitForAllReady: generateStaticHTML
-                    });
-                    errorAllReady.finally(()=>{
-                        if (renderSpan.isRecording()) renderSpan.end();
+                        waitForAllReady
                     });
                     return await (0, _streamops.continueFizzStream)(errorHtmlStream, {
                         inlinedDataStream: (0, _streamops.createNodeInlinedDataStream)(// 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,
+                        waitForAllReady,
                         deploymentId: ctx.sharedContext.deploymentId,
                         getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
                             polyfills,
@@ -2493,7 +2601,6 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                     throw setupErr;
                 }
                 try {
-                    const generateStaticHTML = supportsDynamicResponse !== true;
                     const { stream: errorHtmlStream, allReady: errorAllReady } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _streamops.renderToWebFizzStream, /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
                         reactServerStream: errorServerStream,
                         ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
@@ -2508,15 +2615,14 @@ async function renderToStream(requestStore, req, res, ctx, tree, formState, post
                         ],
                         formState
                     });
-                    errorAllReady.finally(()=>{
-                        if (renderSpan.isRecording()) renderSpan.end();
-                    });
+                    // Finish after React renders the error document.
+                    void errorAllReady.then(finishHtmlRender, finishHtmlRender);
                     return await (0, _streamops.continueFizzStream)(errorHtmlStream, {
                         inlinedDataStream: (0, _streamops.createWebInlinedDataStream)(// 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,
+                        waitForAllReady,
                         deploymentId: ctx.sharedContext.deploymentId,
                         getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
                             polyfills,
@@ -2600,7 +2706,7 @@ const alreadyForwardedDynamicUsageErrors = new WeakSet();
             // Read whether the streamed render errored only now that it has fully
             // settled.
             const devRenderDidError = getDevRenderDidError();
-            const [instantInputs, staticInputs] = await runSpan(_constants.AppRenderSpan.instantInsightsPrepareValidation, 'Prepare validation inputs', async ()=>{
+            const [instantInputs, staticInputs] = await runSpan(_constants1.AppRenderSpan.instantInsightsPrepareValidation, 'Prepare validation inputs', async ()=>{
                 const lazyInputs = await prepareValidationInputs(prefetchMode, navigationKind, result, requestStore, validationDebugChannel, ctx, prerenderResumeDataCache, createRequestStore, getPayload, onError, validationAbortSignal);
                 // If we need to do multiple renders, do them in parallel.
                 // `runValidationInDev` currently needs `instantInputs` eagerly
@@ -2623,7 +2729,7 @@ const alreadyForwardedDynamicUsageErrors = new WeakSet();
                 logValidationAborted(ctx);
                 return;
             }
-            return runSpan(_constants.AppRenderSpan.instantInsightsRunValidation, 'Run validation', async ()=>{
+            return runSpan(_constants1.AppRenderSpan.instantInsightsRunValidation, 'Run validation', async ()=>{
                 // Hand the whole validation to the worker when one is installed. It
                 // runs on a worker thread (off the main thread), emits its own
                 // lifecycle markers, logs code frames on its piped stdio, and
@@ -2640,11 +2746,7 @@ const alreadyForwardedDynamicUsageErrors = new WeakSet();
                     if (chunks && !validationAbortSignal.aborted) {
                         const { sendErrorsToBrowser } = ctx.renderOpts;
                         if (!sendErrorsToBrowser) {
-                            throw Object.defineProperty(new _invarianterror.InvariantError('Expected `sendErrorsToBrowser` to be defined in renderOpts.'), "__NEXT_ERROR_CODE", {
-                                value: "E947",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new _invarianterror.InvariantError('Expected `sendErrorsToBrowser` to be defined in renderOpts.');
                         }
                         sendErrorsToBrowser((0, _streamutils.createNodeStreamFromChunks)(chunks), ctx.htmlRequestId);
                     }
@@ -2673,12 +2775,8 @@ const alreadyForwardedDynamicUsageErrors = new WeakSet();
         if (validationAbortSignal.aborted) {
             return;
         }
-        console.error(Object.defineProperty(new _invarianterror.InvariantError('An unexpected error occurred during validation', {
+        console.error(new _invarianterror.InvariantError('An unexpected error occurred during validation', {
             cause: err
-        }), "__NEXT_ERROR_CODE", {
-            value: "E1393",
-            enumerable: false,
-            configurable: true
         }));
     }).finally(()=>validationGeneration.finish());
 }
@@ -2710,7 +2808,7 @@ async function runInstantInsightsWithTracing(ctx, fn) {
             attributes: {
                 'next.span_category': 'nextjs',
                 'next.span_name': 'Instant Insights',
-                'next.span_type': _constants.AppRenderSpan.instantInsights,
+                'next.span_type': _constants1.AppRenderSpan.instantInsights,
                 'next.route': ctx.pagePath
             }
         }, ()=>fn(runInstantInsightsSpan)));
@@ -2756,19 +2854,53 @@ async function prepareValidationInputs(prefetchMode, navigationKind, result, req
 async function prepareValidationInputsInPartialPrefetching(navigationKind, requestStore, ctx, prerenderResumeDataCache, createRequestStore, getPayload, onError, inputsFromNavigation, validationAbortSignal) {
     const loaderTree = ctx.componentMod.routeModule.userland.loaderTree;
     const needsInstantValidation = await (0, _instantconfig.anySegmentNeedsInstantValidationInDev)(loaderTree);
-    // If we have static params that aren't root params, then the static stages are incompatible
-    // between the Static shell and the App Shell, and we can't use the same render for both.
-    const areStagesCompatible = !(0, _paramsutils.hasNonRootStaticParams)(ctx.interpolatedParams, requestStore.rootParams, requestStore.fallbackParams);
+    const ensureStaticLevel = await (0, _ensurestatic.resolveEnsureStaticLevel)(loaderTree, /* partialPrefetching */ true);
+    // PPF uses runtime shells by default, but this can be overridden with `ensureStatic`.
+    const appShellStage = ensureStaticLevel >= _ensurestatic.EnsureStaticLevel.Shell ? _stagedrendering.RenderStage.ShellStatic : _stagedrendering.RenderStage.ShellRuntime;
+    // Certain APIs resolve in either static or runtime stages depending on the context.
+    // (see `needsRuntimeShell` and callsites of `trackIncompatibleShellContent`)
+    // This includes:
+    // - static `params`
+    // - `navigation()` and `prefetch()`
+    // - caches with `stale < MIN_SHELL_STALE` are excluded from app shells
+    //   but are included in static prerenders
+    // If one of these APIs is used, the render can't be used for both Instant Validation and
+    // Static Shell Validation and we'll need to perform a secondary render.
+    //
+    // Note that a cache miss *also* sets this, because otherwise we might not
+    // have accurate tracking, especially for short-stale caches.
+    // This prevents us from using the same rerender for both validations
+    // if there's a chance that the cache miss might be hiding incompatible data.
+    const canRecoverStaticAndRuntimeShell = !requestStore.hasIncompatibleShellContent;
+    let needsRuntimeAppShell;
+    let canRecoverAppShellFromNavigation;
+    switch(appShellStage){
+        case _stagedrendering.RenderStage.ShellStatic:
+            {
+                // `ShellStatic` can be recovered from any render, because
+                // none of the divergent APIs affect this stage.
+                needsRuntimeAppShell = false;
+                canRecoverAppShellFromNavigation = true;
+                break;
+            }
+        case _stagedrendering.RenderStage.ShellRuntime:
+            {
+                needsRuntimeAppShell = true;
+                // `ShellRuntime` can be recovered if the render has a runtime shell
+                // or if it doesn't use APIs that cause stages to diverge.
+                canRecoverAppShellFromNavigation = navigationHasRuntimeShell(navigationKind) || canRecoverStaticAndRuntimeShell;
+                break;
+            }
+    }
     const LAZY_FULL_RENDER = createLazyDevValidationInputs(async ()=>{
-        const shouldRenderWithAppShell = true;
         const prefetchMode = 2;
-        const inputs = await renderWithWarmCachesForValidationInDev(ctx, createRequestStore, getPayload, onError, prerenderResumeDataCache, prefetchMode, shouldRenderWithAppShell, validationAbortSignal);
+        const inputs = await renderWithWarmCachesForValidationInDev(ctx, createRequestStore, getPayload, onError, prerenderResumeDataCache, prefetchMode, needsRuntimeAppShell, validationAbortSignal);
         if (forwardErrorsFromWarmRender(inputs, ctx)) {
             return VALIDATION_BAILOUT;
         }
         return inputs;
     });
-    const LAZY_RUNTIME_PRERENDER = createLazyDevValidationInputs(async ()=>{
+    const LAZY_RUNTIME_PRERENDER_WITH_STATIC_SHELL = createLazyDevValidationInputs(async ()=>{
         const inputs = await prerenderWithWarmCachesForStaticValidationInDev(ctx, createRequestStore, getPayload, onError, prerenderResumeDataCache, validationAbortSignal);
         if (forwardErrorsFromWarmRender(inputs, ctx)) {
             return VALIDATION_BAILOUT;
@@ -2776,46 +2908,30 @@ async function prepareValidationInputsInPartialPrefetching(navigationKind, reque
         return inputs;
     });
     if (inputsFromNavigation) {
-        // We can reuse the main render for at least one of the validation passes.
-        if (areStagesCompatible) {
-            // Stages are compatible across the static shell and the app shell.
-            // We reuse the main render for both.
-            const instantInputs = needsInstantValidation ? inputsFromNavigation : null;
-            const staticInputs = inputsFromNavigation;
-            return {
-                instantInputs,
-                staticInputs
-            };
-        }
-        // Stages are incompatible across static and instant validation.
-        // If this navigation has an accurate app shell, we can use it for instant validation.
-        // However, static validation can't use this static stage, so we need to prerender it.
-        if (navigationHasAppShell(navigationKind)) {
-            const instantInputs = needsInstantValidation ? inputsFromNavigation : null;
-            const staticInputs = LAZY_RUNTIME_PRERENDER;
-            return {
-                instantInputs,
-                staticInputs
-            };
-        }
-        // This navigation does not have an accurate app shell, so if we need instant validation, we need to render again.
-        // However, this means that it has an accurate static shell, so we can skip prerendering it.
+        // We might be able to reuse the main render for at least one of the validation passes.
+        // If the navigation has the kind of shell we need, re-use it for Instant Validation.
+        // Otherwise, perform a full render with the kind of shell we need.
+        const instantInputs = !needsInstantValidation ? null : canRecoverAppShellFromNavigation ? inputsFromNavigation : LAZY_FULL_RENDER;
+        const staticInputs = // If the navigation has the correct static stage, reuse it for Static Shell Validation.
+        !navigationHasRuntimeShell(navigationKind) || canRecoverStaticAndRuntimeShell ? inputsFromNavigation : // (this avoids two separate rerenders if the navigation had a runtime app shell
+        // but `canRecoverStaticAndRuntimeShell === false` and we're doing a full rerender)
+        instantInputs && !needsRuntimeAppShell ? instantInputs : // which we need for discriminated errors)
+        LAZY_RUNTIME_PRERENDER_WITH_STATIC_SHELL;
+        return {
+            instantInputs,
+            staticInputs
+        };
+    } else {
+        // We cannot reuse the main navigation, and need to render again.
         const instantInputs = needsInstantValidation ? LAZY_FULL_RENDER : null;
-        const staticInputs = inputsFromNavigation;
+        // If stages are compatible and we'll rerender for instant validation,
+        // we can reuse the result for static validation.
+        const staticInputs = instantInputs && (!needsRuntimeAppShell || canRecoverStaticAndRuntimeShell) ? instantInputs : LAZY_RUNTIME_PRERENDER_WITH_STATIC_SHELL;
         return {
             instantInputs,
             staticInputs
         };
     }
-    // We cannot reuse the main navigation, and need to render again.
-    // If stages are compatible and we'll rerender for instant validation,
-    // we can reuse the result for static validation.
-    const instantInputs = needsInstantValidation ? LAZY_FULL_RENDER : null;
-    const staticInputs = areStagesCompatible && instantInputs !== null ? instantInputs : LAZY_RUNTIME_PRERENDER;
-    return {
-        instantInputs,
-        staticInputs
-    };
 }
 async function prepareValidationInputsInLegacyPrefetching(ctx, prerenderResumeDataCache, createRequestStore, getPayload, onError, inputsFromNavigation, validationAbortSignal) {
     const loaderTree = ctx.componentMod.routeModule.userland.loaderTree;
@@ -2832,9 +2948,9 @@ async function prepareValidationInputsInLegacyPrefetching(ctx, prerenderResumeDa
         };
     }
     const LAZY_FULL_RENDER = createLazyDevValidationInputs(async ()=>{
-        const shouldRenderWithAppShell = false;
+        const shouldRenderWithRuntimeShell = false;
         const prefetchMode = 1;
-        const inputs = await renderWithWarmCachesForValidationInDev(ctx, createRequestStore, getPayload, onError, prerenderResumeDataCache, prefetchMode, shouldRenderWithAppShell, validationAbortSignal);
+        const inputs = await renderWithWarmCachesForValidationInDev(ctx, createRequestStore, getPayload, onError, prerenderResumeDataCache, prefetchMode, shouldRenderWithRuntimeShell, validationAbortSignal);
         if (forwardErrorsFromWarmRender(inputs, ctx)) {
             return VALIDATION_BAILOUT;
         }
@@ -2879,7 +2995,10 @@ async function resolveLazyDevValidationInputs(resolvedOrLazyInputs, ctx) {
     if ('syncInterruptReason' in inputs) {
         await logMessagesAndSendErrorsToBrowser([
             inputs.syncInterruptReason
-        ], ctx);
+        ], ctx, // We're not going to run validation, so mark this as the validation result for tests.
+        {
+            logAsValidationResult: true
+        });
         return VALIDATION_BAILOUT;
     }
     return inputs;
@@ -2888,7 +3007,10 @@ function forwardErrorsFromWarmRender(inputs, ctx) {
     if ('syncInterruptReason' in inputs) {
         void logMessagesAndSendErrorsToBrowser([
             inputs.syncInterruptReason
-        ], ctx);
+        ], ctx, // We're not going to run validation, so mark this as the validation result for tests.
+        {
+            logAsValidationResult: true
+        });
         return true;
     }
     // Unlike the cold streamed render, which fills the caches, the warm
@@ -2908,7 +3030,6 @@ var PrefetchingMode = /*#__PURE__*/ function(PrefetchingMode) {
 }({});
 async function getPrefetchingModeForPage(renderOpts, loaderTree) {
     const debug = process.env.NEXT_PRIVATE_DEBUG_VALIDATION === '1' ? console.log : undefined;
-    // TODO(app-shells): support "unstable_eager"
     if (renderOpts.partialPrefetching) {
         debug == null ? void 0 : debug('using prefetching mode Partial because of next.config.js');
         return 2;
@@ -2934,8 +3055,8 @@ function getSyncIOMode(prefetchMode) {
  * cache, async API promises, and a staged rendering controller, all wired into
  * the request store.
  */ function setUpStagedDevRender(prefetchingMode, navigationKind, requestStore) {
-    const shouldRenderWithAppShell = navigationHasAppShell(navigationKind);
-    const cacheSignal = new _cachesignal.CacheSignal();
+    const shouldRenderWithRuntimeShell = navigationHasRuntimeShell(navigationKind);
+    const cacheSignal = new _cachesignal.CacheSignal(null);
     (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
     const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
     const stageController = new _stagedrendering.StagedRenderingController({
@@ -2946,7 +3067,8 @@ function getSyncIOMode(prefetchMode) {
     });
     requestStore.resumeDataCache = prerenderResumeDataCache;
     requestStore.stagedRendering = stageController;
-    requestStore.needsSessionShell = shouldRenderWithAppShell;
+    requestStore.needsRuntimeShell = shouldRenderWithRuntimeShell;
+    requestStore.hasIncompatibleShellContent = false;
     requestStore.asyncApiPromises = createAsyncApiPromises(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
     requestStore.cacheSignal = cacheSignal;
     const environmentName = ()=>getEnvironmentNameForStage(stageController.currentStage);
@@ -2961,27 +3083,46 @@ function getEnvironmentNameForStage(stage) {
     switch(stage){
         case _stagedrendering.RenderStage.Before:
         case _stagedrendering.RenderStage.ShellStatic:
+        case _stagedrendering.RenderStage.PrefetchStatic_prefetchApi:
+        case _stagedrendering.RenderStage.PrefetchStatic:
+        case _stagedrendering.RenderStage.NavigationStatic:
         case _stagedrendering.RenderStage.Static:
             return 'Prerender';
         case _stagedrendering.RenderStage.ShellRuntime:
-        case _stagedrendering.RenderStage.Runtime:
+        case _stagedrendering.RenderStage.PrefetchRuntime_prefetchApi:
+        case _stagedrendering.RenderStage.PrefetchRuntime:
+        case _stagedrendering.RenderStage.NavigationRuntime:
             return 'Prefetch';
         case _stagedrendering.RenderStage.Dynamic:
         case _stagedrendering.RenderStage.Abandoned:
             return 'Server';
         default:
             stage;
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
-                value: "E881",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Invalid render stage: ${stage}`);
     }
 }
-function navigationHasAppShell(navigationKind) {
-    // TODO(app-shells): when we implement `<Link prefetch={true}>/`prefetch = "unstable_eager"` in dev,
-    // this might need to be adjusted, because we'll use `Runtime` for the stage
-    return navigationKind.type === 'prefetched-client' && navigationKind.prefetchStage === _stagedrendering.RenderStage.ShellRuntime;
+function navigationHasRuntimeShell(navigationKind) {
+    switch(navigationKind.type){
+        case 'initial-load':
+            {
+                return false;
+            }
+        case 'prefetched-client':
+            {
+                switch(navigationKind.prefetchStage){
+                    case _stagedrendering.RenderStage.ShellStatic:
+                    case _stagedrendering.RenderStage.Static:
+                        {
+                            return false;
+                        }
+                    case _stagedrendering.RenderStage.ShellRuntime:
+                    case _stagedrendering.RenderStage.PrefetchRuntime:
+                        {
+                            return true;
+                        }
+                }
+            }
+    }
 }
 /**
  * Streams a staged dev render to completion without ever abandoning it, so it
@@ -2995,7 +3136,7 @@ function navigationHasAppShell(navigationKind) {
  * The chunks are accumulated eagerly because detecting completion requires
  * reading the whole stream anyway; the same accumulation feeds validation when
  * the render turns out to be prod-representative.
- */ async function streamStagedRenderInDev({ ctx, requestStore, rscPayload, stageController, cacheSignal, environmentName, onError, debugChannel, navigationKind, requestAbortSignal }) {
+ */ async function streamStagedRenderInDev({ prefetchMode, ctx, requestStore, rscPayload, stageController, cacheSignal, environmentName, onError, debugChannel, navigationKind, requestAbortSignal }) {
     let holdStreamUntilRevealed;
     let revealAfterStage;
     switch(navigationKind.type){
@@ -3026,7 +3167,7 @@ function navigationHasAppShell(navigationKind) {
     // earlier on a cache miss). When streaming live (a client navigation), it's
     // surfaced through the Flight payload as `_revealAfter`: the client decodes
     // it and defers resolving the response's deferred RSCs on it (see
-    // `ppr-navigations`), so a Suspense boundary's children aren't revealed
+    // `render-tree`), so a Suspense boundary's children aren't revealed
     // before their row has been decoded, which would flush a premature fallback.
     // React serializes the promise as a pending row whose resolution row is
     // emitted only when we resolve it here, and that row follows the children's
@@ -3048,6 +3189,7 @@ function navigationHasAppShell(navigationKind) {
     // is reported at most once, and only for a read that's still pending while a
     // shell stage is flushing (see `checkForCacheMiss`).
     let reportedColdCache = false;
+    let trackedIncompatibleShellContent = false;
     // Runs at each stage boundary. Latches the running cache-miss verdict and
     // returns it, so a boundary can reveal the shell as soon as a miss is seen
     // (and so dev validation can later tell whether the streamed render is
@@ -3056,6 +3198,31 @@ function navigationHasAppShell(navigationKind) {
     const checkForCacheMiss = ()=>{
         if (cacheSignal.hasPendingReads()) {
             hadCacheMiss = true;
+            if (prefetchMode === 2) {
+                // If we had a cache miss (and we'll need an app shell for validation),
+                // we *may* have content that is incompatible between an app shell and a static shell:
+                //
+                // - A cache miss might defer content to a stage where it is no longer
+                //   considered incompatible and would not be tracked as such
+                // - Caches with `stale < MIN_SHELL_STALE` should be excluded from app shells,
+                //   but included in static prerenders (which we can only do when the cache
+                //   is a hit and its cache life is known)
+                //
+                // We need to signal this to `prepareValidationInputsInPartialPrefetching`.
+                // It would not re-use a render with a cache miss anyway, but it tries to
+                // optimize the follow-up rerenders into a single one based on whether
+                // stages are compatible, and we can't do that if they *might* use incompatible
+                // data due to a cache miss.
+                //
+                // TODO(app-shells): optimize this (and other `trackIncompatibleShellContent`
+                // callsites) to only consider stages that are relevant for validation.
+                if (trackedIncompatibleShellContent) {
+                // It's enough to report the first miss.
+                } else {
+                    trackedIncompatibleShellContent = true;
+                    (0, _dynamicrenderingutils.trackIncompatibleShellContent)(requestStore, 'cache miss during main render');
+                }
+            }
             // The cold-cache indicator reflects the shell only. A cache read still
             // pending while a shell stage flushes (`currentStage <=
             // revealAfterStage`, using the ordered `RenderStage` values) is part of
@@ -3102,7 +3269,7 @@ function navigationHasAppShell(navigationKind) {
             // for the stream to close.
             requestAbortSignal ?? null)
         });
-    }, ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.Static), ()=>checkReveal(_stagedrendering.RenderStage.Static), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.ShellRuntime), ()=>checkReveal(_stagedrendering.RenderStage.ShellRuntime), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.Runtime), ()=>checkReveal(_stagedrendering.RenderStage.Runtime), ()=>{
+    }, ()=>checkReveal(_stagedrendering.RenderStage.ShellStatic), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.PrefetchStatic_prefetchApi), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.PrefetchStatic), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.NavigationStatic), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.Static), ()=>checkReveal(_stagedrendering.RenderStage.Static), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.ShellRuntime), ()=>checkReveal(_stagedrendering.RenderStage.ShellRuntime), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.PrefetchRuntime_prefetchApi), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.PrefetchRuntime), ()=>checkReveal(_stagedrendering.RenderStage.PrefetchRuntime), ()=>checkCacheMissAndAdvance(_stagedrendering.RenderStage.NavigationRuntime), ()=>{
         // Advance to the dynamic stage even while caches are still filling, so
         // dynamic content streams to the browser right away instead of being
         // withheld until the slowest cache fill completes. Streaming that content
@@ -3167,13 +3334,14 @@ function navigationHasAppShell(navigationKind) {
     };
 }
 function getStageEndTimes(stageController) {
-    return {
-        [_stagedrendering.RenderStage.Static]: stageController.getStageEndTime(_stagedrendering.RenderStage.Static),
-        [_stagedrendering.RenderStage.ShellRuntime]: stageController.getStageEndTime(_stagedrendering.RenderStage.ShellRuntime),
-        [_stagedrendering.RenderStage.Runtime]: stageController.getStageEndTime(_stagedrendering.RenderStage.Runtime)
-    };
+    const result = {};
+    for (const stage of _stagedrendering.RENDER_STAGE_ADVANCE_ORDER){
+        if (stage === _stagedrendering.RenderStage.Dynamic) break;
+        result[stage] = stageController.getStageEndTime(stage);
+    }
+    return result;
 }
-async function renderWithWarmCachesForValidationInDev(ctx, createRequestStore, getPayload, onError, prerenderResumeDataCache, prefetchMode, shouldRenderWithAppShell, validationAbortSignal) {
+async function renderWithWarmCachesForValidationInDev(ctx, createRequestStore, getPayload, onError, prerenderResumeDataCache, prefetchMode, shouldRenderWithRuntimeShell, validationAbortSignal) {
     const { ComponentMod, setReactDebugChannel } = ctx.renderOpts;
     const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     const stageController = new _stagedrendering.StagedRenderingController({
@@ -3185,7 +3353,8 @@ async function renderWithWarmCachesForValidationInDev(ctx, createRequestStore, g
     const requestStore = createRequestStore();
     requestStore.resumeDataCache = (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache);
     requestStore.stagedRendering = stageController;
-    requestStore.needsSessionShell = shouldRenderWithAppShell;
+    requestStore.needsRuntimeShell = shouldRenderWithRuntimeShell;
+    requestStore.hasIncompatibleShellContent = false;
     requestStore.cacheSignal = null;
     requestStore.asyncApiPromises = createAsyncApiPromises(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
     const debugChannel = setReactDebugChannel && (0, _debugchannelserver.createNodeDebugChannel)();
@@ -3204,7 +3373,7 @@ async function renderWithWarmCachesForValidationInDev(ctx, createRequestStore, g
             signal: validationAbortSignal
         });
         return accumulateStreamChunks(sourceStream, stageController, validationAbortSignal);
-    }, ()=>stageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>stageController.advanceStage(_stagedrendering.RenderStage.ShellRuntime), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Runtime), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Dynamic));
+    }, ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic_prefetchApi), ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.NavigationStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>stageController.advanceStage(_stagedrendering.RenderStage.ShellRuntime), ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchRuntime_prefetchApi), ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchRuntime), ()=>stageController.advanceStage(_stagedrendering.RenderStage.NavigationRuntime), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Dynamic));
     const syncInterruptReason = stageController.getSyncInterruptReason();
     if (syncInterruptReason) {
         // Sync IO interrupted the render, so it won't be validated. Drop the debug
@@ -3229,7 +3398,7 @@ async function prerenderWithWarmCachesForStaticValidationInDev(ctx, createReques
     const { ComponentMod, setReactDebugChannel } = ctx.renderOpts;
     const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     // This render is for validation only, and won't be shown to the user,
-    // so we're only rendering until the runtime stage
+    // so we're only rendering until the PrefetchRuntime stage
     // (we need static chunks and runtime chunks for discriminated errors)
     const finalReactController = new AbortController();
     const finalDataController = new AbortController();
@@ -3238,15 +3407,16 @@ async function prerenderWithWarmCachesForStaticValidationInDev(ctx, createReques
         abortSignal: finalDataController.signal,
         abandonController: null,
         syncIO: getSyncIOMode(prefetchMode),
-        finalStage: _stagedrendering.RenderStage.Runtime
+        finalStage: _stagedrendering.RenderStage.PrefetchRuntime
     });
     const requestStore = createRequestStore();
     requestStore.resumeDataCache = (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache);
     requestStore.stagedRendering = stageController;
-    requestStore.needsSessionShell = false;
+    requestStore.needsRuntimeShell = false;
+    requestStore.hasIncompatibleShellContent = false;
     requestStore.cacheSignal = null;
     requestStore.asyncApiPromises = createAsyncApiPromises(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
-    // We abort upon reaching the runtime stage or on Sync IO.
+    // We abort upon reaching the PrefetchRuntime stage or on 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;
@@ -3277,8 +3447,9 @@ async function prerenderWithWarmCachesForStaticValidationInDev(ctx, createReques
         abortWhenSignalAborts(finalReactController.signal, finalDataController);
         // Note: this await will only resolve after the last task (unless sync IO aborts the render earlier)
         await iterateStreamingPrerenderChunks(sourceStream, finalReactController.signal, collectChunk);
-    }, ()=>stageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>stageController.advanceStage(_stagedrendering.RenderStage.ShellRuntime), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Runtime), ()=>{
-        // Do not advance to the dynamic stage, abort instead.
+    }, ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic_prefetchApi), ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.NavigationStatic), ()=>stageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>stageController.advanceStage(_stagedrendering.RenderStage.ShellRuntime), ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchRuntime_prefetchApi), ()=>stageController.advanceStage(_stagedrendering.RenderStage.PrefetchRuntime), // NOTE: We don't need `NavigationRuntime`, because we set `needsRuntimeShell: false`
+    // so `navigation()` resolves in the static stages.
+    ()=>{
         abortInRenderContext(requestStore, finalReactController);
     });
     const syncInterruptReason = stageController.getSyncInterruptReason();
@@ -3397,13 +3568,11 @@ const ABORT_ONCE = {
     }
 }
 function createStageChunksAccumulator() {
-    return {
-        shellStaticChunks: [],
-        staticChunks: [],
-        shellRuntimeChunks: [],
-        runtimeChunks: [],
-        dynamicChunks: []
-    };
+    const result = {};
+    for (const stage of _stagedrendering.RENDER_STAGE_ADVANCE_ORDER){
+        result[stage] = [];
+    }
+    return result;
 }
 async function accumulateStreamChunks(stream, stageController, signal) {
     const accumulator = createStageChunksAccumulator();
@@ -3464,38 +3633,23 @@ async function accumulateStreamChunksInto(accumulator, stream, stageController,
         } catch (err) {
             if (!cancelled) {
                 throw err;
-            }
-        }
-    }
-}
-function collectStageChunk(accumulator, stage, value1) {
-    switch(stage){
-        case _stagedrendering.RenderStage.Before:
-            throw Object.defineProperty(new _invarianterror.InvariantError('Unexpected stream chunk while in Before stage'), "__NEXT_ERROR_CODE", {
-                value: "E942",
-                enumerable: false,
-                configurable: true
-            });
-        case _stagedrendering.RenderStage.ShellStatic:
-            accumulator.shellStaticChunks.push(value1);
-        // fall through
-        case _stagedrendering.RenderStage.Static:
-            accumulator.staticChunks.push(value1);
-        // fall through
-        case _stagedrendering.RenderStage.ShellRuntime:
-            accumulator.shellRuntimeChunks.push(value1);
-        // fall through
-        case _stagedrendering.RenderStage.Runtime:
-            accumulator.runtimeChunks.push(value1);
-        // fall through
-        case _stagedrendering.RenderStage.Dynamic:
-            accumulator.dynamicChunks.push(value1);
-            break;
-        case _stagedrendering.RenderStage.Abandoned:
-            break;
-        default:
-            stage;
+            }
+        }
+    }
+}
+function collectStageChunk(accumulator, currentStage, value1) {
+    if (currentStage === _stagedrendering.RenderStage.Before) {
+        throw new _invarianterror.InvariantError('Unexpected stream chunk while in Before stage');
+    }
+    // Stage N+1 contains all the chunks of the stages 1..N,
+    // so add the chunk to the array for the current stage and all the stages that follow it.
+    // Starting at the end saves us from having to find the current stage in the order array.
+    for(let i = _stagedrendering.RENDER_STAGE_ADVANCE_ORDER.length - 1; i >= 0; i--){
+        const stage = _stagedrendering.RENDER_STAGE_ADVANCE_ORDER[i];
+        if (stage < currentStage) {
             break;
+        }
+        accumulator[stage].push(value1);
     }
 }
 async function countShellAndStaticStageBytes(stream, stageController) {
@@ -3552,8 +3706,8 @@ function createAsyncApiPromises(stagedRendering, cookies, mutableCookies, header
     // NOTE: Must be kept in sync with cookies.ts, headers.ts, params.ts, search-params.ts
     const cookiesStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.sessionData;
     const headersStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.sessionData;
-    const paramsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
-    const searchParamsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
+    const paramsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeUrlData;
+    const searchParamsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeUrlData;
     return {
         cookies: stagedRendering.delayUntilStage(cookiesStage, 'cookies', cookies),
         mutableCookies: stagedRendering.delayUntilStage(cookiesStage, 'cookies', mutableCookies),
@@ -3572,9 +3726,18 @@ function createAsyncApiPromises(stagedRendering, cookies, mutableCookies, header
  * source-map the stack frames (via findSourceMapURL), but also create virtual
  * server modules that allow users to inspect the server source code in the
  * browser.
- */ async function logMessagesAndSendErrorsToBrowser(messages, ctx) {
-    const { htmlRequestId, renderOpts } = ctx;
+ */ async function logMessagesAndSendErrorsToBrowser(messages, ctx, options = {}) {
+    const logAsValidationResult = process.env.__NEXT_TEST_MODE && process.env.NEXT_TEST_LOG_VALIDATION && options.logAsValidationResult;
+    const { htmlRequestId, requestId, renderOpts } = ctx;
+    const url = ctx.url.href;
     const { sendErrorsToBrowser } = renderOpts;
+    if (logAsValidationResult) {
+        console.log((0, _devvalidationevents.formatValidationEvent)({
+            type: 'validation_start',
+            requestId,
+            url
+        }));
+    }
     const errors = [];
     for (const message of messages){
         // Log the error to the CLI. Prevent the logs from being dimmed, which we
@@ -3592,38 +3755,28 @@ function createAsyncApiPromises(stagedRendering, cookies, mutableCookies, header
             errors.push(message);
         }
     }
+    if (logAsValidationResult) {
+        console.log((0, _devvalidationevents.formatValidationEvent)({
+            type: 'validation_end',
+            requestId,
+            url
+        }));
+    }
     if (errors.length > 0) {
         if (!sendErrorsToBrowser) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('Expected `sendErrorsToBrowser` to be defined in renderOpts.'), "__NEXT_ERROR_CODE", {
-                value: "E947",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        // 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);
-            }
+            throw new _invarianterror.InvariantError('Expected `sendErrorsToBrowser` to be defined in renderOpts.');
         }
         const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
         let errorsFlightStream;
         if (process.env.__NEXT_USE_NODE_STREAMS) {
             errorsFlightStream = (0, _streamops.renderToNodeFlightStream)(ctx.componentMod, {
-                errors,
-                errorCodes
+                errors
             }, clientModules, {
                 filterStackFrame
             });
         } else {
             errorsFlightStream = (0, _streamops.renderToWebFlightStream)(ctx.componentMod, {
-                errors,
-                errorCodes
+                errors
             }, clientModules, {
                 filterStackFrame
             });
@@ -3723,8 +3876,10 @@ function toValidationRenderContext(ctx) {
         workStore: ctx.workStore,
         renderOpts: {
             images: ctx.renderOpts.images,
-            allowEmptyStaticShell: ctx.renderOpts.allowEmptyStaticShell
+            allowEmptyStaticShell: ctx.renderOpts.allowEmptyStaticShell,
+            partialPrefetching: ctx.renderOpts.partialPrefetching
         },
+        reactBrowserBailout: ctx.renderOpts.experimental.reactBrowserBailout,
         isDebugChannelEnabled: !!ctx.renderOpts.setReactDebugChannel
     };
 }
@@ -3744,12 +3899,12 @@ function toValidationRenderContext(ctx) {
         onTaskError () {}
     });
     return {
-        isStaticGeneration: false,
         page: message.page,
         route: message.route,
         forceStatic: message.forceStatic,
         isDraftMode: message.request.isDraftMode,
         useCacheTimeout: message.nextConfigSerializable.useCacheTimeout,
+        durableUseCacheEntries: message.nextConfigSerializable.durableUseCacheEntries,
         staticPageGenerationTimeout: message.nextConfigSerializable.staticPageGenerationTimeout,
         cacheLifeProfiles: message.nextConfigSerializable.cacheLifeProfiles,
         buildId: message.buildId,
@@ -3759,6 +3914,7 @@ function toValidationRenderContext(ctx) {
         refreshTagsByCacheKind: new Map(),
         runInCleanSnapshot: (0, _asynclocalstorage.createSnapshot)(),
         shouldTrackFetchMetrics: false,
+        clientComponentLoadTracker: undefined,
         reactServerErrorsByDigest: new Map(),
         afterContext: noopAfterContext,
         // Dev validation only ever runs under Cache Components.
@@ -3783,12 +3939,13 @@ async function runValidationInDevFromSnapshot(message, componentMod, abortSignal
     // so `react-server-dom-*` can resolve client references during the validation
     // prerenders, exactly as the main render does after loading its module.
     if (componentMod.__next_app__) {
-        installGlobalModuleLoadingHandlers(componentMod, true, false);
+        installGlobalModuleLoadingHandlers(componentMod, true);
     }
     // `requestFallbackRouteParams` reproduces `ctx.getDynamicParamFromSegment`
     // exactly, so the depth-loop segment keys match the seed render's Flight.
-    // `fallbackRouteParams` is separate and only marks params unknown in the
-    // prerender stores.
+    // `fallbackRouteParams` is the staged set of the main-thread request store.
+    // It marks params unknown in the prerender stores, and the worker's request
+    // store defers the same params, so both validation paths stage alike.
     //
     // TODO: Those two fallback params sets are very confusing in the whole code
     // base. We should maybe refactor this to make their different roles clearer.
@@ -3808,8 +3965,10 @@ async function runValidationInDevFromSnapshot(message, componentMod, abortSignal
         workStore,
         renderOpts: {
             images: message.renderOpts.images,
-            allowEmptyStaticShell: message.renderOpts.allowEmptyStaticShell
+            allowEmptyStaticShell: message.renderOpts.allowEmptyStaticShell,
+            partialPrefetching: message.renderOpts.partialPrefetching
         },
+        reactBrowserBailout: message.reactBrowserBailout,
         isDebugChannelEnabled: message.isDebugChannelEnabled
     };
     const requestStore = (0, _requeststore.createRequestStore)({
@@ -3827,7 +3986,7 @@ async function runValidationInDevFromSnapshot(message, componentMod, abortSignal
         isHmrRefresh: message.request.isHmrRefresh,
         hmrRefreshHash: message.request.hmrRefreshHash,
         serverComponentsHmrCache: undefined,
-        fallbackParams: requestFallbackRouteParams
+        stagedFallbackParams: fallbackRouteParams ? new Set(fallbackRouteParams.keys()) : null
     });
     const staticInputs = toDevValidationInputs(message.staticInputs, requestStore);
     const instantInputs = message.instantInputs ? toDevValidationInputs(message.instantInputs, requestStore) : null;
@@ -3852,14 +4011,14 @@ async function runValidationInDevFromSnapshot(message, componentMod, abortSignal
     {
         // For warmup, we have to use the shared inputs if present -- the static inputs
         // may not have a proper dynamic stage.
-        const { runtimeChunks, dynamicChunks } = (instantInputs ?? staticInputs).accumulatedChunks;
+        const { accumulatedChunks } = instantInputs ?? staticInputs;
         // 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.
+        // otherwise, for static shell validation, we only need to warm up to the PrefetchRuntime 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, ctx, validationSamples, validationSampleTracking, validationAbortSignal);
+        needsInstantValidation ? 'validation-client' : 'prerender-client', needsInstantValidation ? accumulatedChunks[_stagedrendering.RenderStage.Dynamic] : accumulatedChunks[_stagedrendering.RenderStage.PrefetchRuntime], accumulatedChunks[_stagedrendering.RenderStage.Dynamic], rootParams, fallbackRouteParams, ctx, validationSamples, validationSampleTracking, validationAbortSignal);
     }
     // React renders used by validation can occupy an entire event-loop turn.
     // Yield between them so a newer navigation can enter app rendering,
@@ -3938,11 +4097,12 @@ async function validateStaticShell(inputs, ctx, rootParams, fallbackRouteParams,
     const { componentMod: ComponentMod, renderOpts } = ctx;
     const loaderTree = ComponentMod.routeModule.userland.loaderTree;
     const { accumulatedChunks, stageEndTimes } = inputs;
-    const { staticChunks, runtimeChunks, dynamicChunks } = accumulatedChunks;
     const allowEmptyStaticShell = (renderOpts.allowEmptyStaticShell ?? false) || await (0, _instantconfig.isPageAllowedToBlock)(loaderTree);
-    const runtimeResult = await validateStagedShell(runtimeChunks, dynamicChunks, debugChunks, stageEndTimes[_stagedrendering.RenderStage.Runtime], rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, hmrRefreshHash, _dynamicrendering.trackDynamicHoleInRuntimeShell, validationAbortSignal);
+    const prefetchMode = await getPrefetchingModeForPage(renderOpts, loaderTree);
+    const ensureStaticLevel = await (0, _ensurestatic.resolveEnsureStaticLevel)(loaderTree, prefetchMode === 2);
+    const runtimeResult = await validateStaticShellAtStage(_stagedrendering.RenderStage.PrefetchRuntime, accumulatedChunks, debugChunks, stageEndTimes, rootParams, fallbackRouteParams, ensureStaticLevel, allowEmptyStaticShell, ctx, hmrRefreshHash, validationAbortSignal);
     if (runtimeResult.length > 0) {
-        debug == null ? void 0 : debug(`❌ Failed - ${runtimeResult.length} errors from runtime stage`);
+        debug == null ? void 0 : debug(`❌ Failed - ${runtimeResult.length} errors from PrefetchRuntime stage`);
         // We have something to report from the runtime validation
         // We can skip the rest
         return runtimeResult;
@@ -3950,7 +4110,7 @@ async function validateStaticShell(inputs, ctx, rootParams, fallbackRouteParams,
     if (!await (0, _devvalidationscheduler.yieldToForegroundRequest)(validationAbortSignal)) {
         return [];
     }
-    const staticResult = await validateStagedShell(staticChunks, dynamicChunks, debugChunks, stageEndTimes[_stagedrendering.RenderStage.Static], rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, hmrRefreshHash, _dynamicrendering.trackDynamicHoleInStaticShell, validationAbortSignal);
+    const staticResult = await validateStaticShellAtStage(_stagedrendering.RenderStage.Static, accumulatedChunks, debugChunks, stageEndTimes, rootParams, fallbackRouteParams, ensureStaticLevel, allowEmptyStaticShell, ctx, hmrRefreshHash, validationAbortSignal);
     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
@@ -3986,9 +4146,9 @@ async function warmupClientModulesForStagedValidation(storeType, partialServerCh
             // 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,
+            revalidate: _constants2.INFINITE_CACHE,
+            expire: _constants2.INFINITE_CACHE,
+            stale: _constants2.INFINITE_CACHE,
             tags: [
                 ...implicitTags.tags
             ],
@@ -4011,9 +4171,9 @@ async function warmupClientModulesForStagedValidation(storeType, partialServerCh
             // 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,
+            revalidate: _constants2.INFINITE_CACHE,
+            expire: _constants2.INFINITE_CACHE,
+            stale: _constants2.INFINITE_CACHE,
             tags: [
                 ...implicitTags.tags
             ],
@@ -4082,13 +4242,17 @@ async function warmupClientModulesForStagedValidation(storeType, partialServerCh
     });
     // This is mostly needed for dynamic `import()`s in client components.
     // Promises passed to client were already awaited above (assuming that they came from cached functions)
-    const cacheSignal = new _cachesignal.CacheSignal();
+    const cacheSignal = new _cachesignal.CacheSignal(null);
     (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
     await cacheSignal.cacheReady();
     _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, initialClientReactController.abort.bind(initialClientReactController));
 }
-async function validateStagedShell(stageChunks, allServerChunks, debugChunks, debugEndTime, rootParams, fallbackRouteParams, allowEmptyStaticShell, ctx, hmrRefreshHash, trackDynamicHole, validationAbortSignal) {
+async function validateStaticShellAtStage(stage, accumulatedChunks, debugChunks, stageEndTimes, rootParams, fallbackRouteParams, ensureStaticLevel, allowEmptyStaticShell, ctx, hmrRefreshHash, validationAbortSignal) {
+    const debug = process.env.NEXT_PRIVATE_DEBUG_VALIDATION === '1' ? console.log : undefined;
     const { implicitTags, nonce, workStore } = ctx;
+    const dynamicHoleKind = stage === _stagedrendering.RenderStage.Static ? _dynamicrendering.DynamicHoleKind.Runtime : _dynamicrendering.DynamicHoleKind.Dynamic;
+    const isFallbackShell = false;
+    const stageIsPartial = accumulatedChunks[stage].length < accumulatedChunks[_stagedrendering.RenderStage.Dynamic].length;
     const clientDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(false //isDebugDynamicAccesses
     );
     const clientReactController = new AbortController();
@@ -4110,9 +4274,9 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
         // No APIs require a cacheSignal through the workUnitStore during the HTML prerender
         cacheSignal: null,
         dynamicTracking: clientDynamicTracking,
-        revalidate: _constants1.INFINITE_CACHE,
-        expire: _constants1.INFINITE_CACHE,
-        stale: _constants1.INFINITE_CACHE,
+        revalidate: _constants2.INFINITE_CACHE,
+        expire: _constants2.INFINITE_CACHE,
+        stale: _constants2.INFINITE_CACHE,
         tags: [
             ...implicitTags.tags
         ],
@@ -4123,15 +4287,16 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
         varyParamsAccumulator: null
     };
     const dynamicValidation = (0, _dynamicrendering.createDynamicValidationState)();
-    const serverStream = (0, _streamutils.createNodeStreamWithLateRelease)(stageChunks, allServerChunks, clientReactSignal);
+    const serverStream = (0, _streamutils.createNodeStreamWithLateRelease)(accumulatedChunks[stage], accumulatedChunks[_stagedrendering.RenderStage.Dynamic], clientReactSignal);
     const debugChannelClient = debugChunks ? (0, _streamutils.createNodeStreamWithLateRelease)(debugChunks, debugChunks, clientReactSignal) : undefined;
+    debug == null ? void 0 : debug(`Validating static shell at: ${_stagedrendering.RenderStage[stage]} (partial: ${stageIsPartial}, static level: ${_ensurestatic.EnsureStaticLevel[ensureStaticLevel]})`);
     try {
         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,
-                debugEndTime: debugEndTime,
+                debugEndTime: stageEndTimes[stage],
                 preinitScripts: preinitScripts,
                 ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
                 nonce: nonce,
@@ -4142,7 +4307,11 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
                     if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || clientReactSignal.aborted) {
                         const componentStack = errorInfo.componentStack;
                         if (typeof componentStack === 'string') {
-                            trackDynamicHole(err, workStore, componentStack, dynamicValidation, clientDynamicTracking);
+                            if (ensureStaticLevel === _ensurestatic.EnsureStaticLevel.Navigation) {
+                                (0, _dynamicrendering.trackDynamicAccessInStaticRoute)(err, workStore, componentStack, dynamicValidation, clientDynamicTracking, stageIsPartial, dynamicHoleKind);
+                            } else {
+                                (0, _dynamicrendering.trackDynamicHoleInStaticShell)(err, workStore, componentStack, dynamicValidation, clientDynamicTracking, dynamicHoleKind);
+                            }
                         }
                         return;
                     }
@@ -4167,11 +4336,22 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
             _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalClientPrerenderStore, clientReactController.abort.bind(clientReactController));
         });
         const { preludeIsEmpty } = await (0, _streamops.processPrelude)(unprocessedPrelude);
-        return (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, dynamicValidation, allowEmptyStaticShell);
+        const preludeState = preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full;
+        if (ensureStaticLevel === _ensurestatic.EnsureStaticLevel.Navigation) {
+            return (0, _dynamicrendering.getDisallowedReasonsInStaticRoute)(workStore, preludeState, dynamicValidation, null, isFallbackShell, allowEmptyStaticShell, stageIsPartial);
+        } else {
+            return (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, preludeState, dynamicValidation, 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, dynamicValidation, allowEmptyStaticShell);
+        const preludeState = _dynamicrendering.PreludeState.Errored;
+        let errors;
+        if (ensureStaticLevel === _ensurestatic.EnsureStaticLevel.Navigation) {
+            errors = (0, _dynamicrendering.getDisallowedReasonsInStaticRoute)(workStore, preludeState, dynamicValidation, null, isFallbackShell, allowEmptyStaticShell, stageIsPartial);
+        } else {
+            errors = (0, _dynamicrendering.getStaticShellDisallowedDynamicReasons)(workStore, preludeState, dynamicValidation, 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);
         }
@@ -4181,8 +4361,8 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
 /**
  * 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
+ * above the boundary use the Dynamic stage (already mounted) and segments
+ * below use the stage that corresponds to what was prefetched. If the new subtree
  * contains any `instant` configs, the payload is rendered to
  * detect dynamic holes without Suspense.
  */ async function validateInstantConfigs(prefetchMode, accumulatedChunks, debugChunks, startTime, stageEndTimes, rootParams, fallbackRouteParams, ctx, hmrRefreshHash, validationSamples, devRenderDidError, validationAbortSignal) {
@@ -4190,40 +4370,149 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
     const { createCombinedPayloadAtDepth, createCombinedPayloadStream, collectStagedSegmentData, discoverValidationDepths, ValidationPrefetchKind } = ctx.componentMod.InstantValidation();
     const { createValidationSampleTracking } = require('./instant-validation/instant-samples');
     debug == null ? void 0 : debug('\nStarting depth-based instant validation...');
-    const prefetchKind = prefetchMode === 2 ? ValidationPrefetchKind.Shell : ValidationPrefetchKind.LegacySpeculative;
+    let prefetchKind;
+    switch(prefetchMode){
+        case 2:
+            {
+                const ensureStaticLevel = await (0, _ensurestatic.resolveEnsureStaticLevel)(ctx.componentMod.routeModule.userland.loaderTree, /* partialPrefetching */ true);
+                prefetchKind = ensureStaticLevel >= _ensurestatic.EnsureStaticLevel.Shell ? ValidationPrefetchKind.StaticAppShell : ValidationPrefetchKind.RuntimeAppShell;
+                break;
+            }
+        case 1:
+            {
+                prefetchKind = ValidationPrefetchKind.LegacySpeculative;
+                break;
+            }
+    }
     const loaderTree = ctx.componentMod.routeModule.userland.loaderTree;
     const clientReferenceManifest = (0, _manifestssingleton.getClientReferenceManifest)();
     const renderFlightStream = process.env.__NEXT_USE_NODE_STREAMS ? _streamops.renderToNodeFlightStream : _streamops.renderToWebFlightStream;
     const createDebugChannel = process.env.__NEXT_USE_NODE_STREAMS ? _debugchannelserver.createNodeDebugChannel : _debugchannelserver.createWebDebugChannel;
-    const { cache, payload: initialRscPayload } = await collectStagedSegmentData(prefetchKind, ctx.componentMod, renderFlightStream, {
-        [_stagedrendering.RenderStage.Static]: accumulatedChunks.staticChunks,
-        [_stagedrendering.RenderStage.ShellRuntime]: accumulatedChunks.shellRuntimeChunks,
-        [_stagedrendering.RenderStage.Runtime]: accumulatedChunks.runtimeChunks,
-        [_stagedrendering.RenderStage.Dynamic]: accumulatedChunks.dynamicChunks
-    }, debugChunks, startTime, stageEndTimes, clientReferenceManifest, createDebugChannel);
+    const { cache, payload: initialRscPayload } = await collectStagedSegmentData(prefetchKind, ctx.componentMod, renderFlightStream, accumulatedChunks, debugChunks, startTime, stageEndTimes, clientReferenceManifest, createDebugChannel);
     const { implicitTags, nonce, workStore, isDebugChannelEnabled } = ctx;
-    async function validateAtDepth(depth, groupDepthForValidation) {
-        return validateAtDepthImpl(depth, groupDepthForValidation, null);
+    /**
+   * Typescript helper to ensure that all stages in `stageOrder` have an entry in `holeResolution`.
+   * This is more constrained than the actual `ValidationSequence` type.
+   * */ const defineValidationSequence = (sequence)=>{
+        return sequence;
+    };
+    // TODO: these sequences are effectively duplicated in `collectStagedSegmentData`
+    // in `instant-validation.tsx`. We should have one source of truth for them
+    const validationSequences = {
+        [ValidationPrefetchKind.StaticAppShell]: defineValidationSequence({
+            stageOrder: [
+                _stagedrendering.RenderStage.ShellStatic,
+                _stagedrendering.RenderStage.PrefetchStatic_prefetchApi,
+                _stagedrendering.RenderStage.PrefetchStatic,
+                _stagedrendering.RenderStage.NavigationStatic,
+                _stagedrendering.RenderStage.PrefetchRuntime,
+                _stagedrendering.RenderStage.Dynamic
+            ],
+            holeResolution: {
+                [_stagedrendering.RenderStage.ShellStatic]: null,
+                [_stagedrendering.RenderStage.PrefetchStatic_prefetchApi]: _dynamicrendering.DynamicHoleKind.Prefetch,
+                [_stagedrendering.RenderStage.PrefetchStatic]: _dynamicrendering.DynamicHoleKind.Link,
+                [_stagedrendering.RenderStage.NavigationStatic]: _dynamicrendering.DynamicHoleKind.Navigation,
+                [_stagedrendering.RenderStage.PrefetchRuntime]: _dynamicrendering.DynamicHoleKind.Runtime,
+                [_stagedrendering.RenderStage.Dynamic]: _dynamicrendering.DynamicHoleKind.Dynamic
+            }
+        }),
+        [ValidationPrefetchKind.RuntimeAppShell]: defineValidationSequence({
+            stageOrder: [
+                _stagedrendering.RenderStage.ShellRuntime,
+                _stagedrendering.RenderStage.PrefetchRuntime_prefetchApi,
+                _stagedrendering.RenderStage.PrefetchRuntime,
+                _stagedrendering.RenderStage.NavigationRuntime,
+                _stagedrendering.RenderStage.Dynamic
+            ],
+            holeResolution: {
+                [_stagedrendering.RenderStage.ShellRuntime]: null,
+                [_stagedrendering.RenderStage.PrefetchRuntime_prefetchApi]: _dynamicrendering.DynamicHoleKind.Prefetch,
+                [_stagedrendering.RenderStage.PrefetchRuntime]: _dynamicrendering.DynamicHoleKind.Link,
+                [_stagedrendering.RenderStage.NavigationRuntime]: _dynamicrendering.DynamicHoleKind.Navigation,
+                [_stagedrendering.RenderStage.Dynamic]: _dynamicrendering.DynamicHoleKind.Dynamic
+            }
+        }),
+        [ValidationPrefetchKind.LegacySpeculative]: defineValidationSequence({
+            stageOrder: [
+                _stagedrendering.RenderStage.Static,
+                _stagedrendering.RenderStage.PrefetchRuntime,
+                _stagedrendering.RenderStage.Dynamic
+            ],
+            holeResolution: {
+                [_stagedrendering.RenderStage.Static]: null,
+                [_stagedrendering.RenderStage.PrefetchRuntime]: _dynamicrendering.DynamicHoleKind.Runtime,
+                [_stagedrendering.RenderStage.Dynamic]: _dynamicrendering.DynamicHoleKind.Dynamic
+            }
+        })
+    };
+    const validationSequence = validationSequences[prefetchKind];
+    const initialRenderStage = validationSequence.stageOrder[0];
+    // When narrowing the cause of a dynamic hole, we need to find the first stage it occurs in.
+    // We do this by starting at the end and eliminating later stages, so we go in reverse.
+    const retryRenderStages = validationSequences[prefetchKind].stageOrder.slice(1, -1) // Exclude first stage and Dynamic
+    .reverse();
+    function getDynamicHoleKindForSegmentStage(stage) {
+        // We report holes in reverse order, i.e. holes in Stage N are only reported
+        // if Stage N+1 didn't have any holes. That means that if we report a hole from Stage N,
+        // it has to be caused by data that would've resolved in Stage N+1.
+        // So, the dynamic hole kind corresponds to the *next* logical stage.
+        const { stageOrder, holeResolution } = validationSequence;
+        const nextStage = stageOrder[stageOrder.indexOf(stage) + 1];
+        const holeKind = holeResolution[nextStage];
+        // NOTE: `defineValidationSequence` should prevent `undefined` here, because
+        // we asserted on the type level that each `stage` either has a `holeKind` or `null`
+        if (holeKind === undefined) {
+            throw new _invarianterror.InvariantError(`${_stagedrendering.RenderStage[stage]} segments should not be used in ${ValidationPrefetchKind[prefetchKind]} prefetches`);
+        }
+        // The initial stage can have `null`. We should not see it here
+        if (holeKind === null) {
+            throw new _invarianterror.InvariantError(`${_stagedrendering.RenderStage[stage]} segments do not unblock new data in ${ValidationPrefetchKind[prefetchKind]} prefetches`);
+        }
+        return holeKind;
     }
-    async function validateAtDepthImpl(depth, groupDepthForValidation, previousBoundaryState) {
+    async function validateAtDepth(depth, groupDepthForValidation) {
         if (validationAbortSignal == null ? void 0 : validationAbortSignal.aborted) {
             return null;
         }
+        // First attempt. If we have any dynamic holes, they will be ambiguous.
+        const initialBoundaryState = (0, _boundarytracking.createValidationBoundaryTracking)();
+        const initialResult = await validateOrRetryAtDepth(depth, groupDepthForValidation, initialBoundaryState, null);
+        // If the prerender produced no real errors at this depth — either an
+        // empty array (clean) or a deferred-only result (Error/AggregateError
+        // representing a missing-boundary fallback) — there's nothing to
+        // discriminate. Pass it up so the outer loop can hold any deferred
+        // fallback back until every depth has been tried.
+        if (!Array.isArray(initialResult) || initialResult.length === 0) {
+            return initialResult;
+        }
+        // We do a followup validation using a payload using later stages to determine
+        // what kind of data caused the hole -- link/navigation/dynamic in app shells,
+        // or runtime/dynamic in static shells.
+        for (const retryStage of retryRenderStages){
+            if (validationAbortSignal !== undefined && !await (0, _devvalidationscheduler.yieldToForegroundRequest)(validationAbortSignal)) {
+                return [];
+            }
+            const narrowedResult = await validateOrRetryAtDepth(depth, groupDepthForValidation, (0, _boundarytracking.createValidationBoundaryTracking)(initialBoundaryState), retryStage);
+            if (Array.isArray(narrowedResult) && narrowedResult.length > 0) {
+                // The narrowed validation found errors to report.
+                return narrowedResult;
+            }
+        }
+        // If we didn't return some other errors at this point the only thing to return is this validation's result
+        return initialResult;
+    }
+    async function validateOrRetryAtDepth(depth, groupDepthForValidation, boundaryState, overrideStageForPartialSegments = null) {
+        // If we're not overriding the stage, we're in the first stage.
+        const stage = overrideStageForPartialSegments ?? initialRenderStage;
+        const dynamicHoleKind = getDynamicHoleKindForSegmentStage(stage);
+        debug == null ? void 0 : debug(`  trying ${_stagedrendering.RenderStage[stage]} (hole: ${_dynamicrendering.DynamicHoleKind[dynamicHoleKind]})`);
         const extraChunksController = new AbortController();
         const extraChunksSignal = validationAbortSignal === undefined ? extraChunksController.signal : AbortSignal.any([
             extraChunksController.signal,
             validationAbortSignal
         ]);
-        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, filePath] of previousBoundaryState.requiredIds){
-                boundaryState.requiredIds.set(id, filePath);
-            }
-        }
-        const payloadResult = await createCombinedPayloadAtDepth(prefetchKind, initialRscPayload, cache, loaderTree, ctx.getDynamicParamFromSegment, ctx.query, depth, groupDepthForValidation, extraChunksSignal, boundaryState, clientReferenceManifest, useRuntimeStageForPartialSegments);
+        const payloadResult = await createCombinedPayloadAtDepth(prefetchKind, initialRscPayload, cache, loaderTree, ctx.getDynamicParamFromSegment, depth, groupDepthForValidation, extraChunksSignal, boundaryState, clientReferenceManifest, overrideStageForPartialSegments);
         if (payloadResult === null) {
             return null;
         }
@@ -4248,9 +4537,9 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
             controller: reactController,
             cacheSignal: null,
             dynamicTracking: clientDynamicTracking,
-            revalidate: _constants1.INFINITE_CACHE,
-            expire: _constants1.INFINITE_CACHE,
-            stale: _constants1.INFINITE_CACHE,
+            revalidate: _constants2.INFINITE_CACHE,
+            expire: _constants2.INFINITE_CACHE,
+            stale: _constants2.INFINITE_CACHE,
             tags: [
                 ...implicitTags.tags
             ],
@@ -4262,20 +4551,6 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
             validationSamples,
             validationSampleTracking
         };
-        let dynamicHoleKind;
-        switch(prefetchKind){
-            case ValidationPrefetchKind.Shell:
-                {
-                    dynamicHoleKind = payloadResult.hasAmbiguousErrors ? _dynamicrendering.DynamicHoleKind.Link : _dynamicrendering.DynamicHoleKind.Dynamic;
-                    break;
-                }
-            case ValidationPrefetchKind.LegacySpeculative:
-                {
-                    dynamicHoleKind = payloadResult.hasAmbiguousErrors ? _dynamicrendering.DynamicHoleKind.Runtime : _dynamicrendering.DynamicHoleKind.Dynamic;
-                    break;
-                }
-        }
-        let result;
         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
@@ -4289,6 +4564,14 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
                     images: ctx.renderOpts.images
                 }), {
                     signal: reactSignal,
+                    onBrowserBailout: (err, errorInfo)=>{
+                        if (!reactSignal.aborted) {
+                            const componentStack = errorInfo.componentStack;
+                            if (typeof componentStack === 'string') {
+                                (0, _dynamicrendering.trackThrownErrorInNavigation)(workStore, instantValidationState, err, componentStack, ctx.reactBrowserBailout);
+                            }
+                        }
+                    },
                     onError: (err, errorInfo)=>{
                         if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || reactSignal.aborted) {
                             const componentStack = errorInfo.componentStack;
@@ -4311,7 +4594,7 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
                                         }
                                     }
                                 }
-                                (0, _dynamicrendering.trackThrownErrorInNavigation)(workStore, instantValidationState, errorForDisplay, componentStack);
+                                (0, _dynamicrendering.trackThrownErrorInNavigation)(workStore, instantValidationState, errorForDisplay, componentStack, ctx.reactBrowserBailout);
                             }
                         }
                         if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
@@ -4331,32 +4614,10 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
                 _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderStore, reactController.abort.bind(reactController));
             });
             const { preludeIsEmpty } = await (0, _streamops.processPrelude)(unprocessedPrelude);
-            result = (0, _dynamicrendering.getNavigationDisallowedDynamicReasons)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, instantValidationState, validationSampleTracking, boundaryState, devRenderDidError);
+            return (0, _dynamicrendering.getNavigationDisallowedDynamicReasons)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, instantValidationState, validationSampleTracking, boundaryState, devRenderDidError);
         } catch (thrownValue) {
-            result = (0, _dynamicrendering.getNavigationDisallowedDynamicReasons)(workStore, _dynamicrendering.PreludeState.Errored, instantValidationState, validationSampleTracking, boundaryState, devRenderDidError);
-        }
-        // If the prerender produced no real errors at this depth — either an
-        // empty array (clean) or a deferred-only result (Error/AggregateError
-        // representing a missing-boundary fallback) — there's nothing to
-        // discriminate. Pass it up so the outer loop can hold any deferred
-        // fallback back until every depth has been tried.
-        if (!Array.isArray(result) || result.length === 0) {
-            return result;
+            return (0, _dynamicrendering.getNavigationDisallowedDynamicReasons)(workStore, _dynamicrendering.PreludeState.Errored, instantValidationState, validationSampleTracking, boundaryState, devRenderDidError);
         }
-        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
-            if (validationAbortSignal !== undefined && !await (0, _devvalidationscheduler.yieldToForegroundRequest)(validationAbortSignal)) {
-                return [];
-            }
-            const dynamicOnlyResult = await validateAtDepthImpl(depth, groupDepthForValidation, boundaryState);
-            if (Array.isArray(dynamicOnlyResult) && dynamicOnlyResult.length > 0) {
-                // The dynamic errors only validation found errors to report so we favor those
-                return dynamicOnlyResult;
-            }
-        }
-        // If we didn't return some other errors at this point the only thing to return is this validation's result
-        return result;
     }
     // Discover validation depth bounds from the LoaderTree. The array
     // length is the max URL depth; each entry is the max group depth
@@ -4422,17 +4683,18 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
  * - 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(prefetchMode, ctx, initialRequestStore, createRequestStore, getPayload, createOnError, prefilledDataCache) {
+ */ async function renderWithRestartOnCacheMissInValidation(prefetchMode, ensureStaticLevel, ctx, initialRequestStore, createRequestStore, getPayload, createOnError, prefilledDataCache) {
     const { componentMod: ComponentMod } = ctx;
-    const shouldRenderAppShell = prefetchMode === 2;
     const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     const renderFlightStream = process.env.__NEXT_USE_NODE_STREAMS ? _streamops.renderToNodeFlightStream : _streamops.renderToWebFlightStream;
+    const needsRuntimeAppShell = prefetchMode === 2 && ensureStaticLevel === _ensurestatic.EnsureStaticLevel.None;
     let startTime = -Infinity;
     let requestStore = initialRequestStore;
     //===============================================
     // Initial render (prospective — may warm caches)
     //===============================================
-    const cacheSignal = new _cachesignal.CacheSignal();
+    const immediateTracker = new _fastsetimmediateexternal.ImmediateTracker();
+    const cacheSignal = new _cachesignal.CacheSignal(immediateTracker);
     (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.
@@ -4448,7 +4710,8 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
     });
     requestStore.resumeDataCache = prerenderResumeDataCache;
     requestStore.stagedRendering = initialStageController;
-    requestStore.needsSessionShell = shouldRenderAppShell;
+    requestStore.needsRuntimeShell = needsRuntimeAppShell;
+    requestStore.hasIncompatibleShellContent = false;
     requestStore.cacheSignal = cacheSignal;
     requestStore.asyncApiPromises = createAsyncApiPromises(initialStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
     // We don't set `requestStore.controller and requestStore.renderSignal here.
@@ -4456,7 +4719,7 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
     // (after waiting for caches)
     requestStore.controller = undefined;
     requestStore.renderSignal = undefined;
-    const initialRscPayload = await getPayload(requestStore);
+    const initialRscPayload = await (0, _fastsetimmediateexternal.runWithNativeImmediateTracking)(immediateTracker, getPayload, requestStore);
     const advanceStageIfNoCacheMiss = (stage)=>{
         if (initialAbandonController.signal.aborted === true) {
             return;
@@ -4466,7 +4729,7 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
             initialStageController.advanceStage(stage);
         }
     };
-    const initialResult = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
+    const initialResult = await (0, _fastsetimmediateexternal.runWithNativeImmediateTracking)(immediateTracker, _apprenderrenderutils.runInSequentialTasks, ()=>{
         initialStageController.advanceStage(_stagedrendering.RenderStage.ShellStatic);
         startTime = performance.now() + performance.timeOrigin;
         const stream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, renderFlightStream, ComponentMod, initialRscPayload, clientModules, {
@@ -4486,15 +4749,7 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
         return {
             accumulatedChunksPromise
         };
-    }, ()=>{
-        advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.Static);
-    }, ()=>{
-        advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.ShellRuntime);
-    }, ()=>{
-        advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.Runtime);
-    }, ()=>{
-        advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.Dynamic);
-    });
+    }, ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.PrefetchStatic_prefetchApi), ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.PrefetchStatic), ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.NavigationStatic), ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.Static), ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.ShellRuntime), ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.PrefetchRuntime_prefetchApi), ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.PrefetchRuntime), ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.NavigationRuntime), ()=>advanceStageIfNoCacheMiss(_stagedrendering.RenderStage.Dynamic));
     if (initialStageController.currentStage !== _stagedrendering.RenderStage.Abandoned) {
         // No cache misses. Use the result as-is.
         return {
@@ -4523,7 +4778,8 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
     });
     requestStore.resumeDataCache = (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache);
     requestStore.stagedRendering = finalStageController;
-    requestStore.needsSessionShell = shouldRenderAppShell;
+    requestStore.needsRuntimeShell = needsRuntimeAppShell;
+    requestStore.hasIncompatibleShellContent = false;
     requestStore.cacheSignal = null;
     requestStore.asyncApiPromises = createAsyncApiPromises(finalStageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
     // Right now, we only abort for sync IO.
@@ -4551,7 +4807,7 @@ async function validateStagedShell(stageChunks, allServerChunks, debugChunks, de
         return {
             accumulatedChunksPromise
         };
-    }, ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.ShellRuntime), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.Runtime), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.Dynamic));
+    }, ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic_prefetchApi), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.NavigationStatic), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.Static), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.ShellRuntime), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.PrefetchRuntime_prefetchApi), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.PrefetchRuntime), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.NavigationRuntime), ()=>finalStageController.advanceStage(_stagedrendering.RenderStage.Dynamic));
     return {
         accumulatedChunksPromise: finalResult.accumulatedChunksPromise,
         startTime,
@@ -4568,12 +4824,8 @@ async function validateInstantConfigsInBuild(ctx, prefilledDataCache) {
             // 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 occurred during instant validation', {
+            console.error(new _invarianterror.InvariantError('An unexpected error occurred during instant validation', {
                 cause: err
-            }), "__NEXT_ERROR_CODE", {
-                value: "E1097",
-                enumerable: false,
-                configurable: true
             }));
             success = false;
         }
@@ -4667,6 +4919,7 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
     const { workStore: outerWorkStore } = outerCtx;
     const loaderTree = outerCtx.componentMod.routeModule.userland.loaderTree;
     const prefetchMode = await getPrefetchingModeForPage(outerCtx.renderOpts, loaderTree);
+    const ensureStaticLevel = await (0, _ensurestatic.resolveEnsureStaticLevel)(loaderTree, prefetchMode === 2);
     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
@@ -4691,13 +4944,13 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
     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,
         requestStartTime: outerWorkStore.requestStartTime,
         incrementalCache: outerWorkStore.incrementalCache,
         cacheLifeProfiles: outerWorkStore.cacheLifeProfiles,
         useCacheTimeout: outerWorkStore.useCacheTimeout,
+        durableUseCacheEntries: outerWorkStore.durableUseCacheEntries,
         staticPageGenerationTimeout: outerWorkStore.staticPageGenerationTimeout,
         isBuildTimePrerendering: false,
         fetchCache: outerWorkStore.fetchCache,
@@ -4725,6 +4978,7 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
         refreshTagsByCacheKind: new Map(),
         runInCleanSnapshot: outerWorkStore.runInCleanSnapshot,
         shouldTrackFetchMetrics: false,
+        clientComponentLoadTracker: undefined,
         reactServerErrorsByDigest: new Map()
     };
     return _workasyncstorageexternal.workAsyncStorage.run(workStore, async ()=>{
@@ -4734,6 +4988,11 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
             url: sampleUrlWithoutQuery,
             renderOpts: outerCtx.renderOpts,
             workStore,
+            missingPrefetchHintPolicy: (0, _createtransporttreefromloadertree.getMissingPrefetchHintPolicy)(outerCtx.renderOpts.isBuildTimePrerendering ?? false, false, outerCtx.renderOpts.cacheComponents),
+            renderCapabilities: {
+                isPossiblyPartialResponse: false,
+                supportsPerSegmentPrefetching: outerCtx.renderCapabilities.supportsPerSegmentPrefetching
+            },
             parsedRequestHeaders: outerCtx.parsedRequestHeaders,
             getDynamicParamFromSegment,
             interpolatedParams: sampleParams,
@@ -4794,8 +5053,9 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
         // 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(prefetchMode, validationCtx, createRequestStore(), createRequestStore, (requestStore)=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, loaderTree, validationCtx, {
-                is404: false
+        const { accumulatedChunksPromise, startTime, stageController, requestStore: finalServerStore } = await renderWithRestartOnCacheMissInValidation(prefetchMode, ensureStaticLevel, validationCtx, createRequestStore(), createRequestStore, (requestStore)=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, loaderTree, validationCtx, {
+                is404: false,
+                isPrerendering: true
             }), (signal)=>function onError(err) {
                 const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
                 if (digest) {
@@ -4836,7 +5096,7 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
         // the Dynamic stage, they're Runtime at best.
         const warmupValidationSamplesTracking = createValidationSampleTracking();
         const validationRenderCtx = toValidationRenderContext(validationCtx);
-        await warmupClientModulesForStagedValidation('validation-client', accumulatedChunks.dynamicChunks, accumulatedChunks.dynamicChunks, sampleRootParams, fallbackRouteParams, validationRenderCtx, validationSamples, warmupValidationSamplesTracking);
+        await warmupClientModulesForStagedValidation('validation-client', accumulatedChunks[_stagedrendering.RenderStage.Dynamic], accumulatedChunks[_stagedrendering.RenderStage.Dynamic], sampleRootParams, fallbackRouteParams, validationRenderCtx, validationSamples, warmupValidationSamplesTracking);
         if (warmupValidationSamplesTracking.missingSampleErrors.length > 0) {
             return warmupValidationSamplesTracking.missingSampleErrors;
         }
@@ -4844,15 +5104,6 @@ async function validateInstantConfigInBuildWithSample(outerCtx, sample, allPossi
         );
     });
 }
-/**
- * Determines whether we should generate static flight data.
- */ // TODO: This helper used to exclude fallback route params. It now only checks
-// static generation inside prerenderToStream and can be removed. LOE: low.
-function shouldGenerateStaticFlightData(workStore) {
-    const { isStaticGeneration } = workStore;
-    if (!isStaticGeneration) return false;
-    return true;
-}
 async function continueStaticPrerenderWithInlinedData(htmlStream, reactServerResult, fallbackRouteParams, createInlinedDataStream, formState, nonce, getServerInsertedHTML, getServerInsertedMetadata, deploymentId, ComponentMod, renderFlightStream, clientModules, filterStackFrameForError, serverComponentsErrorHandler) {
     const hasFallbackRouteParams = fallbackRouteParams && fallbackRouteParams.size > 0;
     if (hasFallbackRouteParams) {
@@ -4892,7 +5143,7 @@ async function continueStaticPrerenderWithInlinedData(htmlStream, reactServerRes
         deploymentId
     });
 }
-async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRouteParams) {
+async function prerenderToStream(res, ctx, metadata, tree, fallbackRouteParams) {
     // When prerendering formState is always null. We still include it
     // because some shared APIs expect a formState value and this is slightly
     // more explicit than making it an optional function argument
@@ -4941,7 +5192,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
     const reportErrors = !experimental.isRoutePPREnabled;
     function onHTMLRenderRSCError(err, silenceLog) {
         if (reportErrors) {
-            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'), silenceLog);
+            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, createPrerenderErrorContext(ctx, 'react-server-components'), silenceLog);
         }
     }
     const serverComponentsErrorHandler = (0, _createerrorhandler.createReactServerErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, reactServerErrorsByDigest, onHTMLRenderRSCError);
@@ -4950,13 +5201,14 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             // We don't need to silence logs here. onHTMLRenderSSRError won't be
             // called at all if the error was logged before in the RSC error handler.
             const silenceLog = false;
-            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'server-rendering'), silenceLog);
+            return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, createPrerenderErrorContext(ctx, 'server-rendering'), silenceLog);
         }
     }
     const allCapturedErrors = [];
-    const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, reactServerErrorsByDigest, allCapturedErrors, onHTMLRenderSSRError);
+    const captureHTMLError = (0, _createerrorhandler.createHTMLErrorHandler)(process.env.NODE_ENV === 'development', isBuildTimePrerendering, ctx.renderOpts.experimental.reactBrowserBailout, reactServerErrorsByDigest, allCapturedErrors, onHTMLRenderSSRError);
     let reactServerPrerenderResult = null;
     let reactServerPrerenderResultIsDynamic = null;
+    let reactServerRenderChunks = null;
     let reactServerResumeDataCache = null;
     let reactServerPrerenderStore = null;
     const setMetadataHeader = (name)=>{
@@ -4981,8 +5233,44 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
     const selectStaleTime = (0, _staletime.createSelectStaleTime)(experimental);
     const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     let prerenderStore = null;
+    let capturedHTTPErrorType;
+    // Redirects take precedence over access fallbacks. Within each category, the
+    // first error wins. Always return the current error's type, even if it does
+    // not change the response, so the recovery catch can recognize HTTP errors.
+    function setHTTPAccessFallbackOrRedirectStatus(err) {
+        if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
+            const statusCode = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
+            if (capturedHTTPErrorType === undefined) {
+                capturedHTTPErrorType = 'access-fallback';
+                res.statusCode = statusCode;
+                metadata.statusCode = statusCode;
+            }
+            return (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)(statusCode);
+        } else if ((0, _redirecterror.isRedirectError)(err)) {
+            if (capturedHTTPErrorType !== 'redirect') {
+                capturedHTTPErrorType = 'redirect';
+                res.statusCode = (0, _redirect.getRedirectStatusCodeFromError)(err);
+                metadata.statusCode = res.statusCode;
+                setHeader('location', (0, _addpathprefix.addPathPrefix)((0, _redirect.getURLFromRedirectError)(err), basePath));
+            }
+            return 'redirect';
+        }
+    }
+    // React can complete a prerender after an HTTP access fallback or redirect
+    // error is thrown inside a Suspense boundary. Update the response while
+    // preserving the prerendered content outside the boundary.
+    const htmlRendererErrorHandler = (err, errorInfo)=>{
+        setHTTPAccessFallbackOrRedirectStatus(err);
+        return captureHTMLError(err, errorInfo);
+    };
     try {
         if (cacheComponents) {
+            const partialPrefetching = Boolean(ctx.renderOpts.partialPrefetching) || await (0, _instantconfig.anySegmentHasPartialPrefetchingEnabled)(tree);
+            let ensureStaticLevel = await (0, _ensurestatic.resolveEnsureStaticLevel)(tree, partialPrefetching);
+            if (process.env.NEXT_PRIVATE_DEBUG_RUNTIME_DATA) {
+                console.log(`${workStore.route} :: ensureStatic level = ${_ensurestatic.EnsureStaticLevel[ensureStaticLevel]}`);
+            }
+            const isFallbackShell = !!(renderOpts.allowEmptyStaticShell === true && fallbackRouteParams && fallbackRouteParams.size > 0);
             /**
        * cacheComponents with PPR
        *
@@ -5017,12 +5305,46 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             const initialServerRenderController = new AbortController();
             // The cacheSignal helps us track whether caches are still filling or we are ready
             // to cut the render off.
-            const cacheSignal = new _cachesignal.CacheSignal();
+            const immediateTracker = new _fastsetimmediateexternal.ImmediateTracker();
+            const cacheSignal = new _cachesignal.CacheSignal(immediateTracker);
             // 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 mutable prerender
             // resume data cache.
-            const resumeDataCache = renderOpts.renderResumeDataCache ?? (0, _resumedatacache.createPrerenderResumeDataCache)();
+            let resumeDataCache = renderOpts.renderResumeDataCache ?? (0, _resumedatacache.createPrerenderResumeDataCache)();
+            if (renderOpts.renderResumeDataCache && fallbackRouteParams && Object.keys(rootParams).some((name)=>fallbackRouteParams.has(name))) {
+                // This seed came from a more specific prerender. Its cache keys don't
+                // include root params, so replace entries that read roots this shell
+                // doesn't know with markers explaining why they must become holes.
+                // Keep the original seed intact for shells where those roots are known.
+                const cache = new Map(resumeDataCache.cache);
+                for (const [key, pendingEntry] of cache){
+                    if (pendingEntry === _cachestore.FALLBACK_PARAMS || pendingEntry === _cachestore.RUNTIME_DATA || pendingEntry === _cachestore.SESSION_DATA) {
+                        continue;
+                    }
+                    const { readRootParamNames, entry: { revalidate, expire } } = await pendingEntry;
+                    if (readRootParamNames) {
+                        for (const name of readRootParamNames){
+                            if (fallbackRouteParams.has(name)) {
+                                // Unlike an unexplained miss, this entry can become static
+                                // once its root params are known. Preserve that distinction
+                                // for the final pass's static-prefetch hint. Short-lived
+                                // entries still need runtime data even with concrete params.
+                                if (revalidate === 0 || expire < _constants.MIN_PRERENDERABLE_EXPIRE) {
+                                    cache.set(key, _cachestore.SESSION_DATA);
+                                } else {
+                                    cache.set(key, _cachestore.FALLBACK_PARAMS);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+                resumeDataCache = {
+                    ...resumeDataCache,
+                    cache
+                };
+            }
             reactServerPrerenderResultIsDynamic = null;
             reactServerResumeDataCache = resumeDataCache;
             reactServerPrerenderStore = null;
@@ -5045,9 +5367,9 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // the final prerender.
                 cacheSignal,
                 dynamicTracking: null,
-                revalidate: _constants1.INFINITE_CACHE,
-                expire: _constants1.INFINITE_CACHE,
-                stale: _constants1.INFINITE_CACHE,
+                revalidate: _constants2.INFINITE_CACHE,
+                expire: _constants2.INFINITE_CACHE,
+                stale: _constants2.INFINITE_CACHE,
                 tags: [
                     ...implicitTags.tags
                 ],
@@ -5055,14 +5377,15 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 hmrRefreshHash: undefined,
                 // We don't track vary params during initial prerender, only the final one
                 varyParamsAccumulator: null,
-                runtimeDataAccessed: null,
-                shouldAttemptStaticPrefetch: null,
+                ensureStaticLevel,
+                prerenderDataTracking: null,
                 isFallbackUpgradeable: renderOpts.isFallbackUpgradeable === true
             };
             // 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, {
-                is404: res.statusCode === 404
+            const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPayloadPrerenderStore, _fastsetimmediateexternal.runWithNativeImmediateTracking.bind(null, immediateTracker, getRSCPayload), tree, ctx, {
+                is404: res.statusCode === 404,
+                isPrerendering: true
             });
             const initialServerPrerenderStore = prerenderStore = {
                 type: 'prerender',
@@ -5078,9 +5401,9 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // the final prerender.
                 cacheSignal,
                 dynamicTracking: null,
-                revalidate: _constants1.INFINITE_CACHE,
-                expire: _constants1.INFINITE_CACHE,
-                stale: _constants1.INFINITE_CACHE,
+                revalidate: _constants2.INFINITE_CACHE,
+                expire: _constants2.INFINITE_CACHE,
+                stale: _constants2.INFINITE_CACHE,
                 tags: [
                     ...implicitTags.tags
                 ],
@@ -5088,8 +5411,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 hmrRefreshHash: undefined,
                 // We don't track vary params during initial prerender, only the final one
                 varyParamsAccumulator: null,
-                runtimeDataAccessed: null,
-                shouldAttemptStaticPrefetch: null,
+                ensureStaticLevel,
+                prerenderDataTracking: null,
                 isFallbackUpgradeable: renderOpts.isFallbackUpgradeable === true
             };
             const initialPrerenderOptions = {
@@ -5117,7 +5440,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // transitioning out of the prerender environment
                 signal: initialServerReactController.signal
             };
-            const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, (0, _streamops.getServerPrerender)(ComponentMod), initialServerPayload, clientModules, initialPrerenderOptions);
+            const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, _fastsetimmediateexternal.runWithNativeImmediateTracking.bind(null, immediateTracker, (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.
@@ -5165,9 +5488,9 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     // 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,
+                    revalidate: _constants2.INFINITE_CACHE,
+                    expire: _constants2.INFINITE_CACHE,
+                    stale: _constants2.INFINITE_CACHE,
                     tags: [
                         ...implicitTags.tags
                     ],
@@ -5229,8 +5552,9 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 });
                 // This is mostly needed for dynamic `import()`s in client components.
                 // Promises passed to client were already awaited above (assuming that they came from cached functions)
-                (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
-                await cacheSignal.cacheReady();
+                const clientCacheSignal = new _cachesignal.CacheSignal(null);
+                (0, _trackmoduleloadingexternal.trackPendingModules)(clientCacheSignal);
+                await clientCacheSignal.cacheReady();
                 _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, initialClientReactController.abort.bind(initialClientReactController));
             }
             const finalServerReactController = new AbortController();
@@ -5242,26 +5566,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 syncIO: _stagedrendering.SyncIOMode.AllowedInDynamic,
                 finalStage: _stagedrendering.RenderStage.Static
             });
-            // Records runtime data accesses from the payload and render stores
-            // below into the RSC payload (as `u`), resolved `true` at the moment
-            // of first access so the fulfillment row is serialized at the stream
-            // position where it happened. Used when generating per-segment
-            // prefetch responses. Request data props (params, searchParams) are
-            // created while the RSC payload is constructed, under the payload
-            // store; both stores share the same promise so it observes accesses
-            // from both.
-            const runtimeDataAccessed = (0, _promisewithresolvers.createPromiseWithResolvers)();
-            // Companion cell holding this prerender's static-prefetch measurement
-            // directly — the value that becomes the route's build-constant hint:
-            // starts true, and a disqualifying runtime-data access flips it false
-            // — fallback-param accesses on an upgradeable route don't (see
-            // trackRuntimeDataAccessed, which applies the rule at access time).
-            // Read after the prerender settles by
-            // collectSegmentData below. Shared between both stores for the same
-            // reason as the promise.
-            const shouldAttemptStaticPrefetch = {
-                current: true
-            };
+            const prerenderDataTracking = (0, _dynamicrenderingutils.createPrerenderDataTracking)();
             const finalServerPayloadPrerenderStore = {
                 type: 'prerender',
                 phase: 'render',
@@ -5281,22 +5586,23 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // All caches we could read must already be filled so no tracking is necessary
                 cacheSignal: null,
                 dynamicTracking: null,
-                revalidate: _constants1.INFINITE_CACHE,
-                expire: _constants1.INFINITE_CACHE,
-                stale: _constants1.INFINITE_CACHE,
+                revalidate: _constants2.INFINITE_CACHE,
+                expire: _constants2.INFINITE_CACHE,
+                stale: _constants2.INFINITE_CACHE,
                 tags: [
                     ...implicitTags.tags
                 ],
                 resumeDataCache,
                 hmrRefreshHash: undefined,
                 varyParamsAccumulator,
-                runtimeDataAccessed,
-                shouldAttemptStaticPrefetch,
+                ensureStaticLevel,
+                prerenderDataTracking,
                 isFallbackUpgradeable: renderOpts.isFallbackUpgradeable === true
             };
             const shellByteLengthDeferred = (0, _promisewithresolvers.createPromiseWithResolvers)();
             const finalServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPayloadPrerenderStore, getRSCPayload, tree, ctx, {
                 is404: res.statusCode === 404,
+                isPrerendering: true,
                 shellByteLengthPromise: shellByteLengthDeferred.promise
             });
             let staleTimeIterable;
@@ -5304,12 +5610,10 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 staleTimeIterable = new _staletime.StaleTimeIterable();
                 finalServerPayload.s = staleTimeIterable;
             }
-            if (shouldGenerateStaticFlightData(workStore)) {
-                // Embed the runtime data access tracking in the payload so
-                // collectSegmentData can replay it per stage. Only needed when the
-                // Flight data will be decomposed into segment prefetches below.
-                finalServerPayload.u = runtimeDataAccessed.promise;
-            }
+            // Embed the runtime data access tracking in the payload so
+            // collectSegmentData can replay it per stage. Only needed when the
+            // Flight data will be decomposed into segment prefetches below.
+            finalServerPayload.u = prerenderDataTracking.runtimeDataAccessed.promise;
             const serverDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
             let resultIsPartial = false;
             const finalServerPrerenderStore = prerenderStore = {
@@ -5324,24 +5628,27 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // All caches we could read must already be filled so no tracking is necessary
                 cacheSignal: null,
                 dynamicTracking: serverDynamicTracking,
-                revalidate: _constants1.INFINITE_CACHE,
-                expire: _constants1.INFINITE_CACHE,
-                stale: _constants1.INFINITE_CACHE,
+                revalidate: _constants2.INFINITE_CACHE,
+                expire: _constants2.INFINITE_CACHE,
+                stale: _constants2.INFINITE_CACHE,
                 tags: [
                     ...implicitTags.tags
                 ],
                 resumeDataCache,
                 hmrRefreshHash: undefined,
                 varyParamsAccumulator,
-                runtimeDataAccessed,
-                shouldAttemptStaticPrefetch,
+                ensureStaticLevel,
+                prerenderDataTracking,
                 isFallbackUpgradeable: renderOpts.isFallbackUpgradeable === true
             };
             if (staleTimeIterable !== undefined) {
                 (0, _staletime.trackStaleTime)(finalServerPrerenderStore, staleTimeIterable, selectStaleTime);
             }
             const streamState = createStreamPendingState();
-            const collectedChunks = createPrerenderChunksAccumulator();
+            // On-demand failures need the chunks emitted when React aborts to
+            // complete their Flight payload. Normal partial prerenders still use only
+            // the pre-abort chunks.
+            const collectedChunks = createPrerenderChunksAccumulator(!isBuildTimePrerendering || process.env.NODE_ENV === 'development');
             const collectedChunksByStage = createStageChunksAccumulator();
             const collectChunk = (chunk)=>{
                 collectPrerenderChunk(collectedChunks, finalServerReactController.signal, chunk);
@@ -5372,12 +5679,10 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     if (staleTimeIterable !== undefined) {
                         staleTimeIterable.close();
                     }
-                    runtimeDataAccessed.resolve(false);
                     (0, _varyparams.finishAccumulatingVaryParams)(varyParamsAccumulator);
                 }
             };
             let debugEndTime = undefined;
-            let didLinkDataUnblockNewContent = false;
             await (0, _apprenderrenderutils.runInSequentialTasks)(async ()=>{
                 if (process.env.NODE_ENV === 'development') {
                     // The end time should be tracked whenever we abort.
@@ -5407,7 +5712,14 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 });
                 // Note: this await will only resolve after the last task (unless sync IO aborts the render earlier)
                 // We await it here so that if the stream errors, it's not an unhandled rejection.
-                await iterateStreamingPrerenderChunks(stream, finalServerReactController.signal, collectChunk, streamState);
+                await iterateStreamingPrerenderChunks(stream, finalServerReactController.signal, collectChunk, streamState, collectedChunks.allChunks !== null);
+            }, ()=>{
+                if (checkUnexpectedAbort()) return;
+                // Fold `PrefetchStatic_prefetchApi` into `PrefetchStatic` - no discrimination needed here
+                finalStageController.advanceStage(_stagedrendering.RenderStage.PrefetchStatic);
+            }, ()=>{
+                if (checkUnexpectedAbort()) return;
+                finalStageController.advanceStage(_stagedrendering.RenderStage.NavigationStatic);
             }, ()=>{
                 if (checkUnexpectedAbort()) return;
                 finalStageController.advanceStage(_stagedrendering.RenderStage.Static);
@@ -5416,12 +5728,10 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // Finish the accumulators. We need to wait for Flight to flush the result into the stream,
                 // which is scheduled in a (fast) immediate, so we do this in a separate task
                 // (fast immediates will be drained at the end of the task, so in the next task we know we're done flushing)
-                // If new chunks were emitted in the static stage
-                // (after unblocking link data, i.e. static params)
-                // then the prerender uses link data.
+                // Check if new chunks were emitted after unblocking link data or navigation().
                 // NOTE: we must capture this *before* resolving staleTime/varyParams,
                 // which always emit new static chunks.
-                didLinkDataUnblockNewContent = collectedChunksByStage.staticChunks.length > collectedChunksByStage.shellStaticChunks.length;
+                const hasMoreContentThanShell = collectedChunksByStage[_stagedrendering.RenderStage.Static].length > collectedChunksByStage[_stagedrendering.RenderStage.ShellStatic].length;
                 // 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
@@ -5431,11 +5741,9 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 if (staleTimeIterable !== undefined) {
                     staleTimeIterable.close();
                 }
-                // Idempotent: a no-op if a runtime data access already resolved it
-                // `true`. The `false` row lands here, after all stage content.
-                runtimeDataAccessed.resolve(false);
+                (0, _dynamicrenderingutils.finishPrerenderDataTracking)(prerenderDataTracking);
                 (0, _varyparams.finishAccumulatingVaryParams)(varyParamsAccumulator);
-                shellByteLengthDeferred.resolve(didLinkDataUnblockNewContent ? collectedChunksByStage.shellStaticChunks.reduce((acc, chunk)=>acc + chunk.byteLength, 0) : null);
+                shellByteLengthDeferred.resolve(hasMoreContentThanShell ? collectedChunksByStage[_stagedrendering.RenderStage.ShellStatic].reduce((acc, chunk)=>acc + chunk.byteLength, 0) : null);
             }, ()=>{
                 if (checkUnexpectedAbort()) return;
                 if (streamState.isPending) {
@@ -5455,12 +5763,16 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             const reactServerResult = reactServerPrerenderResult = new _apprenderprerenderutils.ReactServerPrerenderResult(collectedChunks.prerenderChunks);
             reactServerPrerenderResultIsDynamic = resultIsPartial;
             reactServerPrerenderStore = finalServerPrerenderStore;
-            if (shouldGenerateStaticFlightData(workStore)) {
-                metadata.flightData = Buffer.concat(cachedNavigations ? prependIsPartialByteToChunks(reactServerResult.asChunks(), resultIsPartial) : reactServerResult.asChunks());
-                // 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);
+            reactServerRenderChunks = collectedChunks.allChunks;
+            metadata.flightData = Buffer.concat(cachedNavigations ? prependIsPartialByteToChunks(reactServerResult.asChunks(), resultIsPartial) : reactServerResult.asChunks());
+            // collectSegmentData needs the raw flight data without the marker byte.
+            const flightData = cachedNavigations ? metadata.flightData.subarray(1) : metadata.flightData;
+            if (process.env.NEXT_PRIVATE_DEBUG_RUNTIME_DATA) {
+                const { shouldAttemptStaticShell: shellIsStatic, shouldAttemptStaticPrefetch: prefetchIsStatic } = prerenderDataTracking;
+                const label = (isStatic)=>isStatic ? 'static' : 'runtime';
+                console.log(`Route ${workStore.route} :: hints: shell=${label(shellIsStatic)}, prefetch=${label(prefetchIsStatic)}`);
             }
+            await collectSegmentData(flightData, finalServerPrerenderStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
             const clientDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
             const finalClientReactController = new AbortController();
             const finalClientRenderController = new AbortController();
@@ -5475,9 +5787,9 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // No APIs require a cacheSignal through the workUnitStore during the HTML prerender
                 cacheSignal: null,
                 dynamicTracking: clientDynamicTracking,
-                revalidate: _constants1.INFINITE_CACHE,
-                expire: _constants1.INFINITE_CACHE,
-                stale: _constants1.INFINITE_CACHE,
+                revalidate: _constants2.INFINITE_CACHE,
+                expire: _constants2.INFINITE_CACHE,
+                stale: _constants2.INFINITE_CACHE,
                 tags: [
                     ...implicitTags.tags
                 ],
@@ -5486,6 +5798,8 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 // Client prerenders don't track server param access
                 varyParamsAccumulator: null
             };
+            // In a static prerender, we don't know which kind of data caused a dynamic hole.
+            const dynamicHoleKind = _dynamicrendering.DynamicHoleKind.RuntimeOrDynamic;
             let dynamicValidation = (0, _dynamicrendering.createDynamicValidationState)();
             const finalClientOnHeaders = (0, _streamops.createOnHeadersCallback)(appendHeader);
             let { prelude: unprocessedPrelude, postponed } = await (0, _apprenderrenderutils.runInSequentialTasks)(()=>{
@@ -5505,7 +5819,11 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                         if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || finalClientReactController.signal.aborted) {
                             const componentStack = errorInfo.componentStack;
                             if (typeof componentStack === 'string') {
-                                (0, _dynamicrendering.trackAllowedDynamicAccess)(err, workStore, componentStack, dynamicValidation, clientDynamicTracking);
+                                if (ensureStaticLevel === _ensurestatic.EnsureStaticLevel.Navigation) {
+                                    (0, _dynamicrendering.trackDynamicAccessInStaticRoute)(err, workStore, componentStack, dynamicValidation, clientDynamicTracking, resultIsPartial, dynamicHoleKind);
+                                } else {
+                                    (0, _dynamicrendering.trackAllowedDynamicAccess)(err, workStore, componentStack, dynamicValidation, clientDynamicTracking);
+                                }
                             }
                             return;
                         }
@@ -5532,7 +5850,11 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             });
             metadata.hasPendingUi = postponed != null;
             const { prelude, preludeIsEmpty } = await (0, _streamops.processPrelude)(unprocessedPrelude);
-            (0, _dynamicrendering.throwIfDisallowedDynamic)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, dynamicValidation, serverDynamicTracking, allowEmptyStaticShell);
+            if (ensureStaticLevel === _ensurestatic.EnsureStaticLevel.Navigation) {
+                (0, _dynamicrendering.throwIfDisallowedDynamicInStaticRoute)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, dynamicValidation, serverDynamicTracking, isFallbackShell, allowEmptyStaticShell, resultIsPartial);
+            } else {
+                (0, _dynamicrendering.throwIfDisallowedDynamic)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, dynamicValidation, serverDynamicTracking, allowEmptyStaticShell);
+            }
             const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
                 polyfills,
                 renderServerInsertedHTML,
@@ -5542,13 +5864,49 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             });
             let htmlStream = prelude;
             if (resultIsPartial) {
+                if (ensureStaticLevel === _ensurestatic.EnsureStaticLevel.Navigation) {
+                    if (isFallbackShell) {
+                        // TODO(ensure-static): This is a hack, and should be solved in a less rube-goldberg-y way.
+                        // If a fallback shell came out partial, we can't serve it without a resume,
+                        // which we can't do with `ensureStatic = "navigation"`, so force the HTML to be empty.
+                        const emptyHtml = new Uint8Array([]);
+                        const emptyHtmlStream = new ReadableStream({
+                            start (controller) {
+                                controller.enqueue(emptyHtml);
+                                controller.close();
+                            }
+                        });
+                        // We don't have a HTML postponed state.
+                        // This should not be used anyway, but in case we somehow
+                        // end up serving a fallback, make it usable
+                        metadata.hasPendingUi = true;
+                        metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(resumeDataCache, cacheComponents, renderOpts.experimental.maxPostponedStateSizeBytes, renderOpts.experimental.disableResumeDataCacheCompression, fallbackRouteParams);
+                        return {
+                            error: undefined,
+                            digestErrorsMap: new Map(),
+                            ssrErrors: [],
+                            stream: emptyHtmlStream,
+                            dynamicAccess: undefined,
+                            collectedRevalidate: finalServerPrerenderStore.revalidate,
+                            collectedExpire: finalServerPrerenderStore.expire,
+                            collectedStale: selectStaleTime(finalServerPrerenderStore.stale),
+                            collectedTags: finalServerPrerenderStore.tags,
+                            renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache)
+                        };
+                    } else {
+                        // If the result is partial, we should've errored when validating the prerender.
+                        console.error(new _invarianterror.InvariantError(`Route "${workStore.route}": Server result cannot be partial when \`ensureStatic = "navigation"\` is set on the route.`));
+                        throw new _staticgenerationbailout.StaticGenBailoutError();
+                    }
+                }
                 if (postponed != null) {
-                    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, resumeDataCache, cacheComponents, renderOpts.experimental.maxPostponedStateSizeBytes, renderOpts.experimental.disableResumeDataCacheCompression);
                 } else {
-                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(resumeDataCache, cacheComponents);
+                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(resumeDataCache, cacheComponents, renderOpts.experimental.maxPostponedStateSizeBytes, renderOpts.experimental.disableResumeDataCacheCompression, fallbackRouteParams);
                 }
                 reactServerResult.consume();
                 return {
+                    error: undefined,
                     digestErrorsMap: reactServerErrorsByDigest,
                     ssrErrors: allCapturedErrors,
                     stream: await (0, _streamops.continueDynamicPrerender)(htmlStream, {
@@ -5578,7 +5936,7 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                     nonce: nonce,
                     images: ctx.renderOpts.images
                 }), JSON.parse(JSON.stringify(postponed)), {
-                    signal: (0, _dynamicrendering.createRenderInBrowserAbortSignal)(),
+                    signal: (0, _renderinbrowser.createRenderInBrowserAbortSignal)(ctx.renderOpts.experimental.reactBrowserBailout),
                     onError: htmlRendererErrorHandler,
                     nonce
                 });
@@ -5586,14 +5944,11 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 htmlStream = (0, _streamops.chainStreams)(prelude, resumePrelude);
             }
             if (workStore.forceDynamic) {
-                throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError('Invariant: a Page with `dynamic = "force-dynamic"` did not trigger the dynamic pathway. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
-                    value: "E598",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _staticgenerationbailout.StaticGenBailoutError('Invariant: a Page with `dynamic = "force-dynamic"` did not trigger the dynamic pathway. This is a bug in Next.js');
             }
             const stream = await continueStaticPrerenderWithInlinedData(htmlStream, reactServerResult, fallbackRouteParams, createInlinedDataStream, formState, nonce, getServerInsertedHTML, getServerInsertedMetadata, ctx.sharedContext.deploymentId, ComponentMod, renderFlightStream, clientModules, filterStackFrame, serverComponentsErrorHandler);
             return {
+                error: undefined,
                 digestErrorsMap: reactServerErrorsByDigest,
                 ssrErrors: allCapturedErrors,
                 stream,
@@ -5604,204 +5959,15 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 collectedTags: finalServerPrerenderStore.tags,
                 renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache)
             };
-        } else if (experimental.isRoutePPREnabled) {
-            // We're statically generating with PPR and need to do dynamic tracking
-            let dynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
-            const resumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
-            const pprReactServerPrerenderStore = prerenderStore = {
-                type: 'prerender-ppr',
-                phase: 'render',
-                rootParams,
-                fallbackRouteParams,
-                implicitTags,
-                dynamicTracking,
-                revalidate: _constants1.INFINITE_CACHE,
-                expire: _constants1.INFINITE_CACHE,
-                stale: _constants1.INFINITE_CACHE,
-                tags: [
-                    ...implicitTags.tags
-                ],
-                resumeDataCache
-            };
-            const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(pprReactServerPrerenderStore, getRSCPayload, tree, ctx, {
-                is404: res.statusCode === 404
-            });
-            let reactServerResult;
-            reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(pprReactServerPrerenderStore, renderFlightStream, ComponentMod, RSCPayload, clientModules, {
-                filterStackFrame,
-                onError: serverComponentsErrorHandler
-            }));
-            const ssrPrerenderStore = {
-                type: 'prerender-ppr',
-                phase: 'render',
-                rootParams,
-                fallbackRouteParams,
-                implicitTags,
-                dynamicTracking,
-                revalidate: _constants1.INFINITE_CACHE,
-                expire: _constants1.INFINITE_CACHE,
-                stale: _constants1.INFINITE_CACHE,
-                tags: [
-                    ...implicitTags.tags
-                ],
-                resumeDataCache
-            };
-            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,
-                debugEndTime: undefined,
-                preinitScripts: preinitScripts,
-                ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
-                nonce: nonce,
-                images: ctx.renderOpts.images
-            }), {
-                onError: htmlRendererErrorHandler,
-                onHeaders: pprOnHeaders,
-                maxHeadersLength: reactMaxHeadersLength,
-                bootstrapScriptContent,
-                bootstrapScripts: [
-                    bootstrapScript
-                ]
-            });
-            metadata.hasPendingUi = postponed != null;
-            const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
-                polyfills,
-                renderServerInsertedHTML,
-                serverCapturedErrors: allCapturedErrors,
-                basePath,
-                tracingMetadata: tracingMetadata
-            });
-            // 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, _streamops.streamToBuffer)(reactServerResult.asStream());
-            if (shouldGenerateStaticFlightData(workStore)) {
-                metadata.flightData = flightData;
-                await collectSegmentData(flightData, ssrPrerenderStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
-            }
-            const { prelude, preludeIsEmpty } = await (0, _streamops.processPrelude)(unprocessedPrelude);
-            /**
-       * When prerendering there are three outcomes to consider
-       *
-       *   Dynamic HTML:      The prerender has dynamic holes (caused by using Next.js Dynamic Rendering APIs)
-       *                      We will need to resume this result when requests are handled and we don't include
-       *                      any server inserted HTML or inlined flight data in the static HTML
-       *
-       *   Dynamic Data:      The prerender has no dynamic holes but dynamic APIs were used. We will not
-       *                      resume this render when requests are handled but we will generate new inlined
-       *                      flight data since it is dynamic and differences may end up reconciling on the client
-       *
-       *   Static:            The prerender has no dynamic holes and no dynamic APIs were used. We statically encode
-       *                      all server inserted HTML and flight data
-       */ // First we check if we have any dynamic holes in our HTML prerender
-            if ((0, _dynamicrendering.accessedDynamicData)(dynamicTracking.dynamicAccesses)) {
-                if (postponed != null) {
-                    // Dynamic HTML case.
-                    metadata.postponed = await (0, _postponedstate.getDynamicHTMLPostponedState)(postponed, preludeIsEmpty ? _postponedstate.DynamicHTMLPreludeState.Empty : _postponedstate.DynamicHTMLPreludeState.Full, fallbackRouteParams, resumeDataCache, cacheComponents);
-                } else {
-                    // Dynamic Data case.
-                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(resumeDataCache, cacheComponents);
-                }
-                // Regardless of whether this is the Dynamic HTML or Dynamic Data case we need to ensure we include
-                // server inserted html in the static response because the html that is part of the prerender may depend on it
-                // 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, _streamops.continueDynamicPrerender)(prelude, pprDynamicOpts),
-                    dynamicAccess: dynamicTracking.dynamicAccesses,
-                    // TODO: Should this include the SSR pass?
-                    collectedRevalidate: pprReactServerPrerenderStore.revalidate,
-                    collectedExpire: pprReactServerPrerenderStore.expire,
-                    collectedStale: selectStaleTime(pprReactServerPrerenderStore.stale),
-                    collectedTags: pprReactServerPrerenderStore.tags
-                };
-            } else if (fallbackRouteParams && fallbackRouteParams.size > 0) {
-                // Rendering the fallback case.
-                metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(resumeDataCache, cacheComponents);
-                const pprFallbackDynamicOpts = {
-                    getServerInsertedHTML,
-                    getServerInsertedMetadata,
-                    deploymentId: ctx.sharedContext.deploymentId
-                };
-                return {
-                    digestErrorsMap: reactServerErrorsByDigest,
-                    ssrErrors: allCapturedErrors,
-                    stream: await (0, _streamops.continueDynamicPrerender)(prelude, pprFallbackDynamicOpts),
-                    dynamicAccess: dynamicTracking.dynamicAccesses,
-                    // TODO: Should this include the SSR pass?
-                    collectedRevalidate: pprReactServerPrerenderStore.revalidate,
-                    collectedExpire: pprReactServerPrerenderStore.expire,
-                    collectedStale: selectStaleTime(pprReactServerPrerenderStore.stale),
-                    collectedTags: pprReactServerPrerenderStore.tags
-                };
-            } else {
-                // Static case
-                // We still have not used any dynamic APIs. At this point we can produce an entirely static prerender response
-                if (workStore.forceDynamic) {
-                    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError('Invariant: a Page with `dynamic = "force-dynamic"` did not trigger the dynamic pathway. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
-                        value: "E598",
-                        enumerable: false,
-                        configurable: true
-                    });
-                }
-                let htmlStream = prelude;
-                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 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,
-                        debugEndTime: undefined,
-                        preinitScripts: ()=>{},
-                        ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
-                        nonce: nonce,
-                        images: ctx.renderOpts.images
-                    }), JSON.parse(JSON.stringify(postponed)), {
-                        signal: (0, _dynamicrendering.createRenderInBrowserAbortSignal)(),
-                        onError: htmlRendererErrorHandler,
-                        nonce
-                    });
-                    // First we write everything from the prerender, then we write everything from the aborted resume render
-                    htmlStream = (0, _streamops.chainStreams)(prelude, resumePrelude);
-                }
-                return {
-                    digestErrorsMap: reactServerErrorsByDigest,
-                    ssrErrors: allCapturedErrors,
-                    stream: await (0, _streamops.continueStaticPrerender)(htmlStream, {
-                        inlinedDataStream: createInlinedDataStream(reactServerResult.consumeAsStream(), nonce, formState),
-                        getServerInsertedHTML,
-                        getServerInsertedMetadata,
-                        deploymentId: ctx.sharedContext.deploymentId
-                    }),
-                    dynamicAccess: dynamicTracking.dynamicAccesses,
-                    // TODO: Should this include the SSR pass?
-                    collectedRevalidate: pprReactServerPrerenderStore.revalidate,
-                    collectedExpire: pprReactServerPrerenderStore.expire,
-                    collectedStale: selectStaleTime(pprReactServerPrerenderStore.stale),
-                    collectedTags: pprReactServerPrerenderStore.tags
-                };
-            }
         } else {
             const prerenderLegacyStore = prerenderStore = {
                 type: 'prerender-legacy',
                 phase: 'render',
                 rootParams,
                 implicitTags,
-                revalidate: _constants1.INFINITE_CACHE,
-                expire: _constants1.INFINITE_CACHE,
-                stale: _constants1.INFINITE_CACHE,
+                revalidate: _constants2.INFINITE_CACHE,
+                expire: _constants2.INFINITE_CACHE,
+                stale: _constants2.INFINITE_CACHE,
                 tags: [
                     ...implicitTags.tags
                 ]
@@ -5809,7 +5975,8 @@ 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, {
-                is404: res.statusCode === 404
+                is404: res.statusCode === 404,
+                isPrerendering: true
             });
             let reactServerResult;
             reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, renderFlightStream, ComponentMod, RSCPayload, clientModules, {
@@ -5835,11 +6002,9 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             }, {
                 waitForAllReady: true
             });
-            if (shouldGenerateStaticFlightData(workStore)) {
-                const flightData = await (0, _streamops.streamToBuffer)(reactServerResult.asStream());
-                metadata.flightData = flightData;
-                await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
-            }
+            const flightData = await (0, _streamops.streamToBuffer)(reactServerResult.asStream());
+            metadata.flightData = flightData;
+            await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
             const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
                 polyfills,
                 renderServerInsertedHTML,
@@ -5848,11 +6013,12 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 tracingMetadata: tracingMetadata
             });
             return {
+                error: undefined,
                 digestErrorsMap: reactServerErrorsByDigest,
                 ssrErrors: allCapturedErrors,
                 stream: await (0, _streamops.continueFizzStream)(htmlStream, {
                     inlinedDataStream: createInlinedDataStream(reactServerResult.consumeAsStream(), nonce, formState),
-                    isStaticGeneration: true,
+                    waitForAllReady: true,
                     getServerInsertedHTML,
                     getServerInsertedMetadata,
                     deploymentId: ctx.sharedContext.deploymentId
@@ -5865,13 +6031,13 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             };
         }
     } catch (err) {
-        if ((0, _staticgenerationbailout.isStaticGenBailoutError)(err) || typeof err === 'object' && err !== null && 'message' in err && typeof err.message === 'string' && err.message.includes('https://nextjs.org/docs/advanced-features/static-html-export')) {
-            // Ensure that "next dev" prints the red error overlay
+        if (isBuildTimePrerendering && (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')) {
+            // Preserve build-time bailouts and errors about features that cannot be
+            // used with output: 'export'.
             throw err;
         }
-        // If this is a static generation error, we need to throw it so that it
-        // can be handled by the caller if we're in static generation mode.
-        if ((0, _hooksservercontext.isDynamicServerError)(err)) {
+        // Let the build detect dynamic routes from legacy prerender bailouts.
+        if (isBuildTimePrerendering && (0, _hooksservercontext.isDynamicServerError)(err)) {
             throw err;
         }
         // If a bailout made it to this point, it means it wasn't wrapped inside
@@ -5882,30 +6048,36 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             (0, _log.error)(`${err.reason} should be wrapped in a suspense boundary at page "${pagePath}". Read more: https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout\n${stack}`);
             throw err;
         }
+        if (ctx.renderOpts.experimental.reactBrowserBailout) {
+            // React preserves the reason passed to browser() as the fatal error's cause.
+            const browserBailoutReason = (0, _reactbrowserbailout.getReactBrowserBailoutReason)(err);
+            if (browserBailoutReason !== undefined) {
+                const stack = (0, _formatservererror.getStackWithoutErrorMessage)(err);
+                (0, _log.error)(`${browserBailoutReason} should be wrapped in a suspense boundary at page "${pagePath}". Read more: https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout\n${stack}`);
+                throw new _staticgenerationbailout.StaticGenBailoutError();
+            }
+        }
         // If we errored when we did not have an RSC stream to read from. This is
         // not just a render error, we need to throw early.
         if (reactServerPrerenderResult === null) {
             throw err;
         }
-        let errorType;
-        const isHTTPAccessFallback = (0, _httpaccessfallback.isHTTPAccessFallbackError)(err);
-        const isRedirect = (0, _redirecterror.isRedirectError)(err);
-        if (isHTTPAccessFallback) {
-            res.statusCode = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
-            metadata.statusCode = res.statusCode;
-            errorType = (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)(res.statusCode);
-        } else if (isRedirect) {
-            errorType = 'redirect';
-            res.statusCode = (0, _redirect.getRedirectStatusCodeFromError)(err);
-            metadata.statusCode = res.statusCode;
-            const redirectUrl = (0, _addpathprefix.addPathPrefix)((0, _redirect.getURLFromRedirectError)(err), basePath);
-            setHeader('location', redirectUrl);
-        } else {
+        if (!isBuildTimePrerendering && (0, _staticgenerationbailout.isStaticGenBailoutError)(err) && reactServerRenderChunks !== null) {
+            // The streaming renderer emits a shared error chunk and references to it
+            // for unfinished Flight tasks when aborted. Include these chunks so
+            // recovery does not leave the client waiting for a resume. Normal partial
+            // prerenders omit these chunks.
+            reactServerPrerenderResult = new _apprenderprerenderutils.ReactServerPrerenderResult(reactServerRenderChunks);
+            reactServerPrerenderResultIsDynamic = false;
+            metadata.flightData = Buffer.concat(cachedNavigations ? prependIsPartialByteToChunks(reactServerRenderChunks, false) : reactServerRenderChunks);
+        }
+        const errorType = setHTTPAccessFallbackOrRedirectStatus(err);
+        if (errorType === undefined) {
             res.statusCode = 500;
             metadata.statusCode = res.statusCode;
-        }
-        if (cacheComponents && !isHTTPAccessFallback && !isRedirect) {
-            throw reactServerErrorsByDigest.get(err.digest) ?? err;
+            if (cacheComponents && (isBuildTimePrerendering || reactServerPrerenderResultIsDynamic === null)) {
+                throw reactServerErrorsByDigest.get(err == null ? void 0 : err.digest) ?? err;
+            }
         }
         const [errorPreinitScripts, errorBootstrapScript] = (0, _requiredscripts.getRequiredScripts)(buildManifest, assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, false), nonce, _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY);
         const errorBootstrapScriptContent = buildManifest.pagesChunkGroupBootstrapParams && buildManifest.chunkLoadingGlobal ? (0, _getpagefiles.getTurbopackChunkGroupBootstrap)(buildManifest.pagesChunkGroupBootstrapParams, buildManifest.chunkLoadingGlobal, [
@@ -5917,32 +6089,16 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             const originalResumeDataCache = reactServerResumeDataCache;
             const originalPrerenderStore = reactServerPrerenderStore;
             if (originalFlightPrerenderResult === null) {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Cache Components error recovery expected an original Flight prerender result'), "__NEXT_ERROR_CODE", {
-                    value: "E1283",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Cache Components error recovery expected an original Flight prerender result');
             }
             if (originalFlightPrerenderResultIsDynamic === null) {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Cache Components error recovery expected to know whether the original Flight prerender result was dynamic'), "__NEXT_ERROR_CODE", {
-                    value: "E1282",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Cache Components error recovery expected to know whether the original Flight prerender result was dynamic');
             }
             if (originalResumeDataCache === null) {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Cache Components error recovery expected an original resume data cache'), "__NEXT_ERROR_CODE", {
-                    value: "E1285",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Cache Components error recovery expected an original resume data cache');
             }
             if (originalPrerenderStore === null) {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Cache Components error recovery expected an original prerender store'), "__NEXT_ERROR_CODE", {
-                    value: "E1284",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Cache Components error recovery expected an original prerender store');
             }
             const originalCollectedStale = selectStaleTime(originalPrerenderStore.stale);
             // The final recovery still belongs to Cache Components. Render the error
@@ -5963,20 +6119,20 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 stagedRendering: null,
                 cacheSignal: null,
                 dynamicTracking: errorServerDynamicTracking,
-                revalidate: typeof (prerenderStore == null ? void 0 : prerenderStore.revalidate) !== 'undefined' ? prerenderStore.revalidate : _constants1.INFINITE_CACHE,
-                expire: typeof (prerenderStore == null ? void 0 : prerenderStore.expire) !== 'undefined' ? prerenderStore.expire : _constants1.INFINITE_CACHE,
-                stale: typeof (prerenderStore == null ? void 0 : prerenderStore.stale) !== 'undefined' ? prerenderStore.stale : _constants1.INFINITE_CACHE,
+                revalidate: typeof (prerenderStore == null ? void 0 : prerenderStore.revalidate) !== 'undefined' ? prerenderStore.revalidate : _constants2.INFINITE_CACHE,
+                expire: typeof (prerenderStore == null ? void 0 : prerenderStore.expire) !== 'undefined' ? prerenderStore.expire : _constants2.INFINITE_CACHE,
+                stale: typeof (prerenderStore == null ? void 0 : prerenderStore.stale) !== 'undefined' ? prerenderStore.stale : _constants2.INFINITE_CACHE,
                 tags: [
                     ...(prerenderStore == null ? void 0 : prerenderStore.tags) || implicitTags.tags
                 ],
                 resumeDataCache: originalResumeDataCache,
                 hmrRefreshHash: undefined,
                 varyParamsAccumulator: null,
-                runtimeDataAccessed: null,
-                shouldAttemptStaticPrefetch: null,
+                ensureStaticLevel: null,
+                prerenderDataTracking: null,
                 isFallbackUpgradeable: renderOpts.isFallbackUpgradeable === true
             };
-            const errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(errorPrerenderStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err.digest) ? undefined : err, errorType, // The recovery shell only bootstraps the original Flight data. Avoid
+            const errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(errorPrerenderStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err == null ? void 0 : err.digest) ? undefined : err, errorType, // The recovery shell only bootstraps the original Flight data. Avoid
             // blocking that shell on error-page metadata or viewport.
             false);
             const errorServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)((0, _apprenderrenderutils.runInSequentialTasks)(async ()=>{
@@ -6082,10 +6238,13 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                 });
                 let errorHtmlStream = prelude;
                 if (originalFlightPrerenderResultIsDynamic) {
-                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(originalResumeDataCache, cacheComponents);
+                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(originalResumeDataCache, cacheComponents, renderOpts.experimental.maxPostponedStateSizeBytes, renderOpts.experimental.disableResumeDataCacheCompression, fallbackRouteParams);
                     originalFlightPrerenderResult.consume();
                     errorServerResult.consume();
                     return {
+                        error: errorType !== undefined ? undefined : {
+                            thrownValue: err
+                        },
                         digestErrorsMap: reactServerErrorsByDigest,
                         ssrErrors: allCapturedErrors,
                         stream: await (0, _streamops.continueDynamicPrerender)(errorHtmlStream, {
@@ -6113,22 +6272,21 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
                         nonce: nonce,
                         images: ctx.renderOpts.images
                     }), JSON.parse(JSON.stringify(errorPostponed)), {
-                        signal: (0, _dynamicrendering.createRenderInBrowserAbortSignal)(),
+                        signal: (0, _renderinbrowser.createRenderInBrowserAbortSignal)(ctx.renderOpts.experimental.reactBrowserBailout),
                         onError: htmlRendererErrorHandler,
                         nonce
                     });
                     errorHtmlStream = (0, _streamops.chainStreams)(prelude, resumePrelude);
                 }
                 if (workStore.forceDynamic) {
-                    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError('Invariant: a Page with `dynamic = "force-dynamic"` did not trigger the dynamic pathway. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
-                        value: "E598",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new _staticgenerationbailout.StaticGenBailoutError('Invariant: a Page with `dynamic = "force-dynamic"` did not trigger the dynamic pathway. This is a bug in Next.js');
                 }
                 const stream = await continueStaticPrerenderWithInlinedData(errorHtmlStream, originalFlightPrerenderResult, fallbackRouteParams, createInlinedDataStream, formState, nonce, getServerInsertedHTML, getServerInsertedMetadata, ctx.sharedContext.deploymentId, ComponentMod, renderFlightStream, clientModules, filterStackFrame, serverComponentsErrorHandler);
                 errorServerResult.consume();
                 return {
+                    error: errorType !== undefined ? undefined : {
+                        thrownValue: err
+                    },
                     digestErrorsMap: reactServerErrorsByDigest,
                     ssrErrors: allCapturedErrors,
                     stream,
@@ -6152,14 +6310,14 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             phase: 'render',
             rootParams,
             implicitTags: implicitTags,
-            revalidate: typeof (prerenderStore == null ? void 0 : prerenderStore.revalidate) !== 'undefined' ? prerenderStore.revalidate : _constants1.INFINITE_CACHE,
-            expire: typeof (prerenderStore == null ? void 0 : prerenderStore.expire) !== 'undefined' ? prerenderStore.expire : _constants1.INFINITE_CACHE,
-            stale: typeof (prerenderStore == null ? void 0 : prerenderStore.stale) !== 'undefined' ? prerenderStore.stale : _constants1.INFINITE_CACHE,
+            revalidate: typeof (prerenderStore == null ? void 0 : prerenderStore.revalidate) !== 'undefined' ? prerenderStore.revalidate : _constants2.INFINITE_CACHE,
+            expire: typeof (prerenderStore == null ? void 0 : prerenderStore.expire) !== 'undefined' ? prerenderStore.expire : _constants2.INFINITE_CACHE,
+            stale: typeof (prerenderStore == null ? void 0 : prerenderStore.stale) !== 'undefined' ? prerenderStore.stale : _constants2.INFINITE_CACHE,
             tags: [
                 ...(prerenderStore == null ? void 0 : prerenderStore.tags) || implicitTags.tags
             ]
         };
-        const errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err.digest) ? undefined : err, errorType, // Legacy prerender recovery should include the error payload head.
+        const errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err == null ? void 0 : err.digest) ? undefined : err, errorType, // Legacy prerender recovery should include the error payload head.
         true);
         const errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, renderFlightStream, ComponentMod, errorRSCPayload, clientModules, {
             filterStackFrame,
@@ -6183,17 +6341,16 @@ async function prerenderToStream(req, res, ctx, metadata, tree, fallbackRoutePar
             }, {
                 waitForAllReady: true
             });
-            if (shouldGenerateStaticFlightData(workStore)) {
-                const flightData = await (0, _streamops.streamToBuffer)(reactServerPrerenderResult.asStream());
-                metadata.flightData = flightData;
-                await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
-            }
+            const flightData = await (0, _streamops.streamToBuffer)(reactServerPrerenderResult.asStream());
+            metadata.flightData = flightData;
+            await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts, ctx.pagePath, metadata);
             return {
+                error: undefined,
                 digestErrorsMap: reactServerErrorsByDigest,
                 ssrErrors: allCapturedErrors,
                 stream: await (0, _streamops.continueFizzStream)(errorHtmlStream, {
                     inlinedDataStream: createInlinedDataStream(reactServerPrerenderResult.consumeAsStream(), nonce, formState),
-                    isStaticGeneration: true,
+                    waitForAllReady: true,
                     getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
                         polyfills,
                         renderServerInsertedHTML,
@@ -6228,11 +6385,7 @@ function createStreamPendingState() {
     return {
         get isPending () {
             if (_isPending === undefined) {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Expected stream state to be initialized before reading'), "__NEXT_ERROR_CODE", {
-                    value: "E1281",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Expected stream state to be initialized before reading');
             }
             return _isPending;
         },
@@ -6241,22 +6394,18 @@ function createStreamPendingState() {
         }
     };
 }
-function createPrerenderChunksAccumulator() {
+function createPrerenderChunksAccumulator(collectAllChunks = process.env.NODE_ENV === 'development') {
     return {
         // Chunks emitted before aborting the render.
         prerenderChunks: [],
-        // In dev, we also collect chunks that the render emits after aborting,
-        // because they can contain debug info for chunks that did not
-        // resolve during the prerender. However, unlike a prerender, a render
-        // will also error all the pending chunks (instead of halting),
-        // so have to use something like `createNodeStreamWithLateRelease`
-        // to make the errors unobservable.
-        allChunks: process.env.NODE_ENV === 'development' ? [] : null
+        // The complete render includes abort errors for pending components.
+        // Recovery uses these errors; development validation delays them with
+        // createNodeStreamWithLateRelease to expose only debug information.
+        allChunks: collectAllChunks ? [] : null
     };
 }
 function collectPrerenderChunk(chunks, signal, chunk) {
-    var // ...but if they contain debug info, we still want to collect them
-    // to improve error messages.
+    var // Retain the complete stream when recovery or debug information needs it.
     _chunks_allChunks;
     // The chunks emitted after an abort are not part of the prerender...
     if (!signal.aborted) {
@@ -6264,15 +6413,13 @@ function collectPrerenderChunk(chunks, signal, chunk) {
     }
     (_chunks_allChunks = chunks.allChunks) == null ? void 0 : _chunks_allChunks.push(chunk);
 }
-async function iterateStreamingPrerenderChunks(stream, signal, onChunk, streamState) {
+async function iterateStreamingPrerenderChunks(stream, signal, onChunk, streamState, drainAfterAbort = process.env.NODE_ENV === 'development') {
     if (stream instanceof ReadableStream) {
         const reader = stream.getReader();
         if (streamState) {
             streamState.isPending = true;
         }
-        // In production, there's no debug info, so we don't need to capture
-        // anything emitted after the abort and can cancel immediately.
-        if (process.env.NODE_ENV !== 'development') {
+        if (!drainAfterAbort) {
             signal.addEventListener('abort', ()=>{
                 reader.cancel(signal.reason);
             }, {
@@ -6295,9 +6442,7 @@ async function iterateStreamingPrerenderChunks(stream, signal, onChunk, streamSt
             streamState.isPending = true;
         }
         let cancelled = false;
-        // In production, there's no debug info, so we don't need to capture
-        // anything emitted after the abort and can cancel immediately.
-        if (process.env.NODE_ENV !== 'development') {
+        if (!drainAfterAbort) {
             signal.addEventListener('abort', ()=>{
                 if (!cancelled) {
                     cancelled = true;
@@ -6325,11 +6470,7 @@ async function iterateStreamingPrerenderChunks(stream, signal, onChunk, streamSt
 const getGlobalErrorStyles = async (tree, ctx)=>{
     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
-        });
+        throw new Error('Invariant: global-error module is required but not found in loader tree');
     }
     const { componentMod: { createElement } } = ctx;
     // Get the GlobalError component and styles from the loader tree
@@ -6407,22 +6548,16 @@ async function collectSegmentData(fullPageDataBuffer, prerenderStore, ComponentM
     let hints;
     const prefetchInlining = renderOpts.experimental.prefetchInlining;
     if (renderOpts.isBuildTimePrerendering) {
-        // Whether the client should attempt a static prefetch for this route
-        // (PrefetchHint.ShouldAttemptStaticPrefetch): the prerender store's
-        // cell holds the hint value directly — true iff the build-time
-        // prerender accessed no runtime data that disqualifies a static
-        // attempt. The fallback-param upgradeability rule is applied at access
-        // time — see trackRuntimeDataAccessed — so only the settled value is
-        // read here. Only the modern (cacheComponents) prerender tracks
-        // accesses; legacy prerenders conservatively never set the hint.
-        const hintCell = prerenderStore.type === 'prerender' ? prerenderStore.shouldAttemptStaticPrefetch : null;
-        const shouldAttemptStaticPrefetch = hintCell !== null && hintCell.current;
-        if (prefetchInlining || shouldAttemptStaticPrefetch) {
+        // Whether the client should attempt to use static requests for
+        // shells and prefetches. Only applies in routes with Partial Prefetching.
+        const prerenderDataTracking = prerenderStore.type === 'prerender' ? prerenderStore.prerenderDataTracking : null;
+        const { shouldAttemptStaticShell = false, shouldAttemptStaticPrefetch = false } = prerenderDataTracking ?? {};
+        if (prefetchInlining || shouldAttemptStaticShell || shouldAttemptStaticPrefetch) {
             // Build time: compute fresh hints and store in metadata for the
             // manifest. When prefetch inlining is disabled there are no sizes to
             // measure, but the static-prefetch hint still rides the manifest —
             // collectPrefetchHints then only builds the tree shape carrying it.
-            hints = await ComponentMod.collectPrefetchHints(fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, prefetchInlining, shouldAttemptStaticPrefetch);
+            hints = await ComponentMod.collectPrefetchHints(renderOpts.cacheComponents, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, prefetchInlining, shouldAttemptStaticShell, shouldAttemptStaticPrefetch);
             metadata.prefetchHints = hints;
         } else {
             // Inlining is disabled and the hint didn't qualify — there's nothing
@@ -6479,10 +6614,10 @@ async function collectSegmentData(fullPageDataBuffer, prerenderStore, ComponentM
     const fallbackRouteParams = 'fallbackRouteParams' in prerenderStore ? prerenderStore.fallbackRouteParams : null;
     const isUpgradeableISRFallback = fallbackRouteParams != null && fallbackRouteParams.size > 0 && renderOpts.isFallbackUpgradeable === true;
     // Pass the resolved hints so collectSegmentData can union them into
-    // the TreePrefetch. During the initial build the FlightRouterState in
+    // the /_tree response. During the initial build the transport tree 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.
+    // are already embedded in the buffer's tree, so this is null.
     metadata.segmentData = await ComponentMod.collectSegmentData(renderOpts.cacheComponents, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest, Boolean(renderOpts.experimental.prefetchInlining), hints, isUpgradeableISRFallback);
 }
 function isBypassingCachesInDev(requestStore, workStore) {