maxsimcli 1.2.2 → 1.3.0

package/dist/assets/dashboard/node_modules/next/dist/server/app-render/app-render.js

@@ -0,0 +1,2953 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderToHTMLOrFlight", {
+    enumerable: true,
+    get: function() {
+        return renderToHTMLOrFlight;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _renderresult = /*#__PURE__*/ _interop_require_default(require("../render-result"));
+const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
+const _internalutils = require("../internal-utils");
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _metadatacontext = require("../../lib/metadata/metadata-context");
+const _requeststore = require("../async-storage/request-store");
+const _workstore = require("../async-storage/work-store");
+const _httpaccessfallback = require("../../client/components/http-access-fallback/http-access-fallback");
+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 _tracer = require("../lib/trace/tracer");
+const _flightrenderresult = require("./flight-render-result");
+const _createerrorhandler = require("./create-error-handler");
+const _getshortdynamicparamtype = require("./get-short-dynamic-param-type");
+const _getsegmentparam = require("./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 _actionhandler = require("./action-handler");
+const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
+const _log = require("../../build/output/log");
+const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
+const _serverinsertedhtml = require("./server-inserted-html");
+const _requiredscripts = require("./required-scripts");
+const _addpathprefix = require("../../shared/lib/router/utils/add-path-prefix");
+const _makegetserverinsertedhtml = require("./make-get-server-inserted-html");
+const _walktreewithflightrouterstate = require("./walk-tree-with-flight-router-state");
+const _createcomponenttree = require("./create-component-tree");
+const _getassetquerystring = require("./get-asset-query-string");
+const _encryptionutils = require("./encryption-utils");
+const _postponedstate = require("./postponed-state");
+const _hooksservercontext = require("../../client/components/hooks-server-context");
+const _useflightresponse = require("./use-flight-response");
+const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
+const _formatservererror = require("../../lib/format-server-error");
+const _dynamicrendering = require("./dynamic-rendering");
+const _clientcomponentrendererlogger = require("../client-component-renderer-logger");
+const _actionutils = require("./action-utils");
+const _helpers = require("../base-http/helpers");
+const _parserelativeurl = require("../../shared/lib/router/utils/parse-relative-url");
+const _approuter = /*#__PURE__*/ _interop_require_default(require("../../client/components/app-router"));
+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");
+const _segment = require("../../shared/lib/segment");
+const _apprenderprerenderutils = require("./app-render-prerender-utils");
+const _prospectiverenderutils = require("./prospective-render-utils");
+const _apprenderrenderutils = require("./app-render-render-utils");
+const _scheduler = require("../../lib/scheduler");
+const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
+const _cachesignal = require("./cache-signal");
+const _utils1 = require("../lib/trace/utils");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _constants1 = require("../../lib/constants");
+const _createcomponentstylesandscripts = require("./create-component-styles-and-scripts");
+const _parseloadertree = require("./parse-loader-tree");
+const _resumedatacache = require("../resume-data-cache/resume-data-cache");
+const _iserror = /*#__PURE__*/ _interop_require_default(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");
+const _segmentexplorerpath = require("./segment-explorer-path");
+const _requestmeta = require("../request-meta");
+const _getdynamicparam = require("../../shared/lib/router/utils/get-dynamic-param");
+const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 isDevWarmupRequest = options.isDevWarmup === true;
+    // dev warmup requests are treated as prefetch RSC requests
+    // runtime prefetch requests are *not* treated as prefetch requests
+    // (TODO: this is confusing, we should refactor this to express this better)
+    const isPrefetchRequest = isDevWarmupRequest || headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '1';
+    const isRuntimePrefetchRequest = headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '2';
+    const isHmrRefresh = headers[_approuterheaders.NEXT_HMR_REFRESH_HEADER] !== undefined;
+    // dev warmup requests are treated as prefetch RSC requests
+    const isRSCRequest = isDevWarmupRequest || headers[_approuterheaders.RSC_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 = 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);
+    return {
+        flightRouterState,
+        isPrefetchRequest,
+        isRuntimePrefetchRequest,
+        isRouteTreePrefetchRequest,
+        isHmrRefresh,
+        isRSCRequest,
+        isDevWarmupRequest,
+        nonce,
+        previouslyRevalidatedTags
+    };
+}
+function createNotFoundLoaderTree(loaderTree) {
+    const components = loaderTree[2];
+    const hasGlobalNotFound = !!components['global-not-found'];
+    return [
+        '',
+        {
+            children: [
+                _segment.PAGE_SEGMENT_KEY,
+                {},
+                {
+                    page: components['global-not-found'] ?? components['not-found']
+                }
+            ]
+        },
+        // When global-not-found is present, skip layout from components
+        hasGlobalNotFound ? components : {}
+    ];
+}
+/**
+ * Returns a function that parses the dynamic segment and return the associated value.
+ */ function makeGetDynamicParamFromSegment(params, pagePath, fallbackRouteParams) {
+    return function getDynamicParamFromSegment(// [slug] / [[slug]] / [...slug]
+    segment) {
+        const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
+        if (!segmentParam) {
+            return null;
+        }
+        const segmentKey = segmentParam.param;
+        const dynamicParamType = _getshortdynamicparamtype.dynamicParamTypes[segmentParam.type];
+        return (0, _getdynamicparam.getDynamicParam)(params, segmentKey, dynamicParamType, pagePath, fallbackRouteParams);
+    };
+}
+function NonIndex({ pagePath, statusCode, isPossibleServerAction }) {
+    const is404Page = pagePath === '/404';
+    const isInvalidStatusCode = typeof statusCode === 'number' && statusCode > 400;
+    // Only render noindex for page request, skip for server actions
+    // TODO: is this correct if `isPossibleServerAction` is a false positive?
+    if (!isPossibleServerAction && (is404Page || isInvalidStatusCode)) {
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+            name: "robots",
+            content: "noindex"
+        });
+    }
+    return null;
+}
+/**
+ * This is used by server actions & client-side navigations to generate RSC data from a client-side request.
+ * 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 = '';
+    const { componentMod: { tree: loaderTree, createMetadataComponents, MetadataBoundary, ViewportBoundary }, getDynamicParamFromSegment, appUsingSizeAdjustment, query, requestId, flightRouterState, workStore, url } = ctx;
+    const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
+    if (!(options == null ? void 0 : options.skipFlight)) {
+        const preloadCallbacks = [];
+        const { ViewportTree, MetadataTree, getViewportReady, getMetadataReady, StreamingMetadataOutlet } = createMetadataComponents({
+            tree: loaderTree,
+            parsedQuery: query,
+            pathname: url.pathname,
+            metadataContext: (0, _metadatacontext.createMetadataContext)(ctx.renderOpts),
+            getDynamicParamFromSegment,
+            appUsingSizeAdjustment,
+            workStore,
+            MetadataBoundary,
+            ViewportBoundary,
+            serveStreamingMetadata
+        });
+        flightData = (await (0, _walktreewithflightrouterstate.walkTreeWithFlightRouterState)({
+            ctx,
+            loaderTreeToFilter: loaderTree,
+            parentParams: {},
+            flightRouterState,
+            // For flight, render metadata inside leaf page
+            rscHead: /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(NonIndex, {
+                        pagePath: ctx.pagePath,
+                        statusCode: ctx.res.statusCode,
+                        isPossibleServerAction: ctx.isPossibleServerAction
+                    }),
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(ViewportTree, {}, getFlightViewportKey(requestId)),
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(MetadataTree, {}, getFlightMetadataKey(requestId))
+                ]
+            }, flightDataPathHeadKey),
+            injectedCSS: new Set(),
+            injectedJS: new Set(),
+            injectedFontPreloadTags: new Set(),
+            rootLayoutIncluded: false,
+            getViewportReady,
+            getMetadataReady,
+            preloadCallbacks,
+            StreamingMetadataOutlet
+        })).map((path)=>path.slice(1)) // remove the '' (root) segment
+        ;
+    }
+    // If we have an action result, then this is a server action response.
+    // We can rely on this because `ActionResult` will always be a promise, even if
+    // the result is falsey.
+    if (options == null ? void 0 : options.actionResult) {
+        return {
+            a: options.actionResult,
+            f: flightData,
+            b: ctx.sharedContext.buildId
+        };
+    }
+    // Otherwise, it's a regular RSC response.
+    return {
+        b: ctx.sharedContext.buildId,
+        f: flightData,
+        S: workStore.isStaticGeneration
+    };
+}
+function createErrorContext(ctx, renderSource) {
+    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)
+    };
+}
+/**
+ * Produces a RenderResult containing the Flight data for the given request. See
+ * `generateDynamicRSCPayload` for information on the contents of the render result.
+ */ async function generateDynamicFlightRenderResult(req, ctx, requestStore, options) {
+    const renderOpts = ctx.renderOpts;
+    function onFlightDataRenderError(err) {
+        return renderOpts.onInstrumentationRequestError == null ? void 0 : renderOpts.onInstrumentationRequestError.call(renderOpts, err, req, createErrorContext(ctx, 'react-server-components-payload'));
+    }
+    const onError = (0, _createerrorhandler.createFlightReactServerErrorHandler)(!!renderOpts.dev, onFlightDataRenderError);
+    const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, options);
+    // For app dir, use the bundled version of Flight server renderer (renderToReadableStream)
+    // which contains the subset React.
+    const flightReadableStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ctx.componentMod.renderToReadableStream, RSCPayload, ctx.clientReferenceManifest.clientModules, {
+        onError,
+        temporaryReferences: options == null ? void 0 : options.temporaryReferences,
+        filterStackFrame
+    });
+    return new _flightrenderresult.FlightRenderResult(flightReadableStream, {
+        fetchMetrics: ctx.workStore.fetchMetrics
+    });
+}
+async function generateRuntimePrefetchResult(req, res, ctx, requestStore) {
+    const { workStore } = ctx;
+    const renderOpts = ctx.renderOpts;
+    function onFlightDataRenderError(err) {
+        return renderOpts.onInstrumentationRequestError == null ? void 0 : renderOpts.onInstrumentationRequestError.call(renderOpts, err, req, // TODO(runtime-ppr): should we use a different value?
+        createErrorContext(ctx, 'react-server-components-payload'));
+    }
+    const onError = (0, _createerrorhandler.createFlightReactServerErrorHandler)(false, onFlightDataRenderError);
+    const metadata = {};
+    const generatePayload = ()=>generateDynamicRSCPayload(ctx, undefined);
+    const { componentMod: { tree }, getDynamicParamFromSegment } = ctx;
+    const rootParams = (0, _createcomponenttree.getRootParams)(tree, 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)();
+    // We're not resuming an existing render.
+    const renderResumeDataCache = null;
+    await prospectiveRuntimeServerPrerender(ctx, generatePayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, requestStore.cookies, requestStore.draftMode);
+    const response = await finalRuntimeServerPrerender(ctx, generatePayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, requestStore.cookies, requestStore.draftMode, onError);
+    applyMetadataFromPrerenderResult(response, metadata, workStore);
+    metadata.fetchMetrics = ctx.workStore.fetchMetrics;
+    if (response.isPartial) {
+        res.setHeader(_approuterheaders.NEXT_DID_POSTPONE_HEADER, '1');
+    }
+    return new _flightrenderresult.FlightRenderResult(response.result.prelude, metadata);
+}
+async function prospectiveRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, cookies, draftMode) {
+    const { implicitTags, renderOpts, workStore } = ctx;
+    const { clientReferenceManifest, ComponentMod } = renderOpts;
+    assertClientReferenceManifest(clientReferenceManifest);
+    // Prerender controller represents the lifetime of the prerender.
+    // It will be aborted when a Task is complete or a synchronously aborting
+    // API is called. Notably during cache-filling renders this does not actually
+    // terminate the render itself which will continue until all caches are filled
+    const initialServerPrerenderController = new AbortController();
+    // This controller represents the lifetime of the React render call. Notably
+    // during the cache-filling render it is different from the prerender controller
+    // because we don't want to end the react render until all caches are filled.
+    const initialServerRenderController = new AbortController();
+    // The cacheSignal helps us track whether caches are still filling or we are ready
+    // to cut the render off.
+    const cacheSignal = new _cachesignal.CacheSignal();
+    const initialServerPrerenderStore = {
+        type: 'prerender-runtime',
+        phase: 'render',
+        rootParams,
+        implicitTags,
+        renderSignal: initialServerRenderController.signal,
+        controller: initialServerPrerenderController,
+        // During the initial prerender we need to track all cache reads to ensure
+        // we render long enough to fill every cache it is possible to visit during
+        // the final prerender.
+        cacheSignal,
+        // We only need to track dynamic accesses during the final prerender.
+        dynamicTracking: null,
+        // Runtime prefetches are never cached server-side, only client-side,
+        // so we set `expire` and `revalidate` to their minimum values just in case.
+        revalidate: 1,
+        expire: 0,
+        stale: _constants1.INFINITE_CACHE,
+        tags: [
+            ...implicitTags.tags
+        ],
+        renderResumeDataCache,
+        prerenderResumeDataCache,
+        hmrRefreshHash: undefined,
+        captureOwnerStack: undefined,
+        // We only need task sequencing in the final prerender.
+        runtimeStagePromise: null,
+        // These are not present in regular prerenders, but allowed in a runtime prerender.
+        cookies,
+        draftMode
+    };
+    // We're not going to use the result of this render because the only time it could be used
+    // is if it completes in a microtask and that's likely very rare for any non-trivial app
+    const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, getPayload);
+    const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientReferenceManifest.clientModules, {
+        filterStackFrame,
+        onError: (err)=>{
+            const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
+            if (digest) {
+                return digest;
+            }
+            if (initialServerPrerenderController.signal.aborted) {
+                // The render aborted before this error was handled which indicates
+                // the error is caused by unfinished components within the render
+                return;
+            } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+            }
+        },
+        // we don't care to track postpones during the prospective render because we need
+        // to always do a final render anyway
+        onPostpone: undefined,
+        // We don't want to stop rendering until the cacheSignal is complete so we pass
+        // a different signal to this render call than is used by dynamic APIs to signify
+        // transitioning out of the prerender environment
+        signal: initialServerRenderController.signal
+    });
+    // Wait for all caches to be finished filling and for async imports to resolve
+    (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+    await cacheSignal.cacheReady();
+    initialServerRenderController.abort();
+    initialServerPrerenderController.abort();
+    // We don't need to continue the prerender process if we already
+    // detected invalid dynamic usage in the initial prerender phase.
+    if (workStore.invalidDynamicUsageError) {
+        throw workStore.invalidDynamicUsageError;
+    }
+    try {
+        return await (0, _apprenderprerenderutils.createReactServerPrerenderResult)(pendingInitialServerResult);
+    } catch (err) {
+        if (initialServerRenderController.signal.aborted || initialServerPrerenderController.signal.aborted) {
+        // These are expected errors that might error the prerender. we ignore them.
+        } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+            // We don't normally log these errors because we are going to retry anyway but
+            // it can be useful for debugging Next.js itself to get visibility here when needed
+            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+        }
+        return null;
+    }
+}
+async function finalRuntimeServerPrerender(ctx, getPayload, prerenderResumeDataCache, renderResumeDataCache, rootParams, cookies, draftMode, onError) {
+    const { implicitTags, renderOpts } = ctx;
+    const { clientReferenceManifest, ComponentMod, experimental, isDebugDynamicAccesses } = renderOpts;
+    assertClientReferenceManifest(clientReferenceManifest);
+    const selectStaleTime = createSelectStaleTime(experimental);
+    let serverIsDynamic = false;
+    const finalServerController = new AbortController();
+    const serverDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
+    const { promise: runtimeStagePromise, resolve: resolveBlockedRuntimeAPIs } = (0, _promisewithresolvers.createPromiseWithResolvers)();
+    const finalServerPrerenderStore = {
+        type: 'prerender-runtime',
+        phase: 'render',
+        rootParams,
+        implicitTags,
+        renderSignal: finalServerController.signal,
+        controller: finalServerController,
+        // All caches we could read must already be filled so no tracking is necessary
+        cacheSignal: null,
+        dynamicTracking: serverDynamicTracking,
+        // Runtime prefetches are never cached server-side, only client-side,
+        // so we set `expire` and `revalidate` to their minimum values just in case.
+        revalidate: 1,
+        expire: 0,
+        stale: _constants1.INFINITE_CACHE,
+        tags: [
+            ...implicitTags.tags
+        ],
+        prerenderResumeDataCache,
+        renderResumeDataCache,
+        hmrRefreshHash: undefined,
+        captureOwnerStack: undefined,
+        // Used to separate the "Static" stage from the "Runtime" stage.
+        runtimeStagePromise,
+        // These are not present in regular prerenders, but allowed in a runtime prerender.
+        cookies,
+        draftMode
+    };
+    const finalRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPrerenderStore, getPayload);
+    let prerenderIsPending = true;
+    const result = await (0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasksWithStages)(async ()=>{
+        // Static stage
+        const prerenderResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPrerenderStore, ComponentMod.prerender, finalRSCPayload, clientReferenceManifest.clientModules, {
+            filterStackFrame,
+            onError,
+            signal: finalServerController.signal
+        });
+        prerenderIsPending = false;
+        return prerenderResult;
+    }, ()=>{
+        // Advance to the runtime stage.
+        //
+        // We make runtime APIs hang during the first task (above), and unblock them in the following task (here).
+        // This makes sure that, at this point, we'll have finished all the static parts (what we'd prerender statically).
+        // We know that they don't contain any incorrect sync IO, because that'd have caused a build error.
+        // After we unblock Runtime APIs, if we encounter sync IO (e.g. `await cookies(); Date.now()`),
+        // we'll abort, but we'll produce at least as much output as a static prerender would.
+        resolveBlockedRuntimeAPIs();
+    }, ()=>{
+        // Abort.
+        if (finalServerController.signal.aborted) {
+            // If the server controller is already aborted we must have called something
+            // that required aborting the prerender synchronously such as with new Date()
+            serverIsDynamic = true;
+            return;
+        }
+        if (prerenderIsPending) {
+            // If prerenderIsPending then we have blocked for longer than a Task and we assume
+            // there is something unfinished.
+            serverIsDynamic = true;
+        }
+        finalServerController.abort();
+    });
+    (0, _dynamicrendering.warnOnSyncDynamicError)(serverDynamicTracking);
+    return {
+        result,
+        // TODO(runtime-ppr): do we need to produce a digest map here?
+        // digestErrorsMap: ...,
+        dynamicAccess: serverDynamicTracking,
+        isPartial: serverIsDynamic,
+        collectedRevalidate: finalServerPrerenderStore.revalidate,
+        collectedExpire: finalServerPrerenderStore.expire,
+        collectedStale: selectStaleTime(finalServerPrerenderStore.stale),
+        collectedTags: finalServerPrerenderStore.tags
+    };
+}
+/**
+ * Performs a "warmup" render of the RSC payload for a given route. This function is called by the server
+ * prior to an actual render request in Dev mode only. It's purpose is to fill caches so the actual render
+ * can accurately log activity in the right render context (Prerender vs Render).
+ *
+ * At the moment this implementation is mostly a fork of generateDynamicFlightRenderResult
+ */ async function warmupDevRender(req, ctx) {
+    const { clientReferenceManifest, componentMod: ComponentMod, getDynamicParamFromSegment, implicitTags, renderOpts, workStore } = ctx;
+    const { allowEmptyStaticShell = false, dev, onInstrumentationRequestError } = renderOpts;
+    if (!dev) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('generateDynamicFlightRenderResult should never be called in `next start` mode.'), "__NEXT_ERROR_CODE", {
+            value: "E523",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const rootParams = (0, _createcomponenttree.getRootParams)(ComponentMod.tree, getDynamicParamFromSegment);
+    function onFlightDataRenderError(err) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'));
+    }
+    const onError = (0, _createerrorhandler.createFlightReactServerErrorHandler)(true, onFlightDataRenderError);
+    // We're doing a dev warmup, so we should create a new resume data cache so
+    // we can fill it.
+    const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+    const renderController = new AbortController();
+    const prerenderController = new AbortController();
+    const reactController = new AbortController();
+    const cacheSignal = new _cachesignal.CacheSignal();
+    const prerenderStore = {
+        type: 'prerender',
+        phase: 'render',
+        rootParams,
+        implicitTags,
+        renderSignal: renderController.signal,
+        controller: prerenderController,
+        cacheSignal,
+        dynamicTracking: null,
+        allowEmptyStaticShell,
+        revalidate: _constants1.INFINITE_CACHE,
+        expire: _constants1.INFINITE_CACHE,
+        stale: _constants1.INFINITE_CACHE,
+        tags: [],
+        prerenderResumeDataCache,
+        renderResumeDataCache: null,
+        hmrRefreshHash: req.cookies[_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE],
+        captureOwnerStack: ComponentMod.captureOwnerStack,
+        // warmup is a dev only feature and no fallback params are used in the
+        // primary render which is static. We only use a prerender store here to
+        // allow the warmup to halt on Request data APIs and fetches.
+        fallbackRouteParams: null
+    };
+    const rscPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderStore, generateDynamicRSCPayload, ctx);
+    // For app dir, use the bundled version of Flight server renderer (renderToReadableStream)
+    // which contains the subset React.
+    _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderStore, ComponentMod.renderToReadableStream, rscPayload, clientReferenceManifest.clientModules, {
+        filterStackFrame,
+        onError,
+        signal: renderController.signal
+    });
+    // Wait for all caches to be finished filling and for async imports to resolve
+    (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+    await cacheSignal.cacheReady();
+    // We unset the cache so any late over-run renders aren't able to write into this cache
+    prerenderStore.prerenderResumeDataCache = null;
+    // Abort the render
+    reactController.abort();
+    renderController.abort();
+    // We don't really want to return a result here but the stack of functions
+    // that calls into renderToHTML... expects a result. We should refactor this to
+    // lift the warmup pathway outside of renderToHTML... but for now this suffices
+    return new _flightrenderresult.FlightRenderResult('', {
+        fetchMetrics: workStore.fetchMetrics,
+        renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(prerenderResumeDataCache)
+    });
+}
+/**
+ * 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.
+ * This function splits up the pathname so that we can later join it on
+ * when we're ready to consume the path.
+ */ function prepareInitialCanonicalUrl(url) {
+    return (url.pathname + url.search).split('/');
+}
+// This is the data necessary to render <AppRouter /> when no SSR errors are encountered
+async function getRSCPayload(tree, ctx, is404) {
+    const injectedCSS = new Set();
+    const injectedJS = new Set();
+    const injectedFontPreloadTags = new Set();
+    let missingSlots;
+    // We only track missing parallel slots in development
+    if (process.env.NODE_ENV === 'development') {
+        missingSlots = new Set();
+    }
+    const { getDynamicParamFromSegment, query, appUsingSizeAdjustment, componentMod: { createMetadataComponents, MetadataBoundary, ViewportBoundary }, url, workStore } = ctx;
+    const initialTree = (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(tree, getDynamicParamFromSegment, query);
+    const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
+    const hasGlobalNotFound = !!tree[2]['global-not-found'];
+    const { ViewportTree, MetadataTree, getViewportReady, getMetadataReady, StreamingMetadataOutlet } = createMetadataComponents({
+        tree,
+        // When it's using global-not-found, metadata errorType is undefined, which will retrieve the
+        // metadata from the page.
+        // When it's using not-found, metadata errorType is 'not-found', which will retrieve the
+        // metadata from the not-found.js boundary.
+        // TODO: remove this condition and keep it undefined when global-not-found is stabilized.
+        errorType: is404 && !hasGlobalNotFound ? 'not-found' : undefined,
+        parsedQuery: query,
+        pathname: url.pathname,
+        metadataContext: (0, _metadatacontext.createMetadataContext)(ctx.renderOpts),
+        getDynamicParamFromSegment,
+        appUsingSizeAdjustment,
+        workStore,
+        MetadataBoundary,
+        ViewportBoundary,
+        serveStreamingMetadata
+    });
+    const preloadCallbacks = [];
+    const seedData = await (0, _createcomponenttree.createComponentTree)({
+        ctx,
+        loaderTree: tree,
+        parentParams: {},
+        injectedCSS,
+        injectedJS,
+        injectedFontPreloadTags,
+        rootLayoutIncluded: false,
+        getViewportReady,
+        getMetadataReady,
+        missingSlots,
+        preloadCallbacks,
+        authInterrupts: ctx.renderOpts.experimental.authInterrupts,
+        StreamingMetadataOutlet
+    });
+    // When the `vary` response header is present with `Next-URL`, that means there's a chance
+    // it could respond differently if there's an interception route. We provide this information
+    // to `AppRouter` so that it can properly seed the prefetch cache with a prefix, if needed.
+    const varyHeader = ctx.res.getHeader('vary');
+    const couldBeIntercepted = typeof varyHeader === 'string' && varyHeader.includes(_approuterheaders.NEXT_URL);
+    const initialHead = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(NonIndex, {
+                pagePath: ctx.pagePath,
+                statusCode: ctx.res.statusCode,
+                isPossibleServerAction: ctx.isPossibleServerAction
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(ViewportTree, {}),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(MetadataTree, {})
+        ]
+    }, flightDataPathHeadKey);
+    const { GlobalError, styles: globalErrorStyles } = await getGlobalErrorStyles(tree, ctx);
+    // Assume the head we're rendering contains only partial data if PPR is
+    // enabled and this is a statically generated response. This is used by the
+    // 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;
+    return {
+        // See the comment above the `Preloads` component (below) for why this is part of the payload
+        P: /*#__PURE__*/ (0, _jsxruntime.jsx)(Preloads, {
+            preloadCallbacks: preloadCallbacks
+        }),
+        b: ctx.sharedContext.buildId,
+        p: ctx.assetPrefix,
+        c: prepareInitialCanonicalUrl(url),
+        i: !!couldBeIntercepted,
+        f: [
+            [
+                initialTree,
+                seedData,
+                initialHead,
+                isPossiblyPartialHead
+            ]
+        ],
+        m: missingSlots,
+        G: [
+            GlobalError,
+            globalErrorStyles
+        ],
+        s: typeof ctx.renderOpts.postponed === 'string',
+        S: workStore.isStaticGeneration
+    };
+}
+/**
+ * Preload calls (such as `ReactDOM.preloadStyle` and `ReactDOM.preloadFont`) need to be called during rendering
+ * in order to create the appropriate preload tags in the DOM, otherwise they're a no-op. Since we invoke
+ * renderToReadableStream with a function that returns component props rather than a component itself, we use
+ * this component to "render  " the preload calls.
+ */ function Preloads({ preloadCallbacks }) {
+    preloadCallbacks.forEach((preloadFn)=>preloadFn());
+    return null;
+}
+// This is the data necessary to render <AppRouter /> when an error state is triggered
+async function getErrorRSCPayload(tree, ctx, ssrError, errorType) {
+    const { getDynamicParamFromSegment, query, appUsingSizeAdjustment, componentMod: { createMetadataComponents, MetadataBoundary, ViewportBoundary }, url, workStore } = ctx;
+    const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
+    const { MetadataTree, ViewportTree } = createMetadataComponents({
+        tree,
+        parsedQuery: query,
+        pathname: url.pathname,
+        metadataContext: (0, _metadatacontext.createMetadataContext)(ctx.renderOpts),
+        errorType,
+        getDynamicParamFromSegment,
+        appUsingSizeAdjustment,
+        workStore,
+        MetadataBoundary,
+        ViewportBoundary,
+        serveStreamingMetadata: serveStreamingMetadata
+    });
+    const initialHead = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_react.default.Fragment, {
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(NonIndex, {
+                pagePath: ctx.pagePath,
+                statusCode: ctx.res.statusCode,
+                isPossibleServerAction: ctx.isPossibleServerAction
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(ViewportTree, {}),
+            process.env.NODE_ENV === 'development' && /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+                name: "next-error",
+                content: "not-found"
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(MetadataTree, {})
+        ]
+    }, flightDataPathHeadKey);
+    const initialTree = (0, _createflightrouterstatefromloadertree.createFlightRouterStateFromLoaderTree)(tree, 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
+        });
+    }
+    // For metadata notFound error there's no global not found boundary on top
+    // so we create a not found page with AppRouter
+    const seedData = [
+        initialTree[0],
+        /*#__PURE__*/ (0, _jsxruntime.jsxs)("html", {
+            id: "__next_error__",
+            children: [
+                /*#__PURE__*/ (0, _jsxruntime.jsx)("head", {}),
+                /*#__PURE__*/ (0, _jsxruntime.jsx)("body", {
+                    children: process.env.NODE_ENV !== 'production' && err ? /*#__PURE__*/ (0, _jsxruntime.jsx)("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
+    ];
+    const { GlobalError, styles: globalErrorStyles } = await getGlobalErrorStyles(tree, ctx);
+    const isPossiblyPartialHead = workStore.isStaticGeneration && ctx.renderOpts.experimental.isRoutePPREnabled === true;
+    return {
+        b: ctx.sharedContext.buildId,
+        p: ctx.assetPrefix,
+        c: prepareInitialCanonicalUrl(url),
+        m: undefined,
+        i: false,
+        f: [
+            [
+                initialTree,
+                seedData,
+                initialHead,
+                isPossiblyPartialHead
+            ]
+        ],
+        G: [
+            GlobalError,
+            globalErrorStyles
+        ],
+        s: typeof ctx.renderOpts.postponed === 'string',
+        S: workStore.isStaticGeneration
+    };
+}
+function assertClientReferenceManifest(clientReferenceManifest) {
+    if (!clientReferenceManifest) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected clientReferenceManifest to be defined.'), "__NEXT_ERROR_CODE", {
+            value: "E692",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+// This component must run in an SSR context. It will render the RSC root component
+function App({ reactServerStream, preinitScripts, clientReferenceManifest, ServerInsertedHTMLProvider, nonce }) {
+    preinitScripts();
+    const response = _react.default.use((0, _useflightresponse.useFlightStream)(reactServerStream, clientReferenceManifest, nonce));
+    const initialState = (0, _createinitialrouterstate.createInitialRouterState)({
+        // This is not used during hydration, so we don't have to pass a
+        // real timestamp.
+        navigatedAt: -1,
+        initialFlightData: response.f,
+        initialCanonicalUrlParts: response.c,
+        initialParallelRoutes: new Map(),
+        // location is not initialized in the SSR render
+        // it's set to window.location during hydration
+        location: null,
+        couldBeIntercepted: response.i,
+        postponed: response.s,
+        prerendered: response.S
+    });
+    const actionQueue = (0, _approuterinstance.createMutableActionQueue)(initialState, null);
+    const { HeadManagerContext } = require('../../shared/lib/head-manager-context.shared-runtime');
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(HeadManagerContext.Provider, {
+        value: {
+            appDir: true,
+            nonce
+        },
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(ServerInsertedHTMLProvider, {
+            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_approuter.default, {
+                actionQueue: actionQueue,
+                globalErrorState: response.G,
+                assetPrefix: response.p
+            })
+        })
+    });
+}
+// @TODO our error stream should be probably just use the same root component. But it was previously
+// different I don't want to figure out if that is meaningful at this time so just keeping the behavior
+// consistent for now.
+function ErrorApp({ reactServerStream, preinitScripts, clientReferenceManifest, ServerInsertedHTMLProvider, nonce }) {
+    preinitScripts();
+    const response = _react.default.use((0, _useflightresponse.useFlightStream)(reactServerStream, clientReferenceManifest, nonce));
+    const initialState = (0, _createinitialrouterstate.createInitialRouterState)({
+        // This is not used during hydration, so we don't have to pass a
+        // real timestamp.
+        navigatedAt: -1,
+        initialFlightData: response.f,
+        initialCanonicalUrlParts: response.c,
+        initialParallelRoutes: new Map(),
+        // location is not initialized in the SSR render
+        // it's set to window.location during hydration
+        location: null,
+        couldBeIntercepted: response.i,
+        postponed: response.s,
+        prerendered: response.S
+    });
+    const actionQueue = (0, _approuterinstance.createMutableActionQueue)(initialState, null);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(ServerInsertedHTMLProvider, {
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_approuter.default, {
+            actionQueue: actionQueue,
+            globalErrorState: response.G,
+            assetPrefix: response.p
+        })
+    });
+}
+async function renderToHTMLOrFlightImpl(req, res, url, pagePath, query, renderOpts, workStore, parsedRequestHeaders, postponedState, serverComponentsHmrCache, sharedContext, fallbackRouteParams) {
+    const isNotFoundPath = pagePath === '/404';
+    if (isNotFoundPath) {
+        res.statusCode = 404;
+    }
+    // A unique request timestamp used by development to ensure that it's
+    // consistent and won't change during this request. This is important to
+    // avoid that resources can be deduped by React Float if the same resource is
+    // rendered or preloaded multiple times: `<link href="a.css?v={Date.now()}"/>`.
+    const requestTimestamp = Date.now();
+    const { clientReferenceManifest, serverActionsManifest, ComponentMod, nextFontManifest, serverActions, assetPrefix = '', enableTainting } = renderOpts;
+    // We need to expose the bundled `require` API globally for
+    // react-server-dom-webpack. This is a hack until we find a better way.
+    if (ComponentMod.__next_app__) {
+        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
+        // module loading from causing a prerender to abort too early.
+        const shouldTrackModuleLoading = ()=>{
+            if (!renderOpts.experimental.cacheComponents) {
+                return false;
+            }
+            if (renderOpts.dev) {
+                return true;
+            }
+            const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+            if (!workUnitStore) {
+                return false;
+            }
+            switch(workUnitStore.type){
+                case 'prerender':
+                case 'prerender-client':
+                case 'prerender-runtime':
+                case 'cache':
+                case 'private-cache':
+                    return true;
+                case 'prerender-ppr':
+                case 'prerender-legacy':
+                case 'request':
+                case 'unstable-cache':
+                    return false;
+                default:
+                    workUnitStore;
+            }
+        };
+        const __next_require__ = (...args)=>{
+            const exportsOrPromise = instrumented.require(...args);
+            if (shouldTrackModuleLoading()) {
+                // requiring an async module returns a promise.
+                (0, _trackmoduleloadingexternal.trackPendingImport)(exportsOrPromise);
+            }
+            return exportsOrPromise;
+        };
+        // @ts-expect-error
+        globalThis.__next_require__ = __next_require__;
+        const __next_chunk_load__ = (...args)=>{
+            const loadingChunk = instrumented.loadChunk(...args);
+            if (shouldTrackModuleLoading()) {
+                (0, _trackmoduleloadingexternal.trackPendingChunkLoad)(loadingChunk);
+            }
+            return loadingChunk;
+        };
+        // @ts-expect-error
+        globalThis.__next_chunk_load__ = __next_chunk_load__;
+    }
+    if (process.env.NODE_ENV === 'development') {
+        // reset isr status at start of request
+        const { pathname } = new URL(req.url || '/', 'http://n');
+        renderOpts.setIsrStatus == null ? void 0 : renderOpts.setIsrStatus.call(renderOpts, pathname, null);
+    }
+    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)) {
+        res.onClose(()=>{
+            // We stop tracking fetch metrics when the response closes, since we
+            // 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
+    };
+    const appUsingSizeAdjustment = !!(nextFontManifest == null ? void 0 : nextFontManifest.appUsingSizeAdjust);
+    assertClientReferenceManifest(clientReferenceManifest);
+    const serverModuleMap = (0, _actionutils.createServerModuleMap)({
+        serverActionsManifest
+    });
+    (0, _encryptionutils.setReferenceManifestsSingleton)({
+        page: workStore.page,
+        clientReferenceManifest,
+        serverActionsManifest,
+        serverModuleMap
+    });
+    ComponentMod.patchFetch();
+    // Pull out the hooks/references from the component.
+    const { tree: loaderTree, taintObjectReference } = ComponentMod;
+    if (enableTainting) {
+        taintObjectReference('Do not pass process.env to Client Components since it will leak sensitive data', process.env);
+    }
+    workStore.fetchMetrics = [];
+    metadata.fetchMetrics = workStore.fetchMetrics;
+    // don't modify original query object
+    query = {
+        ...query
+    };
+    (0, _internalutils.stripInternalQueries)(query);
+    const { flightRouterState, isPrefetchRequest, isRuntimePrefetchRequest, isRSCRequest, isDevWarmupRequest, isHmrRefresh, nonce } = parsedRequestHeaders;
+    const { isStaticGeneration } = workStore;
+    /**
+   * The metadata items array created in next-app-loader with all relevant information
+   * that we need to resolve the final metadata.
+   */ let requestId;
+    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();
+    }
+    /**
+   * Dynamic parameters. E.g. when you visit `/dashboard/vercel` which is rendered by `/dashboard/[slug]` the value will be {"slug": "vercel"}.
+   */ const params = renderOpts.params ?? {};
+    const getDynamicParamFromSegment = makeGetDynamicParamFromSegment(params, pagePath, fallbackRouteParams);
+    const isPossibleActionRequest = (0, _serveractionrequestmeta.getIsPossibleServerAction)(req);
+    const implicitTags = await (0, _implicittags.getImplicitTags)(workStore.page, url, fallbackRouteParams);
+    const ctx = {
+        componentMod: ComponentMod,
+        url,
+        renderOpts,
+        workStore,
+        parsedRequestHeaders,
+        getDynamicParamFromSegment,
+        query,
+        isPrefetch: isPrefetchRequest,
+        isPossibleServerAction: isPossibleActionRequest,
+        requestTimestamp,
+        appUsingSizeAdjustment,
+        flightRouterState,
+        requestId,
+        pagePath,
+        clientReferenceManifest,
+        assetPrefix,
+        isNotFoundPath,
+        nonce,
+        res,
+        sharedContext,
+        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;
+        }
+        // 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;
+        }
+        const options = {
+            metadata,
+            contentType: _constants1.HTML_CONTENT_TYPE_HEADER
+        };
+        // If we have pending revalidates, wait until they are all resolved.
+        if (workStore.pendingRevalidates || workStore.pendingRevalidateWrites || workStore.pendingRevalidatedTags) {
+            const pendingPromise = (0, _revalidationutils.executeRevalidates)(workStore).finally(()=>{
+                if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
+                    console.log('pending revalidates promise finished for:', url);
+                }
+            });
+            if (renderOpts.waitUntil) {
+                renderOpts.waitUntil(pendingPromise);
+            } else {
+                options.waitUntil = pendingPromise;
+            }
+        }
+        applyMetadataFromPrerenderResult(response, metadata, workStore);
+        if (response.renderResumeDataCache) {
+            metadata.renderResumeDataCache = response.renderResumeDataCache;
+        }
+        return new _renderresult.default(await (0, _nodewebstreamshelper.streamToString)(response.stream), options);
+    } else {
+        // We're rendering dynamically
+        const renderResumeDataCache = renderOpts.renderResumeDataCache ?? (postponedState == null ? void 0 : postponedState.renderResumeDataCache);
+        const rootParams = (0, _createcomponenttree.getRootParams)(loaderTree, ctx.getDynamicParamFromSegment);
+        const devValidatingFallbackParams = (0, _requestmeta.getRequestMeta)(req, 'devValidatingFallbackParams') || null;
+        const requestStore = (0, _requeststore.createRequestStoreForRender)(req, res, url, rootParams, implicitTags, renderOpts.onUpdateCookies, renderOpts.previewProps, isHmrRefresh, serverComponentsHmrCache, renderResumeDataCache, devValidatingFallbackParams);
+        if (process.env.NODE_ENV === 'development' && renderOpts.setIsrStatus && // 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) && !isDevWarmupRequest) {
+            const setIsrStatus = renderOpts.setIsrStatus;
+            req.originalRequest.on('end', ()=>{
+                if (!requestStore.usedDynamic && !workStore.forceDynamic) {
+                    // only node can be ISR so we only need to update the status here
+                    const { pathname } = new URL(req.url || '/', 'http://n');
+                    setIsrStatus(pathname, true);
+                }
+            });
+        }
+        if (isDevWarmupRequest) {
+            return warmupDevRender(req, ctx);
+        } else if (isRSCRequest) {
+            if (isRuntimePrefetchRequest) {
+                return generateRuntimePrefetchResult(req, res, ctx, requestStore);
+            } else {
+                return generateDynamicFlightRenderResult(req, ctx, requestStore);
+            }
+        }
+        const renderToStreamWithTracing = (0, _tracer.getTracer)().wrap(_constants.AppRenderSpan.getBodyResult, {
+            spanName: `render route (app) ${pagePath}`,
+            attributes: {
+                'next.route': pagePath
+            }
+        }, renderToStream);
+        let 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,
+                serverModuleMap,
+                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 renderToStreamWithTracing(requestStore, req, res, ctx, notFoundLoaderTree, formState, postponedState, metadata, devValidatingFallbackParams);
+                    return new _renderresult.default(stream, {
+                        metadata,
+                        contentType: _constants1.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;
+                    }
+                }
+            }
+        }
+        const options = {
+            metadata,
+            contentType: _constants1.HTML_CONTENT_TYPE_HEADER
+        };
+        const stream = await renderToStreamWithTracing(requestStore, req, res, ctx, loaderTree, formState, postponedState, metadata, devValidatingFallbackParams);
+        // Invalid dynamic usages should only error the request in development.
+        // In production, it's better to produce a result.
+        // (the dynamic error will still be thrown inside the component tree, but it's catchable by error boundaries)
+        if (workStore.invalidDynamicUsageError && workStore.dev) {
+            throw workStore.invalidDynamicUsageError;
+        }
+        // If we have pending revalidates, wait until they are all resolved.
+        if (workStore.pendingRevalidates || workStore.pendingRevalidateWrites || workStore.pendingRevalidatedTags) {
+            const pendingPromise = (0, _revalidationutils.executeRevalidates)(workStore).finally(()=>{
+                if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
+                    console.log('pending revalidates promise finished for:', url);
+                }
+            });
+            if (renderOpts.waitUntil) {
+                renderOpts.waitUntil(pendingPromise);
+            } else {
+                options.waitUntil = pendingPromise;
+            }
+        }
+        // Create the new render result for the response.
+        return new _renderresult.default(stream, options);
+    }
+}
+const renderToHTMLOrFlight = (req, res, pagePath, query, fallbackRouteParams, renderOpts, serverComponentsHmrCache, isDevWarmup, sharedContext)=>{
+    var _renderOpts_previewProps;
+    if (!req.url) {
+        throw Object.defineProperty(new Error('Invalid URL'), "__NEXT_ERROR_CODE", {
+            value: "E182",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    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, {
+        isDevWarmup,
+        isRoutePPREnabled: renderOpts.experimental.isRoutePPREnabled === true,
+        previewModeId: (_renderOpts_previewProps = renderOpts.previewProps) == null ? void 0 : _renderOpts_previewProps.previewModeId
+    });
+    const { isPrefetchRequest, previouslyRevalidatedTags } = parsedRequestHeaders;
+    let postponedState = null;
+    // If provided, the postpone state should be parsed so it can be provided to
+    // React.
+    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
+            });
+        }
+        postponedState = (0, _postponedstate.parsePostponedState)(renderOpts.postponed, renderOpts.params);
+    }
+    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
+        });
+    }
+    const workStore = (0, _workstore.createWorkStore)({
+        page: renderOpts.routeModule.definition.page,
+        renderOpts,
+        // @TODO move to workUnitStore of type Request
+        isPrefetchRequest,
+        buildId: sharedContext.buildId,
+        previouslyRevalidatedTags
+    });
+    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, fallbackRouteParams);
+};
+function applyMetadataFromPrerenderResult(response, metadata, workStore) {
+    var _metadata_cacheControl;
+    if (response.collectedTags) {
+        metadata.fetchTags = response.collectedTags.join(',');
+    }
+    // Let the client router know how long to keep the cached entry around.
+    const staleHeader = String(response.collectedStale);
+    metadata.headers ??= {};
+    metadata.headers[_approuterheaders.NEXT_ROUTER_STALE_TIME_HEADER] = staleHeader;
+    // If force static is specifically set to false, we should not revalidate
+    // the page.
+    if (workStore.forceStatic === false || response.collectedRevalidate === 0) {
+        metadata.cacheControl = {
+            revalidate: 0,
+            expire: undefined
+        };
+    } 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
+        };
+    }
+    // provide bailout info for debugging
+    if (((_metadata_cacheControl = metadata.cacheControl) == null ? void 0 : _metadata_cacheControl.revalidate) === 0) {
+        metadata.staticBailoutInfo = {
+            description: workStore.dynamicUsageDescription,
+            stack: workStore.dynamicUsageStack
+        };
+    }
+}
+async function renderToStream(requestStore, req, res, ctx, tree, formState, postponedState, metadata, devValidatingFallbackParams) {
+    const { assetPrefix, nonce, pagePath, renderOpts } = ctx;
+    const { basePath, buildManifest, clientReferenceManifest, ComponentMod, crossOrigin, dev = false, experimental, nextExport = false, onInstrumentationRequestError, page, reactMaxHeadersLength, shouldWaitOnAllReady, subresourceIntegrityManifest, supportsDynamicResponse } = renderOpts;
+    assertClientReferenceManifest(clientReferenceManifest);
+    const { ServerInsertedHTMLProvider, renderServerInsertedHTML } = (0, _serverinsertedhtml.createServerInsertedHTML)();
+    const getServerInsertedMetadata = (0, _createserverinsertedmetadata.createServerInsertedMetadata)(nonce);
+    const tracingMetadata = (0, _utils1.getTracedMetadata)((0, _tracer.getTracer)().getTracePropagationData(), experimental.clientTraceMetadata);
+    const polyfills = buildManifest.polyfillFiles.filter((polyfill)=>polyfill.endsWith('.js') && !polyfill.endsWith('.module.js')).map((polyfill)=>({
+            src: `${assetPrefix}/_next/${polyfill}${(0, _getassetquerystring.getAssetQueryString)(ctx, false)}`,
+            integrity: subresourceIntegrityManifest == null ? void 0 : subresourceIntegrityManifest[polyfill],
+            crossOrigin,
+            noModule: true,
+            nonce
+        }));
+    const [preinitScripts, bootstrapScript] = (0, _requiredscripts.getRequiredScripts)(buildManifest, // Why is assetPrefix optional on renderOpts?
+    // @TODO make it default empty string on renderOpts and get rid of it from ctx
+    assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, true), nonce, page);
+    const reactServerErrorsByDigest = new Map();
+    const silenceLogger = false;
+    function onHTMLRenderRSCError(err) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'));
+    }
+    const serverComponentsErrorHandler = (0, _createerrorhandler.createHTMLReactServerErrorHandler)(dev, nextExport, reactServerErrorsByDigest, silenceLogger, onHTMLRenderRSCError);
+    function onHTMLRenderSSRError(err) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'server-rendering'));
+    }
+    const allCapturedErrors = [];
+    const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(dev, nextExport, reactServerErrorsByDigest, allCapturedErrors, silenceLogger, onHTMLRenderSSRError);
+    let reactServerResult = null;
+    const setHeader = res.setHeader.bind(res);
+    const appendHeader = res.appendHeader.bind(res);
+    try {
+        if (// We only want this behavior when running `next dev`
+        dev && // We only want this behavior when we have React's dev builds available
+        process.env.NODE_ENV === 'development' && // 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
+        experimental.cacheComponents) {
+            // This is a dynamic render. We don't do dynamic tracking because we're not prerendering
+            const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+            const [resolveValidation, validationOutlet] = createValidationOutlet();
+            RSCPayload._validation = validationOutlet;
+            const reactServerStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _apprenderrenderutils.scheduleInSequentialTasks, ()=>{
+                requestStore.prerenderPhase = true;
+                return ComponentMod.renderToReadableStream(RSCPayload, clientReferenceManifest.clientModules, {
+                    onError: serverComponentsErrorHandler,
+                    environmentName: ()=>requestStore.prerenderPhase === true ? 'Prerender' : 'Server',
+                    filterStackFrame
+                });
+            }, ()=>{
+                requestStore.prerenderPhase = false;
+            });
+            spawnDynamicValidationInDev(resolveValidation, tree, ctx, res.statusCode === 404, clientReferenceManifest, requestStore, devValidatingFallbackParams);
+            reactServerResult = new _apprenderprerenderutils.ReactServerResult(reactServerStream);
+        } else {
+            // This is a dynamic render. We don't do dynamic tracking because we're not prerendering
+            const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+            reactServerResult = new _apprenderprerenderutils.ReactServerResult(_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ComponentMod.renderToReadableStream, RSCPayload, clientReferenceManifest.clientModules, {
+                filterStackFrame,
+                onError: serverComponentsErrorHandler
+            }));
+        }
+        // React doesn't start rendering synchronously but we want the RSC render to have a chance to start
+        // before we begin SSR rendering because we want to capture any available preload headers so we tick
+        // one task before continuing
+        await (0, _scheduler.waitAtLeastOneReactRenderTask)();
+        // If provided, the postpone state should be parsed as JSON so it can be
+        // provided to React.
+        if (typeof renderOpts.postponed === 'string') {
+            if ((postponedState == null ? void 0 : postponedState.type) === _postponedstate.DynamicState.DATA) {
+                // We have a complete HTML Document in the prerender but we need to
+                // still include the new server component render because it was not included
+                // in the static prelude.
+                const inlinedReactServerDataStream = (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.tee(), nonce, formState);
+                return (0, _nodewebstreamshelper.chainStreams)(inlinedReactServerDataStream, (0, _nodewebstreamshelper.createDocumentClosingStream)());
+            } else if (postponedState) {
+                // We assume we have dynamic HTML requiring a resume render to complete
+                const { postponed, preludeState } = (0, _postponedstate.getPostponedFromState)(postponedState);
+                const resume = require('react-dom/server').resume;
+                const htmlStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, resume, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                    reactServerStream: reactServerResult.tee(),
+                    preinitScripts: preinitScripts,
+                    clientReferenceManifest: clientReferenceManifest,
+                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                    nonce: nonce
+                }), postponed, {
+                    onError: htmlRendererErrorHandler,
+                    nonce
+                });
+                const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                    polyfills,
+                    renderServerInsertedHTML,
+                    serverCapturedErrors: allCapturedErrors,
+                    basePath,
+                    tracingMetadata: tracingMetadata
+                });
+                return await (0, _nodewebstreamshelper.continueDynamicHTMLResume)(htmlStream, {
+                    // If the prelude is empty (i.e. is no static shell), we should wait for initial HTML to be rendered
+                    // to avoid injecting RSC data too early.
+                    // If we have a non-empty-prelude (i.e. a static HTML shell), then it's already been sent separately,
+                    // so we shouldn't wait for any HTML to be emitted from the resume before sending RSC data.
+                    delayDataUntilFirstHtmlChunk: preludeState === _postponedstate.DynamicHTMLPreludeState.Empty,
+                    inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consume(), nonce, formState),
+                    getServerInsertedHTML,
+                    getServerInsertedMetadata
+                });
+            }
+        }
+        // This is a regular dynamic render
+        const renderToReadableStream = require('react-dom/server').renderToReadableStream;
+        const htmlStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, renderToReadableStream, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+            reactServerStream: reactServerResult.tee(),
+            preinitScripts: preinitScripts,
+            clientReferenceManifest: clientReferenceManifest,
+            ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+            nonce: nonce
+        }), {
+            onError: htmlRendererErrorHandler,
+            nonce,
+            onHeaders: (headers)=>{
+                headers.forEach((value, key)=>{
+                    appendHeader(key, value);
+                });
+            },
+            maxHeadersLength: reactMaxHeadersLength,
+            bootstrapScripts: [
+                bootstrapScript
+            ],
+            formState
+        });
+        const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+            polyfills,
+            renderServerInsertedHTML,
+            serverCapturedErrors: allCapturedErrors,
+            basePath,
+            tracingMetadata: tracingMetadata
+        });
+        /**
+     * Rules of Static & Dynamic HTML:
+     *
+     *    1.) We must generate static HTML unless the caller explicitly opts
+     *        in to dynamic HTML support.
+     *
+     *    2.) If dynamic HTML support is requested, we must honor that request
+     *        or throw an error. It is the sole responsibility of the caller to
+     *        ensure they aren't e.g. requesting dynamic HTML for an AMP page.
+     *
+     *   3.) If `shouldWaitOnAllReady` is true, which indicates we need to
+     *       resolve all suspenses and generate a full HTML. e.g. when it's a
+     *       html limited bot requests, we produce the full HTML content.
+     *
+     * These rules help ensure that other existing features like request caching,
+     * coalescing, and ISR continue working as intended.
+     */ const generateStaticHTML = supportsDynamicResponse !== true || !!shouldWaitOnAllReady;
+        return await (0, _nodewebstreamshelper.continueFizzStream)(htmlStream, {
+            inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consume(), nonce, formState),
+            isStaticGeneration: generateStaticHTML,
+            isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
+            buildId: ctx.workStore.buildId,
+            getServerInsertedHTML,
+            getServerInsertedMetadata,
+            validateRootLayout: dev
+        });
+    } catch (err) {
+        if ((0, _staticgenerationbailout.isStaticGenBailoutError)(err) || typeof err === 'object' && err !== null && 'message' in err && typeof err.message === 'string' && err.message.includes('https://nextjs.org/docs/advanced-features/static-html-export')) {
+            // Ensure that "next dev" prints the red error overlay
+            throw err;
+        }
+        // If a bailout made it to this point, it means it wasn't wrapped inside
+        // a suspense boundary.
+        const shouldBailoutToCSR = (0, _bailouttocsr.isBailoutToCSRError)(err);
+        if (shouldBailoutToCSR) {
+            const stack = (0, _formatservererror.getStackWithoutErrorMessage)(err);
+            (0, _log.error)(`${err.reason} should be wrapped in a suspense boundary at page "${pagePath}". Read more: https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout\n${stack}`);
+            throw err;
+        }
+        let errorType;
+        if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
+            res.statusCode = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
+            metadata.statusCode = res.statusCode;
+            errorType = (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)(res.statusCode);
+        } else if ((0, _redirecterror.isRedirectError)(err)) {
+            errorType = 'redirect';
+            res.statusCode = (0, _redirect.getRedirectStatusCodeFromError)(err);
+            metadata.statusCode = res.statusCode;
+            const redirectUrl = (0, _addpathprefix.addPathPrefix)((0, _redirect.getURLFromRedirectError)(err), basePath);
+            // If there were mutable cookies set, we need to set them on the
+            // response.
+            const headers = new Headers();
+            if ((0, _requestcookies.appendMutableCookies)(headers, requestStore.mutableCookies)) {
+                setHeader('set-cookie', Array.from(headers.values()));
+            }
+            setHeader('location', redirectUrl);
+        } else if (!shouldBailoutToCSR) {
+            res.statusCode = 500;
+            metadata.statusCode = res.statusCode;
+        }
+        const [errorPreinitScripts, errorBootstrapScript] = (0, _requiredscripts.getRequiredScripts)(buildManifest, assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, false), nonce, '/_not-found/page');
+        const errorRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, getErrorRSCPayload, tree, ctx, reactServerErrorsByDigest.has(err.digest) ? null : err, errorType);
+        const errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ComponentMod.renderToReadableStream, errorRSCPayload, clientReferenceManifest.clientModules, {
+            filterStackFrame,
+            onError: serverComponentsErrorHandler
+        });
+        if (reactServerResult === null) {
+            // We errored when we did not have an RSC stream to read from. This is not just a render
+            // error, we need to throw early
+            throw err;
+        }
+        try {
+            const fizzStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, _nodewebstreamshelper.renderToInitialFizzStream, {
+                ReactDOMServer: require('react-dom/server'),
+                element: /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
+                    reactServerStream: errorServerStream,
+                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                    preinitScripts: errorPreinitScripts,
+                    clientReferenceManifest: clientReferenceManifest,
+                    nonce: nonce
+                }),
+                streamOptions: {
+                    nonce,
+                    // Include hydration scripts in the HTML
+                    bootstrapScripts: [
+                        errorBootstrapScript
+                    ],
+                    formState
+                }
+            });
+            /**
+       * Rules of Static & Dynamic HTML:
+       *
+       *    1.) We must generate static HTML unless the caller explicitly opts
+       *        in to dynamic HTML support.
+       *
+       *    2.) If dynamic HTML support is requested, we must honor that request
+       *        or throw an error. It is the sole responsibility of the caller to
+       *        ensure they aren't e.g. requesting dynamic HTML for an AMP page.
+       *    3.) If `shouldWaitOnAllReady` is true, which indicates we need to
+       *        resolve all suspenses and generate a full HTML. e.g. when it's a
+       *        html limited bot requests, we produce the full HTML content.
+       *
+       * These rules help ensure that other existing features like request caching,
+       * coalescing, and ISR continue working as intended.
+       */ const generateStaticHTML = supportsDynamicResponse !== true || !!shouldWaitOnAllReady;
+            return await (0, _nodewebstreamshelper.continueFizzStream)(fizzStream, {
+                inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(// This is intentionally using the readable datastream from the
+                // main render rather than the flight data from the error page
+                // render
+                reactServerResult.consume(), nonce, formState),
+                isStaticGeneration: generateStaticHTML,
+                isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
+                buildId: ctx.workStore.buildId,
+                getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                    polyfills,
+                    renderServerInsertedHTML,
+                    serverCapturedErrors: [],
+                    basePath,
+                    tracingMetadata: tracingMetadata
+                }),
+                getServerInsertedMetadata,
+                validateRootLayout: dev
+            });
+        } catch (finalErr) {
+            if (process.env.NODE_ENV === 'development' && (0, _httpaccessfallback.isHTTPAccessFallbackError)(finalErr)) {
+                const { bailOnRootNotFound } = require('../../client/components/dev-root-http-access-fallback-boundary');
+                bailOnRootNotFound();
+            }
+            throw finalErr;
+        }
+    }
+}
+function createValidationOutlet() {
+    let resolveValidation;
+    let outlet = new Promise((resolve)=>{
+        resolveValidation = resolve;
+    });
+    return [
+        resolveValidation,
+        outlet
+    ];
+}
+/**
+ * This function is a fork of prerenderToStream cacheComponents branch.
+ * While it doesn't return a stream we want it to have identical
+ * prerender semantics to prerenderToStream and should update it
+ * in conjunction with any changes to that function.
+ */ async function spawnDynamicValidationInDev(resolveValidation, tree, ctx, isNotFound, clientReferenceManifest, requestStore, fallbackRouteParams) {
+    var _requestStore_cookies_get;
+    const { componentMod: ComponentMod, getDynamicParamFromSegment, implicitTags, nonce, renderOpts, workStore } = ctx;
+    const { allowEmptyStaticShell = false } = renderOpts;
+    // These values are placeholder values for this validating render
+    // that are provided during the actual prerenderToStream.
+    const preinitScripts = ()=>{};
+    const { ServerInsertedHTMLProvider } = (0, _serverinsertedhtml.createServerInsertedHTML)();
+    const rootParams = (0, _createcomponenttree.getRootParams)(ComponentMod.tree, getDynamicParamFromSegment);
+    const hmrRefreshHash = (_requestStore_cookies_get = requestStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _requestStore_cookies_get.value;
+    // The prerender controller represents the lifetime of the prerender. It will
+    // be aborted when a task is complete or a synchronously aborting API is
+    // called. Notably, during prospective prerenders, this does not actually
+    // terminate the prerender itself, which will continue until all caches are
+    // filled.
+    const initialServerPrerenderController = new AbortController();
+    // This controller is used to abort the React prerender.
+    const initialServerReactController = new AbortController();
+    // This controller represents the lifetime of the React prerender. Its signal
+    // can be used for any I/O operation to abort the I/O and/or to reject, when
+    // prerendering aborts. This includes our own hanging promises for accessing
+    // request data, and for fetch calls. It might be replaced in the future by
+    // React.cacheSignal(). It's aborted after the React controller, so that no
+    // pending I/O can register abort listeners that are called before React's
+    // abort listener is called. This ensures that pending I/O is not rejected too
+    // early when aborting the prerender. Notably, during the prospective
+    // prerender, it is different from the prerender controller because we don't
+    // want to end the React prerender until all caches are filled.
+    const initialServerRenderController = new AbortController();
+    // The cacheSignal helps us track whether caches are still filling or we are
+    // ready to cut the render off.
+    const cacheSignal = new _cachesignal.CacheSignal();
+    const captureOwnerStackClient = _react.default.captureOwnerStack;
+    const captureOwnerStackServer = ComponentMod.captureOwnerStack;
+    // The resume data cache here should use a fresh instance as it's
+    // performing a fresh prerender. If we get to implementing the
+    // prerendering of an already prerendered page, we should use the passed
+    // resume data cache instead.
+    const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+    const initialServerPayloadPrerenderStore = {
+        type: 'prerender',
+        phase: 'render',
+        rootParams,
+        fallbackRouteParams,
+        implicitTags,
+        // While this render signal isn't going to be used to abort a React render while getting the RSC payload
+        // various request data APIs bind to this controller to reject after completion.
+        renderSignal: initialServerRenderController.signal,
+        // When we generate the RSC payload we might abort this controller due to sync IO
+        // but we don't actually care about sync IO in this phase so we use a throw away controller
+        // that isn't connected to anything
+        controller: new AbortController(),
+        // During the initial prerender we need to track all cache reads to ensure
+        // we render long enough to fill every cache it is possible to visit during
+        // the final prerender.
+        cacheSignal,
+        dynamicTracking: null,
+        allowEmptyStaticShell,
+        revalidate: _constants1.INFINITE_CACHE,
+        expire: _constants1.INFINITE_CACHE,
+        stale: _constants1.INFINITE_CACHE,
+        tags: [
+            ...implicitTags.tags
+        ],
+        prerenderResumeDataCache,
+        renderResumeDataCache: null,
+        hmrRefreshHash,
+        captureOwnerStack: captureOwnerStackServer
+    };
+    // We're not going to use the result of this render because the only time it could be used
+    // is if it completes in a microtask and that's likely very rare for any non-trivial app
+    const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPayloadPrerenderStore, getRSCPayload, tree, ctx, isNotFound);
+    const initialServerPrerenderStore = {
+        type: 'prerender',
+        phase: 'render',
+        rootParams,
+        fallbackRouteParams,
+        implicitTags,
+        renderSignal: initialServerRenderController.signal,
+        controller: initialServerPrerenderController,
+        // During the initial prerender we need to track all cache reads to ensure
+        // we render long enough to fill every cache it is possible to visit during
+        // the final prerender.
+        cacheSignal,
+        dynamicTracking: null,
+        allowEmptyStaticShell,
+        revalidate: _constants1.INFINITE_CACHE,
+        expire: _constants1.INFINITE_CACHE,
+        stale: _constants1.INFINITE_CACHE,
+        tags: [
+            ...implicitTags.tags
+        ],
+        prerenderResumeDataCache,
+        renderResumeDataCache: null,
+        hmrRefreshHash,
+        captureOwnerStack: captureOwnerStackServer
+    };
+    const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientReferenceManifest.clientModules, {
+        filterStackFrame,
+        onError: (err)=>{
+            const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
+            if (digest) {
+                return digest;
+            }
+            if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
+                // TODO: Aggregate
+                console.error(err);
+                return undefined;
+            }
+            if (initialServerPrerenderController.signal.aborted) {
+                // The render aborted before this error was handled which indicates
+                // the error is caused by unfinished components within the render
+                return;
+            } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+            }
+        },
+        // we don't care to track postpones during the prospective render because we need
+        // to always do a final render anyway
+        onPostpone: undefined,
+        // We don't want to stop rendering until the cacheSignal is complete so we pass
+        // a different signal to this render call than is used by dynamic APIs to signify
+        // transitioning out of the prerender environment
+        signal: initialServerReactController.signal
+    });
+    // The listener to abort our own render controller must be added after React
+    // has added its listener, to ensure that pending I/O is not aborted/rejected
+    // too early.
+    initialServerReactController.signal.addEventListener('abort', ()=>{
+        initialServerRenderController.abort();
+    }, {
+        once: true
+    });
+    // Wait for all caches to be finished filling and for async imports to resolve
+    (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+    await cacheSignal.cacheReady();
+    initialServerReactController.abort();
+    // We don't need to continue the prerender process if we already
+    // detected invalid dynamic usage in the initial prerender phase.
+    const { invalidDynamicUsageError } = workStore;
+    if (invalidDynamicUsageError) {
+        resolveValidation(/*#__PURE__*/ (0, _jsxruntime.jsx)(LogSafely, {
+            fn: ()=>{
+                console.error(invalidDynamicUsageError);
+            }
+        }));
+        return;
+    }
+    let initialServerResult;
+    try {
+        initialServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)(pendingInitialServerResult);
+    } catch (err) {
+        if (initialServerReactController.signal.aborted || initialServerPrerenderController.signal.aborted) {
+        // These are expected errors that might error the prerender. we ignore them.
+        } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+            // We don't normally log these errors because we are going to retry anyway but
+            // it can be useful for debugging Next.js itself to get visibility here when needed
+            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+        }
+    }
+    if (initialServerResult) {
+        const initialClientPrerenderController = new AbortController();
+        const initialClientReactController = new AbortController();
+        const initialClientRenderController = new AbortController();
+        const initialClientPrerenderStore = {
+            type: 'prerender-client',
+            phase: 'render',
+            rootParams,
+            fallbackRouteParams,
+            implicitTags,
+            renderSignal: initialClientRenderController.signal,
+            controller: initialClientPrerenderController,
+            // For HTML Generation the only cache tracked activity
+            // is module loading, which has it's own cache signal
+            cacheSignal: null,
+            dynamicTracking: null,
+            allowEmptyStaticShell,
+            revalidate: _constants1.INFINITE_CACHE,
+            expire: _constants1.INFINITE_CACHE,
+            stale: _constants1.INFINITE_CACHE,
+            tags: [
+                ...implicitTags.tags
+            ],
+            prerenderResumeDataCache,
+            renderResumeDataCache: null,
+            hmrRefreshHash: undefined,
+            captureOwnerStack: captureOwnerStackClient
+        };
+        const prerender = require('react-dom/static').prerender;
+        const pendingInitialClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, prerender, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+            reactServerStream: initialServerResult.asUnclosingStream(),
+            preinitScripts: preinitScripts,
+            clientReferenceManifest: clientReferenceManifest,
+            ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+            nonce: nonce
+        }), {
+            signal: initialClientReactController.signal,
+            onError: (err)=>{
+                const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
+                if (digest) {
+                    return digest;
+                }
+                if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
+                    // TODO: Aggregate
+                    console.error(err);
+                    return undefined;
+                }
+                if (initialClientReactController.signal.aborted) {
+                // These are expected errors that might error the prerender. we ignore them.
+                } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                    // We don't normally log these errors because we are going to retry anyway but
+                    // it can be useful for debugging Next.js itself to get visibility here when needed
+                    (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                }
+            }
+        });
+        // The listener to abort our own render controller must be added after React
+        // has added its listener, to ensure that pending I/O is not
+        // aborted/rejected too early.
+        initialClientReactController.signal.addEventListener('abort', ()=>{
+            initialClientRenderController.abort();
+        }, {
+            once: true
+        });
+        pendingInitialClientResult.catch((err)=>{
+            if (initialClientReactController.signal.aborted || (0, _dynamicrendering.isPrerenderInterruptedError)(err)) {
+            // These are expected errors that might error the prerender. we ignore them.
+            } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                // We don't normally log these errors because we are going to retry anyway but
+                // it can be useful for debugging Next.js itself to get visibility here when needed
+                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+            }
+        });
+        // This is mostly needed for dynamic `import()`s in client components.
+        // Promises passed to client were already awaited above (assuming that they came from cached functions)
+        (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+        await cacheSignal.cacheReady();
+        initialClientReactController.abort();
+    }
+    const finalServerReactController = new AbortController();
+    const finalServerRenderController = new AbortController();
+    const finalServerPayloadPrerenderStore = {
+        type: 'prerender',
+        phase: 'render',
+        rootParams,
+        fallbackRouteParams,
+        implicitTags,
+        // While this render signal isn't going to be used to abort a React render while getting the RSC payload
+        // various request data APIs bind to this controller to reject after completion.
+        renderSignal: finalServerRenderController.signal,
+        // When we generate the RSC payload we might abort this controller due to sync IO
+        // but we don't actually care about sync IO in this phase so we use a throw away controller
+        // that isn't connected to anything
+        controller: new AbortController(),
+        // All caches we could read must already be filled so no tracking is necessary
+        cacheSignal: null,
+        dynamicTracking: null,
+        allowEmptyStaticShell,
+        revalidate: _constants1.INFINITE_CACHE,
+        expire: _constants1.INFINITE_CACHE,
+        stale: _constants1.INFINITE_CACHE,
+        tags: [
+            ...implicitTags.tags
+        ],
+        prerenderResumeDataCache,
+        renderResumeDataCache: null,
+        hmrRefreshHash,
+        captureOwnerStack: captureOwnerStackServer
+    };
+    const finalAttemptRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPayloadPrerenderStore, getRSCPayload, tree, ctx, isNotFound);
+    const serverDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(false // isDebugDynamicAccesses
+    );
+    const finalServerPrerenderStore = {
+        type: 'prerender',
+        phase: 'render',
+        rootParams,
+        fallbackRouteParams,
+        implicitTags,
+        renderSignal: finalServerRenderController.signal,
+        controller: finalServerReactController,
+        // All caches we could read must already be filled so no tracking is necessary
+        cacheSignal: null,
+        dynamicTracking: serverDynamicTracking,
+        allowEmptyStaticShell,
+        revalidate: _constants1.INFINITE_CACHE,
+        expire: _constants1.INFINITE_CACHE,
+        stale: _constants1.INFINITE_CACHE,
+        tags: [
+            ...implicitTags.tags
+        ],
+        prerenderResumeDataCache,
+        renderResumeDataCache: null,
+        hmrRefreshHash,
+        captureOwnerStack: captureOwnerStackServer
+    };
+    const reactServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)((0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasks)(async ()=>{
+        const pendingPrerenderResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(// The store to scope
+        finalServerPrerenderStore, // The function to run
+        ComponentMod.prerender, // ... the arguments for the function to run
+        finalAttemptRSCPayload, clientReferenceManifest.clientModules, {
+            filterStackFrame,
+            onError: (err)=>{
+                if (finalServerReactController.signal.aborted && (0, _dynamicrendering.isPrerenderInterruptedError)(err)) {
+                    return err.digest;
+                }
+                if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
+                    // TODO: Aggregate
+                    console.error(err);
+                    return undefined;
+                }
+                return (0, _createerrorhandler.getDigestForWellKnownError)(err);
+            },
+            signal: finalServerReactController.signal
+        });
+        // The listener to abort our own render controller must be added after
+        // React has added its listener, to ensure that pending I/O is not
+        // aborted/rejected too early.
+        finalServerReactController.signal.addEventListener('abort', ()=>{
+            finalServerRenderController.abort();
+        }, {
+            once: true
+        });
+        return pendingPrerenderResult;
+    }, ()=>{
+        finalServerReactController.abort();
+    }));
+    const clientDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(false //isDebugDynamicAccesses
+    );
+    const finalClientReactController = new AbortController();
+    const finalClientRenderController = new AbortController();
+    const finalClientPrerenderStore = {
+        type: 'prerender-client',
+        phase: 'render',
+        rootParams,
+        fallbackRouteParams,
+        implicitTags,
+        renderSignal: finalClientRenderController.signal,
+        controller: finalClientReactController,
+        // No APIs require a cacheSignal through the workUnitStore during the HTML prerender
+        cacheSignal: null,
+        dynamicTracking: clientDynamicTracking,
+        allowEmptyStaticShell,
+        revalidate: _constants1.INFINITE_CACHE,
+        expire: _constants1.INFINITE_CACHE,
+        stale: _constants1.INFINITE_CACHE,
+        tags: [
+            ...implicitTags.tags
+        ],
+        prerenderResumeDataCache,
+        renderResumeDataCache: null,
+        hmrRefreshHash,
+        captureOwnerStack: captureOwnerStackClient
+    };
+    let dynamicValidation = (0, _dynamicrendering.createDynamicValidationState)();
+    try {
+        const prerender = require('react-dom/static').prerender;
+        let { prelude: unprocessedPrelude } = await (0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasks)(()=>{
+            const pendingFinalClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalClientPrerenderStore, prerender, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                reactServerStream: reactServerResult.asUnclosingStream(),
+                preinitScripts: preinitScripts,
+                clientReferenceManifest: clientReferenceManifest,
+                ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                nonce: nonce
+            }), {
+                signal: finalClientReactController.signal,
+                onError: (err, errorInfo)=>{
+                    if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || finalClientReactController.signal.aborted) {
+                        const componentStack = errorInfo.componentStack;
+                        if (typeof componentStack === 'string') {
+                            (0, _dynamicrendering.trackAllowedDynamicAccess)(workStore, componentStack, dynamicValidation, clientDynamicTracking);
+                        }
+                        return;
+                    }
+                    if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
+                        // TODO: Aggregate
+                        console.error(err);
+                        return undefined;
+                    }
+                    return (0, _createerrorhandler.getDigestForWellKnownError)(err);
+                }
+            });
+            // The listener to abort our own render controller must be added after
+            // React has added its listener, to ensure that pending I/O is not
+            // aborted/rejected too early.
+            finalClientReactController.signal.addEventListener('abort', ()=>{
+                finalClientRenderController.abort();
+            }, {
+                once: true
+            });
+            return pendingFinalClientResult;
+        }, ()=>{
+            finalClientReactController.abort();
+        });
+        const { preludeIsEmpty } = await (0, _apprenderprerenderutils.processPrelude)(unprocessedPrelude);
+        resolveValidation(/*#__PURE__*/ (0, _jsxruntime.jsx)(LogSafely, {
+            fn: _dynamicrendering.throwIfDisallowedDynamic.bind(null, workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, dynamicValidation, serverDynamicTracking)
+        }));
+    } catch (thrownValue) {
+        // Even if the root errors we still want to report any cache components errors
+        // that were discovered before the root errored.
+        let loggingFunction = _dynamicrendering.throwIfDisallowedDynamic.bind(null, workStore, _dynamicrendering.PreludeState.Errored, dynamicValidation, serverDynamicTracking);
+        if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+            // We don't normally log these errors because we are going to retry anyway but
+            // it can be useful for debugging Next.js itself to get visibility here when needed
+            const originalLoggingFunction = loggingFunction;
+            loggingFunction = ()=>{
+                console.error('During dynamic validation the root of the page errored. The next logged error is the thrown value. It may be a duplicate of errors reported during the normal development mode render.');
+                console.error(thrownValue);
+                originalLoggingFunction();
+            };
+        }
+        resolveValidation(/*#__PURE__*/ (0, _jsxruntime.jsx)(LogSafely, {
+            fn: loggingFunction
+        }));
+    }
+}
+async function LogSafely({ fn }) {
+    try {
+        await fn();
+    } catch  {}
+    return null;
+}
+/**
+ * Determines whether we should generate static flight data.
+ */ function shouldGenerateStaticFlightData(workStore) {
+    const { isStaticGeneration } = workStore;
+    if (!isStaticGeneration) return false;
+    return true;
+}
+async function prerenderToStream(req, 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
+    const formState = null;
+    const { assetPrefix, getDynamicParamFromSegment, implicitTags, nonce, pagePath, renderOpts, workStore } = ctx;
+    const { allowEmptyStaticShell = false, basePath, buildManifest, clientReferenceManifest, ComponentMod, crossOrigin, dev = false, experimental, isDebugDynamicAccesses, nextExport = false, onInstrumentationRequestError, page, reactMaxHeadersLength, subresourceIntegrityManifest } = renderOpts;
+    assertClientReferenceManifest(clientReferenceManifest);
+    const rootParams = (0, _createcomponenttree.getRootParams)(tree, getDynamicParamFromSegment);
+    const { ServerInsertedHTMLProvider, renderServerInsertedHTML } = (0, _serverinsertedhtml.createServerInsertedHTML)();
+    const getServerInsertedMetadata = (0, _createserverinsertedmetadata.createServerInsertedMetadata)(nonce);
+    const tracingMetadata = (0, _utils1.getTracedMetadata)((0, _tracer.getTracer)().getTracePropagationData(), experimental.clientTraceMetadata);
+    const polyfills = buildManifest.polyfillFiles.filter((polyfill)=>polyfill.endsWith('.js') && !polyfill.endsWith('.module.js')).map((polyfill)=>({
+            src: `${assetPrefix}/_next/${polyfill}${(0, _getassetquerystring.getAssetQueryString)(ctx, false)}`,
+            integrity: subresourceIntegrityManifest == null ? void 0 : subresourceIntegrityManifest[polyfill],
+            crossOrigin,
+            noModule: true,
+            nonce
+        }));
+    const [preinitScripts, bootstrapScript] = (0, _requiredscripts.getRequiredScripts)(buildManifest, // Why is assetPrefix optional on renderOpts?
+    // @TODO make it default empty string on renderOpts and get rid of it from ctx
+    assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, true), nonce, page);
+    const reactServerErrorsByDigest = new Map();
+    // We don't report errors during prerendering through our instrumentation hooks
+    const silenceLogger = !!experimental.isRoutePPREnabled;
+    function onHTMLRenderRSCError(err) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components'));
+    }
+    const serverComponentsErrorHandler = (0, _createerrorhandler.createHTMLReactServerErrorHandler)(dev, nextExport, reactServerErrorsByDigest, silenceLogger, onHTMLRenderRSCError);
+    function onHTMLRenderSSRError(err) {
+        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'server-rendering'));
+    }
+    const allCapturedErrors = [];
+    const htmlRendererErrorHandler = (0, _createerrorhandler.createHTMLErrorHandler)(dev, nextExport, reactServerErrorsByDigest, allCapturedErrors, silenceLogger, onHTMLRenderSSRError);
+    let reactServerPrerenderResult = null;
+    const setMetadataHeader = (name)=>{
+        metadata.headers ??= {};
+        metadata.headers[name] = res.getHeader(name);
+    };
+    const setHeader = (name, value)=>{
+        res.setHeader(name, value);
+        setMetadataHeader(name);
+        return res;
+    };
+    const appendHeader = (name, value)=>{
+        if (Array.isArray(value)) {
+            value.forEach((item)=>{
+                res.appendHeader(name, item);
+            });
+        } else {
+            res.appendHeader(name, value);
+        }
+        setMetadataHeader(name);
+    };
+    const selectStaleTime = createSelectStaleTime(experimental);
+    let prerenderStore = null;
+    try {
+        if (experimental.cacheComponents) {
+            /**
+       * cacheComponents with PPR
+       *
+       * The general approach is to render the RSC stream first allowing any cache reads to resolve.
+       * Once we have settled all cache reads we restart the render and abort after a single Task.
+       *
+       * Unlike with the non PPR case we can't synchronously abort the render when a dynamic API is used
+       * during the initial render because we need to ensure all caches can be filled as part of the initial Task
+       * and a synchronous abort might prevent us from filling all caches.
+       *
+       * Once the render is complete we allow the SSR render to finish and use a combination of the postponed state
+       * and the reactServerIsDynamic value to determine how to treat the resulting render
+       */ // The prerender controller represents the lifetime of the prerender. It
+            // will be aborted when a task is complete or a synchronously aborting API
+            // is called. Notably, during prospective prerenders, this does not
+            // actually terminate the prerender itself, which will continue until all
+            // caches are filled.
+            const initialServerPrerenderController = new AbortController();
+            // This controller is used to abort the React prerender.
+            const initialServerReactController = new AbortController();
+            // This controller represents the lifetime of the React prerender. Its
+            // signal can be used for any I/O operation to abort the I/O and/or to
+            // reject, when prerendering aborts. This includes our own hanging
+            // promises for accessing request data, and for fetch calls. It might be
+            // replaced in the future by React.cacheSignal(). It's aborted after the
+            // React controller, so that no pending I/O can register abort listeners
+            // that are called before React's abort listener is called. This ensures
+            // that pending I/O is not rejected too early when aborting the prerender.
+            // Notably, during the prospective prerender, it is different from the
+            // prerender controller because we don't want to end the React prerender
+            // until all caches are filled.
+            const initialServerRenderController = new AbortController();
+            // The cacheSignal helps us track whether caches are still filling or we are ready
+            // to cut the render off.
+            const cacheSignal = new _cachesignal.CacheSignal();
+            let resumeDataCache;
+            let renderResumeDataCache = null;
+            let prerenderResumeDataCache = null;
+            if (renderOpts.renderResumeDataCache) {
+                // If a prefilled immutable render resume data cache is provided, e.g.
+                // when prerendering an optional fallback shell after having prerendered
+                // pages with defined params, we use this instead of a prerender resume
+                // data cache.
+                resumeDataCache = renderResumeDataCache = renderOpts.renderResumeDataCache;
+            } else {
+                // Otherwise we create a new mutable prerender resume data cache.
+                resumeDataCache = prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+            }
+            const initialServerPayloadPrerenderStore = {
+                type: 'prerender',
+                phase: 'render',
+                rootParams,
+                fallbackRouteParams,
+                implicitTags,
+                // While this render signal isn't going to be used to abort a React render while getting the RSC payload
+                // various request data APIs bind to this controller to reject after completion.
+                renderSignal: initialServerRenderController.signal,
+                // When we generate the RSC payload we might abort this controller due to sync IO
+                // but we don't actually care about sync IO in this phase so we use a throw away controller
+                // that isn't connected to anything
+                controller: new AbortController(),
+                // During the initial prerender we need to track all cache reads to ensure
+                // we render long enough to fill every cache it is possible to visit during
+                // the final prerender.
+                cacheSignal,
+                dynamicTracking: null,
+                allowEmptyStaticShell,
+                revalidate: _constants1.INFINITE_CACHE,
+                expire: _constants1.INFINITE_CACHE,
+                stale: _constants1.INFINITE_CACHE,
+                tags: [
+                    ...implicitTags.tags
+                ],
+                prerenderResumeDataCache,
+                renderResumeDataCache,
+                hmrRefreshHash: undefined,
+                captureOwnerStack: undefined
+            };
+            // We're not going to use the result of this render because the only time it could be used
+            // is if it completes in a microtask and that's likely very rare for any non-trivial app
+            const initialServerPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPayloadPrerenderStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+            const initialServerPrerenderStore = prerenderStore = {
+                type: 'prerender',
+                phase: 'render',
+                rootParams,
+                fallbackRouteParams,
+                implicitTags,
+                renderSignal: initialServerRenderController.signal,
+                controller: initialServerPrerenderController,
+                // During the initial prerender we need to track all cache reads to ensure
+                // we render long enough to fill every cache it is possible to visit during
+                // the final prerender.
+                cacheSignal,
+                dynamicTracking: null,
+                allowEmptyStaticShell,
+                revalidate: _constants1.INFINITE_CACHE,
+                expire: _constants1.INFINITE_CACHE,
+                stale: _constants1.INFINITE_CACHE,
+                tags: [
+                    ...implicitTags.tags
+                ],
+                prerenderResumeDataCache,
+                renderResumeDataCache,
+                hmrRefreshHash: undefined,
+                captureOwnerStack: undefined
+            };
+            const pendingInitialServerResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialServerPrerenderStore, ComponentMod.prerender, initialServerPayload, clientReferenceManifest.clientModules, {
+                filterStackFrame,
+                onError: (err)=>{
+                    const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
+                    if (digest) {
+                        return digest;
+                    }
+                    if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
+                        // TODO: Aggregate
+                        console.error(err);
+                        return undefined;
+                    }
+                    if (initialServerPrerenderController.signal.aborted) {
+                        // The render aborted before this error was handled which indicates
+                        // the error is caused by unfinished components within the render
+                        return;
+                    } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                    }
+                },
+                // we don't care to track postpones during the prospective render because we need
+                // to always do a final render anyway
+                onPostpone: undefined,
+                // We don't want to stop rendering until the cacheSignal is complete so we pass
+                // a different signal to this render call than is used by dynamic APIs to signify
+                // transitioning out of the prerender environment
+                signal: initialServerReactController.signal
+            });
+            // The listener to abort our own render controller must be added after
+            // React has added its listener, to ensure that pending I/O is not
+            // aborted/rejected too early.
+            initialServerReactController.signal.addEventListener('abort', ()=>{
+                initialServerRenderController.abort();
+            }, {
+                once: true
+            });
+            // Wait for all caches to be finished filling and for async imports to resolve
+            (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+            await cacheSignal.cacheReady();
+            initialServerReactController.abort();
+            // We don't need to continue the prerender process if we already
+            // detected invalid dynamic usage in the initial prerender phase.
+            if (workStore.invalidDynamicUsageError) {
+                (0, _dynamicrendering.logDisallowedDynamicError)(workStore, workStore.invalidDynamicUsageError);
+                throw new _staticgenerationbailout.StaticGenBailoutError();
+            }
+            let initialServerResult;
+            try {
+                initialServerResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)(pendingInitialServerResult);
+            } catch (err) {
+                if (initialServerReactController.signal.aborted || initialServerPrerenderController.signal.aborted) {
+                // These are expected errors that might error the prerender. we ignore them.
+                } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                    // We don't normally log these errors because we are going to retry anyway but
+                    // it can be useful for debugging Next.js itself to get visibility here when needed
+                    (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                }
+            }
+            if (initialServerResult) {
+                const initialClientPrerenderController = new AbortController();
+                const initialClientReactController = new AbortController();
+                const initialClientRenderController = new AbortController();
+                const initialClientPrerenderStore = {
+                    type: 'prerender-client',
+                    phase: 'render',
+                    rootParams,
+                    fallbackRouteParams,
+                    implicitTags,
+                    renderSignal: initialClientRenderController.signal,
+                    controller: initialClientPrerenderController,
+                    // For HTML Generation the only cache tracked activity
+                    // is module loading, which has it's own cache signal
+                    cacheSignal: null,
+                    dynamicTracking: null,
+                    allowEmptyStaticShell,
+                    revalidate: _constants1.INFINITE_CACHE,
+                    expire: _constants1.INFINITE_CACHE,
+                    stale: _constants1.INFINITE_CACHE,
+                    tags: [
+                        ...implicitTags.tags
+                    ],
+                    prerenderResumeDataCache,
+                    renderResumeDataCache,
+                    hmrRefreshHash: undefined,
+                    captureOwnerStack: undefined
+                };
+                const prerender = require('react-dom/static').prerender;
+                const pendingInitialClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(initialClientPrerenderStore, prerender, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                    reactServerStream: initialServerResult.asUnclosingStream(),
+                    preinitScripts: preinitScripts,
+                    clientReferenceManifest: clientReferenceManifest,
+                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                    nonce: nonce
+                }), {
+                    signal: initialClientReactController.signal,
+                    onError: (err)=>{
+                        const digest = (0, _createerrorhandler.getDigestForWellKnownError)(err);
+                        if (digest) {
+                            return digest;
+                        }
+                        if ((0, _reactlargeshellerror.isReactLargeShellError)(err)) {
+                            // TODO: Aggregate
+                            console.error(err);
+                            return undefined;
+                        }
+                        if (initialClientReactController.signal.aborted) {
+                        // These are expected errors that might error the prerender. we ignore them.
+                        } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                            // We don't normally log these errors because we are going to retry anyway but
+                            // it can be useful for debugging Next.js itself to get visibility here when needed
+                            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                        }
+                    },
+                    bootstrapScripts: [
+                        bootstrapScript
+                    ]
+                });
+                // The listener to abort our own render controller must be added after
+                // React has added its listener, to ensure that pending I/O is not
+                // aborted/rejected too early.
+                initialClientReactController.signal.addEventListener('abort', ()=>{
+                    initialClientRenderController.abort();
+                }, {
+                    once: true
+                });
+                pendingInitialClientResult.catch((err)=>{
+                    if (initialClientReactController.signal.aborted || (0, _dynamicrendering.isPrerenderInterruptedError)(err)) {
+                    // These are expected errors that might error the prerender. we ignore them.
+                    } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+                        // We don't normally log these errors because we are going to retry anyway but
+                        // it can be useful for debugging Next.js itself to get visibility here when needed
+                        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                    }
+                });
+                // This is mostly needed for dynamic `import()`s in client components.
+                // Promises passed to client were already awaited above (assuming that they came from cached functions)
+                (0, _trackmoduleloadingexternal.trackPendingModules)(cacheSignal);
+                await cacheSignal.cacheReady();
+                initialClientReactController.abort();
+            }
+            const finalServerReactController = new AbortController();
+            const finalServerRenderController = new AbortController();
+            const finalServerPayloadPrerenderStore = {
+                type: 'prerender',
+                phase: 'render',
+                rootParams,
+                fallbackRouteParams,
+                implicitTags,
+                // While this render signal isn't going to be used to abort a React render while getting the RSC payload
+                // various request data APIs bind to this controller to reject after completion.
+                renderSignal: finalServerRenderController.signal,
+                // When we generate the RSC payload we might abort this controller due to sync IO
+                // but we don't actually care about sync IO in this phase so we use a throw away controller
+                // that isn't connected to anything
+                controller: new AbortController(),
+                // All caches we could read must already be filled so no tracking is necessary
+                cacheSignal: null,
+                dynamicTracking: null,
+                allowEmptyStaticShell,
+                revalidate: _constants1.INFINITE_CACHE,
+                expire: _constants1.INFINITE_CACHE,
+                stale: _constants1.INFINITE_CACHE,
+                tags: [
+                    ...implicitTags.tags
+                ],
+                prerenderResumeDataCache,
+                renderResumeDataCache,
+                hmrRefreshHash: undefined,
+                captureOwnerStack: undefined
+            };
+            const finalAttemptRSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalServerPayloadPrerenderStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+            const serverDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
+            let serverIsDynamic = false;
+            const finalServerPrerenderStore = prerenderStore = {
+                type: 'prerender',
+                phase: 'render',
+                rootParams,
+                fallbackRouteParams,
+                implicitTags,
+                renderSignal: finalServerRenderController.signal,
+                controller: finalServerReactController,
+                // All caches we could read must already be filled so no tracking is necessary
+                cacheSignal: null,
+                dynamicTracking: serverDynamicTracking,
+                allowEmptyStaticShell,
+                revalidate: _constants1.INFINITE_CACHE,
+                expire: _constants1.INFINITE_CACHE,
+                stale: _constants1.INFINITE_CACHE,
+                tags: [
+                    ...implicitTags.tags
+                ],
+                prerenderResumeDataCache,
+                renderResumeDataCache,
+                hmrRefreshHash: undefined,
+                captureOwnerStack: undefined
+            };
+            let prerenderIsPending = true;
+            const reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResult)((0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasks)(async ()=>{
+                const pendingPrerenderResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(// The store to scope
+                finalServerPrerenderStore, // The function to run
+                ComponentMod.prerender, // ... the arguments for the function to run
+                finalAttemptRSCPayload, clientReferenceManifest.clientModules, {
+                    filterStackFrame,
+                    onError: (err)=>{
+                        return serverComponentsErrorHandler(err);
+                    },
+                    signal: finalServerReactController.signal
+                });
+                // The listener to abort our own render controller must be added
+                // after React has added its listener, to ensure that pending I/O
+                // is not aborted/rejected too early.
+                finalServerReactController.signal.addEventListener('abort', ()=>{
+                    finalServerRenderController.abort();
+                }, {
+                    once: true
+                });
+                const prerenderResult = await pendingPrerenderResult;
+                prerenderIsPending = false;
+                return prerenderResult;
+            }, ()=>{
+                if (finalServerReactController.signal.aborted) {
+                    // If the server controller is already aborted we must have called something
+                    // that required aborting the prerender synchronously such as with new Date()
+                    serverIsDynamic = true;
+                    return;
+                }
+                if (prerenderIsPending) {
+                    // If prerenderIsPending then we have blocked for longer than a Task and we assume
+                    // there is something unfinished.
+                    serverIsDynamic = true;
+                }
+                finalServerReactController.abort();
+            }));
+            const clientDynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
+            const finalClientReactController = new AbortController();
+            const finalClientRenderController = new AbortController();
+            const finalClientPrerenderStore = {
+                type: 'prerender-client',
+                phase: 'render',
+                rootParams,
+                fallbackRouteParams,
+                implicitTags,
+                renderSignal: finalClientRenderController.signal,
+                controller: finalClientReactController,
+                // No APIs require a cacheSignal through the workUnitStore during the HTML prerender
+                cacheSignal: null,
+                dynamicTracking: clientDynamicTracking,
+                allowEmptyStaticShell,
+                revalidate: _constants1.INFINITE_CACHE,
+                expire: _constants1.INFINITE_CACHE,
+                stale: _constants1.INFINITE_CACHE,
+                tags: [
+                    ...implicitTags.tags
+                ],
+                prerenderResumeDataCache,
+                renderResumeDataCache,
+                hmrRefreshHash: undefined,
+                captureOwnerStack: undefined
+            };
+            let dynamicValidation = (0, _dynamicrendering.createDynamicValidationState)();
+            const prerender = require('react-dom/static').prerender;
+            let { prelude: unprocessedPrelude, postponed } = await (0, _apprenderprerenderutils.prerenderAndAbortInSequentialTasks)(()=>{
+                const pendingFinalClientResult = _workunitasyncstorageexternal.workUnitAsyncStorage.run(finalClientPrerenderStore, prerender, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                    reactServerStream: reactServerResult.asUnclosingStream(),
+                    preinitScripts: preinitScripts,
+                    clientReferenceManifest: clientReferenceManifest,
+                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                    nonce: nonce
+                }), {
+                    signal: finalClientReactController.signal,
+                    onError: (err, errorInfo)=>{
+                        if ((0, _dynamicrendering.isPrerenderInterruptedError)(err) || finalClientReactController.signal.aborted) {
+                            const componentStack = errorInfo.componentStack;
+                            if (typeof componentStack === 'string') {
+                                (0, _dynamicrendering.trackAllowedDynamicAccess)(workStore, componentStack, dynamicValidation, clientDynamicTracking);
+                            }
+                            return;
+                        }
+                        return htmlRendererErrorHandler(err, errorInfo);
+                    },
+                    onHeaders: (headers)=>{
+                        headers.forEach((value, key)=>{
+                            appendHeader(key, value);
+                        });
+                    },
+                    maxHeadersLength: reactMaxHeadersLength,
+                    bootstrapScripts: [
+                        bootstrapScript
+                    ]
+                });
+                // The listener to abort our own render controller must be added
+                // after React has added its listener, to ensure that pending I/O is
+                // not aborted/rejected too early.
+                finalClientReactController.signal.addEventListener('abort', ()=>{
+                    finalClientRenderController.abort();
+                }, {
+                    once: true
+                });
+                return pendingFinalClientResult;
+            }, ()=>{
+                finalClientReactController.abort();
+            });
+            const { prelude, preludeIsEmpty } = await (0, _apprenderprerenderutils.processPrelude)(unprocessedPrelude);
+            // If we've disabled throwing on empty static shell, then we don't need to
+            // track any dynamic access that occurs above the suspense boundary because
+            // we'll do so in the route shell.
+            if (!allowEmptyStaticShell) {
+                (0, _dynamicrendering.throwIfDisallowedDynamic)(workStore, preludeIsEmpty ? _dynamicrendering.PreludeState.Empty : _dynamicrendering.PreludeState.Full, dynamicValidation, serverDynamicTracking);
+            }
+            const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                polyfills,
+                renderServerInsertedHTML,
+                serverCapturedErrors: allCapturedErrors,
+                basePath,
+                tracingMetadata: tracingMetadata
+            });
+            const flightData = await (0, _nodewebstreamshelper.streamToBuffer)(reactServerResult.asStream());
+            metadata.flightData = flightData;
+            metadata.segmentData = await collectSegmentData(flightData, finalServerPrerenderStore, ComponentMod, renderOpts);
+            // If there are fallback route params, the RSC data is inherently dynamic
+            // today because it's encoded into the flight router state. Until we can
+            // move the fallback route params out of the flight router state, we need
+            // to always perform a dynamic resume after the static prerender.
+            const hasFallbackRouteParams = fallbackRouteParams && fallbackRouteParams.size > 0;
+            if (serverIsDynamic || hasFallbackRouteParams) {
+                // Dynamic case
+                // We will always need to perform a "resume" render of some kind when this route is accessed
+                // because the RSC data itself is dynamic. We determine if there are any HTML holes or not
+                // but generally this is a "partial" prerender in that there will be a per-request compute
+                // concatenated to the static shell.
+                if (postponed != null) {
+                    // Dynamic HTML case
+                    metadata.postponed = await (0, _postponedstate.getDynamicHTMLPostponedState)(postponed, preludeIsEmpty ? _postponedstate.DynamicHTMLPreludeState.Empty : _postponedstate.DynamicHTMLPreludeState.Full, fallbackRouteParams, resumeDataCache);
+                } else {
+                    // Dynamic Data case
+                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(resumeDataCache);
+                }
+                reactServerResult.consume();
+                return {
+                    digestErrorsMap: reactServerErrorsByDigest,
+                    ssrErrors: allCapturedErrors,
+                    stream: await (0, _nodewebstreamshelper.continueDynamicPrerender)(prelude, {
+                        getServerInsertedHTML,
+                        getServerInsertedMetadata
+                    }),
+                    dynamicAccess: (0, _dynamicrendering.consumeDynamicAccess)(serverDynamicTracking, clientDynamicTracking),
+                    // TODO: Should this include the SSR pass?
+                    collectedRevalidate: finalServerPrerenderStore.revalidate,
+                    collectedExpire: finalServerPrerenderStore.expire,
+                    collectedStale: selectStaleTime(finalServerPrerenderStore.stale),
+                    collectedTags: finalServerPrerenderStore.tags,
+                    renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache)
+                };
+            } else {
+                // Static case
+                // We will not perform resumption per request. The result can be served statically to the requestor
+                // and if there was anything dynamic it will only be rendered in the browser.
+                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 resume = require('react-dom/server').resume;
+                    // We don't actually want to render anything so we just pass a stream
+                    // that never resolves. The resume call is going to abort immediately anyway
+                    const foreverStream = new ReadableStream();
+                    const resumeStream = await resume(/*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                        reactServerStream: foreverStream,
+                        preinitScripts: ()=>{},
+                        clientReferenceManifest: clientReferenceManifest,
+                        ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                        nonce: nonce
+                    }), 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, _nodewebstreamshelper.chainStreams)(prelude, resumeStream);
+                }
+                return {
+                    digestErrorsMap: reactServerErrorsByDigest,
+                    ssrErrors: allCapturedErrors,
+                    stream: await (0, _nodewebstreamshelper.continueStaticPrerender)(htmlStream, {
+                        inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consumeAsStream(), nonce, formState),
+                        getServerInsertedHTML,
+                        getServerInsertedMetadata,
+                        isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
+                        buildId: ctx.workStore.buildId
+                    }),
+                    dynamicAccess: (0, _dynamicrendering.consumeDynamicAccess)(serverDynamicTracking, clientDynamicTracking),
+                    // TODO: Should this include the SSR pass?
+                    collectedRevalidate: finalServerPrerenderStore.revalidate,
+                    collectedExpire: finalServerPrerenderStore.expire,
+                    collectedStale: selectStaleTime(finalServerPrerenderStore.stale),
+                    collectedTags: finalServerPrerenderStore.tags,
+                    renderResumeDataCache: (0, _resumedatacache.createRenderResumeDataCache)(resumeDataCache)
+                };
+            }
+        } else if (experimental.isRoutePPREnabled) {
+            // We're statically generating with PPR and need to do dynamic tracking
+            let dynamicTracking = (0, _dynamicrendering.createDynamicTrackingState)(isDebugDynamicAccesses);
+            const prerenderResumeDataCache = (0, _resumedatacache.createPrerenderResumeDataCache)();
+            const reactServerPrerenderStore = 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
+                ],
+                prerenderResumeDataCache
+            };
+            const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(reactServerPrerenderStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+            const reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(reactServerPrerenderStore, ComponentMod.renderToReadableStream, // ... the arguments for the function to run
+            RSCPayload, clientReferenceManifest.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
+                ],
+                prerenderResumeDataCache
+            };
+            const prerender = require('react-dom/static').prerender;
+            const { prelude: unprocessedPrelude, postponed } = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(ssrPrerenderStore, prerender, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                reactServerStream: reactServerResult.asUnclosingStream(),
+                preinitScripts: preinitScripts,
+                clientReferenceManifest: clientReferenceManifest,
+                ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                nonce: nonce
+            }), {
+                onError: htmlRendererErrorHandler,
+                onHeaders: (headers)=>{
+                    headers.forEach((value, key)=>{
+                        appendHeader(key, value);
+                    });
+                },
+                maxHeadersLength: reactMaxHeadersLength,
+                bootstrapScripts: [
+                    bootstrapScript
+                ]
+            });
+            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, _nodewebstreamshelper.streamToBuffer)(reactServerResult.asStream());
+            if (shouldGenerateStaticFlightData(workStore)) {
+                metadata.flightData = flightData;
+                metadata.segmentData = await collectSegmentData(flightData, ssrPrerenderStore, ComponentMod, renderOpts);
+            }
+            const { prelude, preludeIsEmpty } = await (0, _apprenderprerenderutils.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, prerenderResumeDataCache);
+                } else {
+                    // Dynamic Data case.
+                    metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(prerenderResumeDataCache);
+                }
+                // 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();
+                return {
+                    digestErrorsMap: reactServerErrorsByDigest,
+                    ssrErrors: allCapturedErrors,
+                    stream: await (0, _nodewebstreamshelper.continueDynamicPrerender)(prelude, {
+                        getServerInsertedHTML,
+                        getServerInsertedMetadata
+                    }),
+                    dynamicAccess: dynamicTracking.dynamicAccesses,
+                    // TODO: Should this include the SSR pass?
+                    collectedRevalidate: reactServerPrerenderStore.revalidate,
+                    collectedExpire: reactServerPrerenderStore.expire,
+                    collectedStale: selectStaleTime(reactServerPrerenderStore.stale),
+                    collectedTags: reactServerPrerenderStore.tags
+                };
+            } else if (fallbackRouteParams && fallbackRouteParams.size > 0) {
+                // Rendering the fallback case.
+                metadata.postponed = await (0, _postponedstate.getDynamicDataPostponedState)(prerenderResumeDataCache);
+                return {
+                    digestErrorsMap: reactServerErrorsByDigest,
+                    ssrErrors: allCapturedErrors,
+                    stream: await (0, _nodewebstreamshelper.continueDynamicPrerender)(prelude, {
+                        getServerInsertedHTML,
+                        getServerInsertedMetadata
+                    }),
+                    dynamicAccess: dynamicTracking.dynamicAccesses,
+                    // TODO: Should this include the SSR pass?
+                    collectedRevalidate: reactServerPrerenderStore.revalidate,
+                    collectedExpire: reactServerPrerenderStore.expire,
+                    collectedStale: selectStaleTime(reactServerPrerenderStore.stale),
+                    collectedTags: reactServerPrerenderStore.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 resume = require('react-dom/server').resume;
+                    // We don't actually want to render anything so we just pass a stream
+                    // that never resolves. The resume call is going to abort immediately anyway
+                    const foreverStream = new ReadableStream();
+                    const resumeStream = await resume(/*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                        reactServerStream: foreverStream,
+                        preinitScripts: ()=>{},
+                        clientReferenceManifest: clientReferenceManifest,
+                        ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                        nonce: nonce
+                    }), 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, _nodewebstreamshelper.chainStreams)(prelude, resumeStream);
+                }
+                return {
+                    digestErrorsMap: reactServerErrorsByDigest,
+                    ssrErrors: allCapturedErrors,
+                    stream: await (0, _nodewebstreamshelper.continueStaticPrerender)(htmlStream, {
+                        inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consumeAsStream(), nonce, formState),
+                        getServerInsertedHTML,
+                        getServerInsertedMetadata,
+                        isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
+                        buildId: ctx.workStore.buildId
+                    }),
+                    dynamicAccess: dynamicTracking.dynamicAccesses,
+                    // TODO: Should this include the SSR pass?
+                    collectedRevalidate: reactServerPrerenderStore.revalidate,
+                    collectedExpire: reactServerPrerenderStore.expire,
+                    collectedStale: selectStaleTime(reactServerPrerenderStore.stale),
+                    collectedTags: reactServerPrerenderStore.tags
+                };
+            }
+        } else {
+            const prerenderLegacyStore = prerenderStore = {
+                type: 'prerender-legacy',
+                phase: 'render',
+                rootParams,
+                implicitTags,
+                revalidate: _constants1.INFINITE_CACHE,
+                expire: _constants1.INFINITE_CACHE,
+                stale: _constants1.INFINITE_CACHE,
+                tags: [
+                    ...implicitTags.tags
+                ]
+            };
+            // This is a regular static generation. We don't do dynamic tracking because we rely on
+            // the old-school dynamic error handling to bail out of static generation
+            const RSCPayload = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, getRSCPayload, tree, ctx, res.statusCode === 404);
+            const reactServerResult = reactServerPrerenderResult = await (0, _apprenderprerenderutils.createReactServerPrerenderResultFromRender)(_workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, ComponentMod.renderToReadableStream, RSCPayload, clientReferenceManifest.clientModules, {
+                filterStackFrame,
+                onError: serverComponentsErrorHandler
+            }));
+            const renderToReadableStream = require('react-dom/server').renderToReadableStream;
+            const htmlStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, renderToReadableStream, /*#__PURE__*/ (0, _jsxruntime.jsx)(App, {
+                reactServerStream: reactServerResult.asUnclosingStream(),
+                preinitScripts: preinitScripts,
+                clientReferenceManifest: clientReferenceManifest,
+                ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                nonce: nonce
+            }), {
+                onError: htmlRendererErrorHandler,
+                nonce,
+                bootstrapScripts: [
+                    bootstrapScript
+                ]
+            });
+            if (shouldGenerateStaticFlightData(workStore)) {
+                const flightData = await (0, _nodewebstreamshelper.streamToBuffer)(reactServerResult.asStream());
+                metadata.flightData = flightData;
+                metadata.segmentData = await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts);
+            }
+            const getServerInsertedHTML = (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                polyfills,
+                renderServerInsertedHTML,
+                serverCapturedErrors: allCapturedErrors,
+                basePath,
+                tracingMetadata: tracingMetadata
+            });
+            return {
+                digestErrorsMap: reactServerErrorsByDigest,
+                ssrErrors: allCapturedErrors,
+                stream: await (0, _nodewebstreamshelper.continueFizzStream)(htmlStream, {
+                    inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(reactServerResult.consumeAsStream(), nonce, formState),
+                    isStaticGeneration: true,
+                    isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
+                    buildId: ctx.workStore.buildId,
+                    getServerInsertedHTML,
+                    getServerInsertedMetadata
+                }),
+                // TODO: Should this include the SSR pass?
+                collectedRevalidate: prerenderLegacyStore.revalidate,
+                collectedExpire: prerenderLegacyStore.expire,
+                collectedStale: selectStaleTime(prerenderLegacyStore.stale),
+                collectedTags: prerenderLegacyStore.tags
+            };
+        }
+    } catch (err) {
+        if ((0, _staticgenerationbailout.isStaticGenBailoutError)(err) || typeof err === 'object' && err !== null && 'message' in err && typeof err.message === 'string' && err.message.includes('https://nextjs.org/docs/advanced-features/static-html-export')) {
+            // Ensure that "next dev" prints the red error overlay
+            throw err;
+        }
+        // If 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)) {
+            throw err;
+        }
+        // If a bailout made it to this point, it means it wasn't wrapped inside
+        // a suspense boundary.
+        const shouldBailoutToCSR = (0, _bailouttocsr.isBailoutToCSRError)(err);
+        if (shouldBailoutToCSR) {
+            const stack = (0, _formatservererror.getStackWithoutErrorMessage)(err);
+            (0, _log.error)(`${err.reason} should be wrapped in a suspense boundary at page "${pagePath}". Read more: https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout\n${stack}`);
+            throw err;
+        }
+        // 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;
+        if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(err)) {
+            res.statusCode = (0, _httpaccessfallback.getAccessFallbackHTTPStatus)(err);
+            metadata.statusCode = res.statusCode;
+            errorType = (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)(res.statusCode);
+        } else if ((0, _redirecterror.isRedirectError)(err)) {
+            errorType = 'redirect';
+            res.statusCode = (0, _redirect.getRedirectStatusCodeFromError)(err);
+            metadata.statusCode = res.statusCode;
+            const redirectUrl = (0, _addpathprefix.addPathPrefix)((0, _redirect.getURLFromRedirectError)(err), basePath);
+            setHeader('location', redirectUrl);
+        } else if (!shouldBailoutToCSR) {
+            res.statusCode = 500;
+            metadata.statusCode = res.statusCode;
+        }
+        const [errorPreinitScripts, errorBootstrapScript] = (0, _requiredscripts.getRequiredScripts)(buildManifest, assetPrefix, crossOrigin, subresourceIntegrityManifest, (0, _getassetquerystring.getAssetQueryString)(ctx, false), nonce, '/_not-found/page');
+        const prerenderLegacyStore = prerenderStore = {
+            type: 'prerender-legacy',
+            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,
+            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);
+        const errorServerStream = _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, ComponentMod.renderToReadableStream, errorRSCPayload, clientReferenceManifest.clientModules, {
+            filterStackFrame,
+            onError: serverComponentsErrorHandler
+        });
+        try {
+            // TODO we should use the same prerender semantics that we initially rendered
+            // with in this case too. The only reason why this is ok atm is because it's essentially
+            // an empty page and no user code runs.
+            const fizzStream = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(prerenderLegacyStore, _nodewebstreamshelper.renderToInitialFizzStream, {
+                ReactDOMServer: require('react-dom/server'),
+                element: /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorApp, {
+                    reactServerStream: errorServerStream,
+                    ServerInsertedHTMLProvider: ServerInsertedHTMLProvider,
+                    preinitScripts: errorPreinitScripts,
+                    clientReferenceManifest: clientReferenceManifest,
+                    nonce: nonce
+                }),
+                streamOptions: {
+                    nonce,
+                    // Include hydration scripts in the HTML
+                    bootstrapScripts: [
+                        errorBootstrapScript
+                    ],
+                    formState
+                }
+            });
+            if (shouldGenerateStaticFlightData(workStore)) {
+                const flightData = await (0, _nodewebstreamshelper.streamToBuffer)(reactServerPrerenderResult.asStream());
+                metadata.flightData = flightData;
+                metadata.segmentData = await collectSegmentData(flightData, prerenderLegacyStore, ComponentMod, renderOpts);
+            }
+            // This is intentionally using the readable datastream from the main
+            // render rather than the flight data from the error page render
+            const flightStream = reactServerPrerenderResult.consumeAsStream();
+            return {
+                // Returning the error that was thrown so it can be used to handle
+                // the response in the caller.
+                digestErrorsMap: reactServerErrorsByDigest,
+                ssrErrors: allCapturedErrors,
+                stream: await (0, _nodewebstreamshelper.continueFizzStream)(fizzStream, {
+                    inlinedDataStream: (0, _useflightresponse.createInlinedDataReadableStream)(flightStream, nonce, formState),
+                    isStaticGeneration: true,
+                    isBuildTimePrerendering: ctx.workStore.isBuildTimePrerendering === true,
+                    buildId: ctx.workStore.buildId,
+                    getServerInsertedHTML: (0, _makegetserverinsertedhtml.makeGetServerInsertedHTML)({
+                        polyfills,
+                        renderServerInsertedHTML,
+                        serverCapturedErrors: [],
+                        basePath,
+                        tracingMetadata: tracingMetadata
+                    }),
+                    getServerInsertedMetadata,
+                    validateRootLayout: dev
+                }),
+                dynamicAccess: null,
+                collectedRevalidate: prerenderStore !== null ? prerenderStore.revalidate : _constants1.INFINITE_CACHE,
+                collectedExpire: prerenderStore !== null ? prerenderStore.expire : _constants1.INFINITE_CACHE,
+                collectedStale: selectStaleTime(prerenderStore !== null ? prerenderStore.stale : _constants1.INFINITE_CACHE),
+                collectedTags: prerenderStore !== null ? prerenderStore.tags : null
+            };
+        } catch (finalErr) {
+            if (process.env.NODE_ENV === 'development' && (0, _httpaccessfallback.isHTTPAccessFallbackError)(finalErr)) {
+                const { bailOnRootNotFound } = require('../../client/components/dev-root-http-access-fallback-boundary');
+                bailOnRootNotFound();
+            }
+            throw finalErr;
+        }
+    }
+}
+const getGlobalErrorStyles = async (tree, ctx)=>{
+    const { modules: { 'global-error': globalErrorModule } } = (0, _parseloadertree.parseLoaderTree)(tree);
+    const GlobalErrorComponent = ctx.componentMod.GlobalError;
+    let globalErrorStyles;
+    if (globalErrorModule) {
+        const [, styles] = await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+            ctx,
+            filePath: globalErrorModule[1],
+            getComponent: globalErrorModule[0],
+            injectedCSS: new Set(),
+            injectedJS: new Set()
+        });
+        globalErrorStyles = styles;
+    }
+    if (ctx.renderOpts.dev) {
+        const dir = (process.env.NEXT_RUNTIME === 'edge' ? process.env.__NEXT_EDGE_PROJECT_DIR : ctx.renderOpts.dir) || '';
+        const globalErrorModulePath = (0, _segmentexplorerpath.normalizeConventionFilePath)(dir, globalErrorModule == null ? void 0 : globalErrorModule[1]);
+        if (ctx.renderOpts.devtoolSegmentExplorer && globalErrorModulePath) {
+            const SegmentViewNode = ctx.componentMod.SegmentViewNode;
+            globalErrorStyles = // This will be rendered next to GlobalError component under ErrorBoundary,
+            // it requires a key to avoid React warning about duplicate keys.
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(SegmentViewNode, {
+                type: "global-error",
+                pagePath: globalErrorModulePath,
+                children: globalErrorStyles
+            }, "ge-svn");
+        }
+    }
+    return {
+        GlobalError: GlobalErrorComponent,
+        styles: globalErrorStyles
+    };
+};
+function createSelectStaleTime(experimental) {
+    return (stale)=>{
+        var _experimental_staleTimes;
+        return stale === _constants1.INFINITE_CACHE && typeof ((_experimental_staleTimes = experimental.staleTimes) == null ? void 0 : _experimental_staleTimes.static) === 'number' ? experimental.staleTimes.static : stale;
+    };
+}
+async function collectSegmentData(fullPageDataBuffer, prerenderStore, ComponentMod, renderOpts) {
+    // Per-segment prefetch data
+    //
+    // All of the segments for a page are generated simultaneously, including
+    // during revalidations. This is to ensure consistency, because it's
+    // possible for a mismatch between a layout and page segment can cause the
+    // client to error during rendering. We want to preserve the ability of the
+    // client to recover from such a mismatch by re-requesting all the segments
+    // to get a consistent view of the page.
+    //
+    // For performance, we reuse the Flight output that was created when
+    // generating the initial page HTML. The Flight stream for the whole page is
+    // decomposed into a separate stream per segment.
+    const clientReferenceManifest = renderOpts.clientReferenceManifest;
+    if (!clientReferenceManifest || // Do not generate per-segment data unless the experimental Segment Cache
+    // flag is enabled.
+    //
+    // We also skip generating segment data if flag is set to "client-only",
+    // rather than true. (The "client-only" option only affects the behavior of
+    // the client-side implementation; per-segment prefetches are intentionally
+    // disabled in that configuration).
+    renderOpts.experimental.clientSegmentCache !== true) {
+        return;
+    }
+    // Manifest passed to the Flight client for reading the full-page Flight
+    // stream. Based off similar code in use-cache-wrapper.ts.
+    const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
+    const serverConsumerManifest = {
+        // moduleLoading must be null because we don't want to trigger preloads of ClientReferences
+        // to be added to the consumer. Instead, we'll wait for any ClientReference to be emitted
+        // which themselves will handle the preloading.
+        moduleLoading: null,
+        moduleMap: isEdgeRuntime ? clientReferenceManifest.edgeRscModuleMapping : clientReferenceManifest.rscModuleMapping,
+        serverModuleMap: (0, _encryptionutils.getServerModuleMap)()
+    };
+    const staleTime = prerenderStore.stale;
+    return await ComponentMod.collectSegmentData(renderOpts.experimental.clientParamParsing, fullPageDataBuffer, staleTime, clientReferenceManifest.clientModules, serverConsumerManifest);
+}
+
+//# sourceMappingURL=app-render.js.map