next/dist/esm/server/app-render/app-render.js

The React Framework

import { jsx as _jsx } from "react/jsx-runtime";
import { PrefetchHint } from '../../shared/lib/app-router-types';
import { workAsyncStorage } from '../app-render/work-async-storage.external';
import { getTurbopackChunkGroupBootstrap } from '../get-page-files';
import { UNDERSCORE_NOT_FOUND_ROUTE_ENTRY } from '../../shared/lib/entry-constants';
import * as ReactClient from 'react';
import RenderResult from '../render-result';
import { chainStreams, continueFizzStream, continueDynamicPrerender, continueStaticPrerender, continueDynamicHTMLResumeNode, continueDynamicHTMLResumeWeb, continueStaticFallbackPrerender, streamToBuffer, streamToString, createWebInlinedDataStream, createPendingStream, createOnHeadersCallback, resumeAndAbort, renderToWebFlightStream, resumeToFizzStream, getServerPrerender, getClientPrerender, processPrelude as processPreludeOp, createDocumentClosingStream, teeStream, renderToWebFizzStream, renderToNodeFlightStream, renderToNodeFizzStream, createNodeInlinedDataStream } from './stream-ops';
import { getInstantTestBootstrapScriptContent } from './instant-test-bootstrap';
import { stripInternalQueries } from '../internal-utils';
import { NEXT_HMR_REFRESH_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, NEXT_URL, RSC_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_REQUEST_ID_HEADER, NEXT_HTML_REQUEST_ID_HEADER } from '../../client/components/app-router-headers';
import { createMetadataContext } from '../../lib/metadata/metadata-context';
import { createRequestStore as createRequestStoreFromInputs, createRequestStoreForRender } from '../async-storage/request-store';
import { isRSCRequestHeader } from '../lib/is-rsc-request';
import { createWorkStore } from '../async-storage/work-store';
import { formatValidationEvent } from './dev-validation-events';
import { createSnapshot } from './async-local-storage';
import { getDevValidationWorker } from './dev-validation-worker-globals';
import { buildDevValidationSnapshot } from './dev-validation-worker-snapshot';
import { getAccessFallbackErrorTypeByStatus, getAccessFallbackHTTPStatus, isHTTPAccessFallbackError } from '../../client/components/http-access-fallback/http-access-fallback';
import { getURLFromRedirectError, getRedirectStatusCodeFromError } from '../../client/components/redirect';
import { isRedirectError } from '../../client/components/redirect-error';
import { getImplicitTags } from '../lib/implicit-tags';
import { AppRenderSpan, NextNodeServerSpan } from '../lib/trace/constants';
import { getRequestInsightsIdentity, runWithRequestInsightsIdentity } from '../lib/trace/request-insights-identity';
import { getTracer, SpanStatusCode } from '../lib/trace/tracer';
import { traceLocalSpan } from '../lib/trace/local-span-recorder';
import { isRequestInsightsEnabled } from '../lib/trace/request-insights';
import { FlightRenderResult } from './flight-render-result';
import { createReactServerErrorHandler, createHTMLErrorHandler, isUserLandError, getDigestForWellKnownError } from './create-error-handler';
import { dynamicParamTypes } from './get-short-dynamic-param-type';
import { getSegmentParam } from '../../shared/lib/router/utils/get-segment-param';
import { getScriptNonceFromHeader } from './get-script-nonce-from-header';
import { parseAndValidateFlightRouterState } from './parse-and-validate-flight-router-state';
import { createFlightRouterStateFromLoaderTree } from './create-flight-router-state-from-loader-tree';
import { handleAction } from './action-handler';
import { isBailoutToCSRError } from '../../shared/lib/lazy-dynamic/bailout-to-csr';
import { warn, error } from '../../build/output/log';
import { appendMutableCookies, RequestCookiesAdapter } from '../web/spec-extension/adapters/request-cookies';
import { HeadersAdapter } from '../web/spec-extension/adapters/headers';
import { createServerInsertedHTML } from './server-inserted-html';
import { getRequiredScripts } from './required-scripts';
import { addPathPrefix } from '../../shared/lib/router/utils/add-path-prefix';
import { makeGetServerInsertedHTML } from './make-get-server-inserted-html';
import { walkTreeWithFlightRouterState, createFullTreeFlightDataForNavigation } from './walk-tree-with-flight-router-state';
import { createComponentTree, getRootParams } from './create-component-tree';
import { getAssetQueryString } from './get-asset-query-string';
import { getClientReferenceManifest, getServerModuleMap } from './manifests-singleton';
import { DynamicState, DynamicHTMLPreludeState, parsePostponedState } from './postponed-state';
import { getDynamicDataPostponedState, getDynamicHTMLPostponedState, getPostponedFromState } from './postponed-state';
import { isDynamicServerError } from '../../client/components/hooks-server-context';
import { getFlightStream } from './use-flight-response';
import { StaticGenBailoutError, isStaticGenBailoutError } from '../../client/components/static-generation-bailout';
import { getStackWithoutErrorMessage } from '../../lib/format-server-error';
import { extractNextErrorCode } from '../../lib/error-telemetry-utils';
import { accessedDynamicData, createRenderInBrowserAbortSignal, formatDynamicAPIAccesses, isPrerenderInterruptedError, createDynamicTrackingState, createDynamicValidationState, trackAllowedDynamicAccess, throwIfDisallowedDynamic, PreludeState, consumeDynamicAccess, logDisallowedDynamicError, trackDynamicHoleInRuntimeShell, trackDynamicHoleInStaticShell, getStaticShellDisallowedDynamicReasons, getNavigationDisallowedDynamicReasons, trackDynamicHoleInNavigation, DynamicHoleKind, trackThrownErrorInNavigation, createInstantValidationState, throwIfSyncIOUsed } from './dynamic-rendering';
import { logBuildDebugHint } from './blocking-route-messages';
import { getClientComponentLoaderMetrics, wrapClientComponentLoader } from '../client-component-renderer-logger';
import { isNodeNextRequest, isNodeNextResponse } from '../base-http/helpers';
import { waitForResponseToFinish } from './wait-for-response';
import { beginDevValidation, yieldToForegroundRequest } from './dev-validation-scheduler';
import { signalFromNodeResponse } from '../web/spec-extension/adapters/next-request';
import { parseRelativeUrl } from '../../shared/lib/router/utils/parse-relative-url';
import AppRouter from '../../client/components/app-router';
import { getIsPossibleServerAction } from '../lib/server-action-request-meta';
import { createInitialRouterState } from '../../client/components/router-reducer/create-initial-router-state';
import { createMutableActionQueue } from '../../client/components/app-router-instance';
import { getRevalidateReason } from '../instrumentation/utils';
import { PAGE_SEGMENT_KEY } from '../../shared/lib/segment';
import { getFallbackRouteParams } from '../request/fallback-params';
import { ReactServerPrerenderResult, createReactServerPrerenderResult, ReactServerResult, ReplayableNodeStream, createReactServerPrerenderResultFromRender } from './app-render-prerender-utils';
import { Phase, printDebugThrownValueForProspectiveRender } from './prospective-render-utils';
import { runInSequentialTasks } from './app-render-render-utils';
import { waitAtLeastOneReactRenderTask } from '../../lib/scheduler';
import { getHmrRefreshHash, workUnitAsyncStorage } from './work-unit-async-storage.external';
import { consoleAsyncStorage } from './console-async-storage.external';
import { CacheSignal } from './cache-signal';
import { createResponseVaryParamsAccumulator, finishAccumulatingVaryParams, getMetadataVaryParamsAccumulator, getRootParamsVaryParamsAccumulator } from './vary-params';
import { getTracedMetadata } from '../lib/trace/utils';
import { InvariantError } from '../../shared/lib/invariant-error';
import { StaleTimeIterable, createSelectStaleTime, trackStaleTime } from './stale-time';
import { HTML_CONTENT_TYPE_HEADER, INFINITE_CACHE } from '../../lib/constants';
import { createComponentStylesAndScripts } from './create-component-styles-and-scripts';
import { parseLoaderTree } from '../../shared/lib/router/utils/parse-loader-tree';
import { createPrerenderResumeDataCache, createRenderResumeDataCache } from '../resume-data-cache/resume-data-cache';
import isError from '../../lib/is-error';
import { createServerInsertedMetadata } from './metadata-insertion/create-server-inserted-metadata';
import { getPreviouslyRevalidatedTags } from '../server-utils';
import { executeRevalidates } from '../revalidation-utils';
import { trackPendingChunkLoad, trackPendingImport, trackPendingModules } from './module-loading/track-module-loading.external';
import { isReactLargeShellError } from './react-large-shell-error';
import { normalizeConventionFilePath } from './segment-explorer-path';
import { getRequestMeta } from '../request-meta';
import { getDynamicParam, interpolateParallelRouteParams } from '../../shared/lib/router/utils/get-dynamic-param';
import { ImageConfigContext } from '../../shared/lib/image-config-context.shared-runtime';
import { imageConfigDefault } from '../../shared/lib/image-config';
import { getNextStage, isAdvanceableRenderStage, RENDER_STAGE_ADVANCE_ORDER, RenderStage, StagedRenderingController, SyncIOMode } from './staged-rendering';
import { anySegmentHasPartialPrefetchingEnabled, isPageAllowedToBlock, anySegmentNeedsInstantValidationInDev, anySegmentNeedsInstantValidationInBuild, resolveInstantConfigSamplesForPage } from './instant-validation/instant-config';
import { warnOnce } from '../../shared/lib/utils/warn-once';
import { createWebDebugChannel, createNodeDebugChannel } from './debug-channel-server';
import { createNodeStreamFromChunks, createNodeStreamWithLateRelease } from './instant-validation/stream-utils';
import { createValidationBoundaryTracking } from './instant-validation/boundary-tracking';
import { ResponseCookies } from '../web/spec-extension/cookies';
import { isInstantValidationError } from './instant-validation/instant-validation-error';
import { createPromiseWithResolvers } from '../../shared/lib/promise-with-resolvers';
import { RENDER_STAGES_BY_DATA_KIND } from '../dynamic-rendering-utils';
import { hasNonRootStaticParams } from '../lib/params-utils';
function maybeAppendBuildIdToRSCPayload(ctx, payload) {
    if (!ctx.sharedContext.deploymentId) {
        // When using the build id, we need to initialize the id on initial page load, so a build id
        // header wouldn't be enough.
        payload.b = ctx.sharedContext.buildId;
    }
    return payload;
}
const flightDataPathHeadKey = 'h';
const getFlightViewportKey = (requestId)=>requestId + 'v';
const getFlightMetadataKey = (requestId)=>requestId + 'm';
const filterStackFrame = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').filterStackFrameDEV : undefined;
function parseRequestHeaders(headers, options) {
    const isRSCRequest = isRSCRequestHeader(headers[RSC_HEADER]);
    // runtime prefetch requests are *not* treated as prefetch requests
    // (TODO: this is confusing, we should refactor this to express this better)
    const isPrefetchRequest = isRSCRequest && headers[NEXT_ROUTER_PREFETCH_HEADER] === '1';
    const isAppShellPrefetchRequest = isRSCRequest && headers[NEXT_ROUTER_PREFETCH_HEADER] === '3';
    // App Shell prefetches are a subtype of runtime prefetch — same code path,
    // but with less resolved content (omitting link data)
    const isRuntimePrefetchRequest = isRSCRequest && (headers[NEXT_ROUTER_PREFETCH_HEADER] === '2' || isAppShellPrefetchRequest);
    const isHmrRefresh = headers[NEXT_HMR_REFRESH_HEADER] !== undefined;
    const shouldProvideFlightRouterState = isRSCRequest && (!isPrefetchRequest || !options.isRoutePPREnabled);
    const flightRouterState = shouldProvideFlightRouterState ? parseAndValidateFlightRouterState(headers[NEXT_ROUTER_STATE_TREE_HEADER]) : undefined;
    // Checks if this is a prefetch of the Route Tree by the Segment Cache
    const isRouteTreePrefetchRequest = isRSCRequest && headers[NEXT_ROUTER_SEGMENT_PREFETCH_HEADER] === '/_tree';
    const csp = headers['content-security-policy'] || headers['content-security-policy-report-only'];
    const nonce = typeof csp === 'string' ? getScriptNonceFromHeader(csp) : undefined;
    const previouslyRevalidatedTags = getPreviouslyRevalidatedTags(headers, options.previewModeId);
    let requestId;
    let htmlRequestId;
    if (process.env.__NEXT_DEV_SERVER) {
        // The request IDs are only used for the dev server to send debug
        // information to the matching client (identified by the HTML request ID
        // that was sent to the client with the HTML document) for the current
        // request (identified by the request ID, as defined by the client).
        requestId = typeof headers[NEXT_REQUEST_ID_HEADER] === 'string' ? headers[NEXT_REQUEST_ID_HEADER] : undefined;
        htmlRequestId = typeof headers[NEXT_HTML_REQUEST_ID_HEADER] === 'string' ? headers[NEXT_HTML_REQUEST_ID_HEADER] : undefined;
    }
    return {
        flightRouterState,
        isPrefetchRequest,
        isRuntimePrefetchRequest,
        isAppShellPrefetchRequest,
        isRouteTreePrefetchRequest,
        isHmrRefresh,
        isRSCRequest,
        nonce,
        previouslyRevalidatedTags,
        requestId,
        htmlRequestId
    };
}
/**
 * Walks the loader tree to find the minimum `unstable_dynamicStaleTime` exported by
 * any page module. Returns null if no page exports the config.
 *
 * This only reads static exports from page modules — it does not render any
 * server components, so it's cheap to call.
 *
 * TODO: Move this to the prefetch hints file so we don't have to walk the
 * tree on every render.
 */ async function getDynamicStaleTime(tree) {
    const { page, parallelRoutes } = parseLoaderTree(tree);
    let result = null;
    // Only pages (not layouts) can export unstable_dynamicStaleTime.
    if (typeof page !== 'undefined') {
        const pageMod = await page[0]();
        if (pageMod && typeof pageMod.unstable_dynamicStaleTime === 'number') {
            const value1 = pageMod.unstable_dynamicStaleTime;
            result = result !== null ? Math.min(result, value1) : value1;
        }
    }
    const childPromises = [];
    for(const parallelRouteKey in parallelRoutes){
        childPromises.push(getDynamicStaleTime(parallelRoutes[parallelRouteKey]));
    }
    const childResults = await Promise.all(childPromises);
    for (const childResult of childResults){
        if (childResult !== null) {
            result = result !== null ? Math.min(result, childResult) : childResult;
        }
    }
    return result;
}
function createNotFoundLoaderTree(loaderTree) {
    const components = loaderTree[2];
    const hasGlobalNotFound = !!components['global-not-found'];
    const notFoundTreeComponents = hasGlobalNotFound ? {
        layout: components['global-not-found'],
        page: [
            ()=>null,
            'next/dist/client/components/builtin/empty-stub'
        ]
    } : {
        page: components['not-found']
    };
    return [
        '',
        {
            children: [
                PAGE_SEGMENT_KEY,
                {},
                notFoundTreeComponents,
                null
            ]
        },
        // Always include global-error so that getGlobalErrorStyles can access it.
        // When global-not-found is present, use full components.
        // Otherwise, only include global-error module.
        hasGlobalNotFound ? components : {
            'global-error': components['global-error']
        },
        null
    ];
}
/**
 * Returns a function that parses the dynamic segment and return the associated value.
 */ function makeGetDynamicParamFromSegment(interpolatedParams, fallbackRouteParams, optimisticRouting) {
    return function getDynamicParamFromSegment(loaderTree) {
        const [segment, , , staticSiblings] = loaderTree;
        const segmentParam = getSegmentParam(segment);
        if (!segmentParam) {
            return null;
        }
        const segmentKey = segmentParam.paramName;
        const dynamicParamType = dynamicParamTypes[segmentParam.paramType];
        // Static siblings are only included when optimistic routing is enabled
        const siblings = optimisticRouting ? staticSiblings : null;
        return getDynamicParam(interpolatedParams, segmentKey, dynamicParamType, fallbackRouteParams, siblings);
    };
}
function NonIndex({ createElement, 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 createElement('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: { routeModule: { userland: { loaderTree } }, createElement, createMetadataComponents, Fragment }, query, requestId, flightRouterState, workStore, url } = ctx;
    const serveStreamingMetadata = !!ctx.renderOpts.serveStreamingMetadata;
    if (!(options == null ? void 0 : options.skipPageRendering)) {
        var _ctx_renderOpts_prefetchHints;
        const preloadCallbacks = [];
        const requestStore = workUnitAsyncStorage.getStore();
        // If we're performing instant validation, we need to render the whole tree,
        // without skipping shared layouts.
        const needsFullTree = process.env.__NEXT_DEV_SERVER && ctx.renderOpts.cacheComponents && !((requestStore == null ? void 0 : requestStore.type) === 'request' && isBypassingCachesInDev(requestStore, workStore)) && !(options == null ? void 0 : options.actionResult) && // Only for navigations
        await anySegmentNeedsInstantValidationInDev(loaderTree);
        const { Viewport, Metadata, MetadataOutlet } = createMetadataComponents({
            tree: loaderTree,
            parsedQuery: query,
            pathname: url.pathname,
            metadataContext: createMetadataContext(ctx.renderOpts),
            interpolatedParams: ctx.interpolatedParams,
            serveStreamingMetadata
        });
        const rscHead = createElement(Fragment, {
            key: flightDataPathHeadKey
        }, createElement(NonIndex, {
            createElement,
            pagePath: ctx.pagePath,
            statusCode: ctx.res.statusCode,
            isPossibleServerAction: ctx.isPossibleServerAction
        }), createElement(Viewport, {
            key: getFlightViewportKey(requestId)
        }), createElement(Metadata, {
            key: getFlightMetadataKey(requestId)
        }));
        flightData = (needsFullTree ? await createFullTreeFlightDataForNavigation({
            ctx,
            loaderTree,
            rscHead,
            injectedCSS: new Set(),
            injectedJS: new Set(),
            injectedFontPreloadTags: new Set(),
            preloadCallbacks,
            MetadataOutlet
        }) : await walkTreeWithFlightRouterState({
            ctx,
            loaderTreeToFilter: loaderTree,
            parentParams: {},
            flightRouterState,
            rscHead,
            injectedCSS: new Set(),
            injectedJS: new Set(),
            injectedFontPreloadTags: new Set(),
            rootLayoutIncluded: false,
            preloadCallbacks,
            MetadataOutlet,
            hintTree: ((_ctx_renderOpts_prefetchHints = ctx.renderOpts.prefetchHints) == null ? void 0 : _ctx_renderOpts_prefetchHints[ctx.pagePath]) ?? null
        })).map((path)=>path.slice(1)) // remove the '' (root) segment
        ;
    }
    // In dev, the Vary header may not reliably reflect whether a route can
    // be intercepted, because interception routes are compiled on demand.
    // Default to true so the client doesn't cache a stale Fallback entry.
    const varyHeader = ctx.res.getHeader('vary');
    const couldBeIntercepted = !!process.env.__NEXT_DEV_SERVER || typeof varyHeader === 'string' && varyHeader.includes(NEXT_URL);
    // If we have an action result, then this is a server action response.
    // We can rely on this because `ActionResult` will always be a promise, even if
    // the result is falsey.
    if (options == null ? void 0 : options.actionResult) {
        return maybeAppendBuildIdToRSCPayload(ctx, {
            a: options.actionResult,
            f: flightData,
            q: getRenderedSearch(query),
            i: !!couldBeIntercepted
        });
    }
    // Otherwise, it's a regular RSC response.
    const baseResponse = maybeAppendBuildIdToRSCPayload(ctx, {
        f: flightData,
        q: getRenderedSearch(query),
        i: !!couldBeIntercepted,
        S: workStore.isStaticGeneration,
        h: getMetadataVaryParamsAccumulator(),
        r: getRootParamsVaryParamsAccumulator() ?? undefined
    });
    if ((options == null ? void 0 : options.staleTimeIterable) !== undefined) {
        baseResponse.s = options.staleTimeIterable;
    }
    if ((options == null ? void 0 : options.staticStageByteLengthPromise) !== undefined) {
        baseResponse.l = options.staticStageByteLengthPromise;
    }
    if ((options == null ? void 0 : options.shellByteLengthPromise) !== undefined) {
        baseResponse.a = options.shellByteLengthPromise;
    }
    if ((options == null ? void 0 : options.shellUsedSessionDataPromise) !== undefined) {
        baseResponse.u = options.shellUsedSessionDataPromise;
    }
    if ((options == null ? void 0 : options.runtimePrefetchStream) !== undefined) {
        baseResponse.p = options.runtimePrefetchStream;
    }
    // Include the per-page dynamic stale time from unstable_dynamicStaleTime, but only
    // for dynamic renders (not prerenders/static generation). The client treats
    // its presence as authoritative.
    // TODO: Move this to the prefetch hints file so we don't have to walk the
    // tree on every render.
    if (!workStore.isStaticGeneration) {
        const dynamicStaleTime = await getDynamicStaleTime(ctx.componentMod.routeModule.userland.loaderTree);
        if (dynamicStaleTime !== null) {
            baseResponse.d = dynamicStaleTime;
        }
    }
    return baseResponse;
}
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: 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 { htmlRequestId, renderOpts, requestId, workStore } = ctx;
    const { onInstrumentationRequestError, setReactDebugChannel, isBuildTimePrerendering = false } = renderOpts;
    function onFlightDataRenderError(err, silenceLog) {
        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
    }
    const onError = createReactServerErrorHandler(process.env.NODE_ENV === 'development', isBuildTimePrerendering, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
    // With Server Components HMR cancellation enabled, a superseded HMR refresh
    // aborts its own client fetch, which closes this response. We use that
    // response-close to abort the discarded render. This is the
    // non-Cache-Components dev RSC path; unlike the Cache Components staged path
    // it has no detached validation, so the render is the only work to cancel.
    const requestAbortSignal = process.env.__NEXT_DEV_SERVER && renderOpts.experimental.serverComponentsHmrCancellation === true && requestStore.isHmrRefresh === true && isNodeNextResponse(ctx.res) ? signalFromNodeResponse(ctx.res.originalResponse) : undefined;
    if (process.env.__NEXT_USE_NODE_STREAMS) {
        const debugChannel = setReactDebugChannel && createNodeDebugChannel();
        if (debugChannel) {
            setReactDebugChannel(debugChannel.clientSide, htmlRequestId, requestId);
        }
        const { clientModules } = getClientReferenceManifest();
        const rscPayload = await workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, options);
        const flightStream = workUnitAsyncStorage.run(requestStore, renderToNodeFlightStream, ctx.componentMod, rscPayload, clientModules, {
            onError,
            temporaryReferences: options == null ? void 0 : options.temporaryReferences,
            filterStackFrame,
            debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide,
            signal: requestAbortSignal
        });
        return new FlightRenderResult(flightStream, {
            fetchMetrics: workStore.fetchMetrics
        }, options == null ? void 0 : options.waitUntil);
    } else {
        const debugChannel = setReactDebugChannel && createWebDebugChannel();
        if (debugChannel) {
            setReactDebugChannel(debugChannel.clientSide, htmlRequestId, requestId);
        }
        const { clientModules } = getClientReferenceManifest();
        const rscPayload = await workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, options);
        const flightStream = workUnitAsyncStorage.run(requestStore, renderToWebFlightStream, ctx.componentMod, rscPayload, clientModules, {
            onError,
            temporaryReferences: options == null ? void 0 : options.temporaryReferences,
            filterStackFrame,
            debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide,
            signal: requestAbortSignal
        });
        return new FlightRenderResult(flightStream, {
            fetchMetrics: workStore.fetchMetrics
        }, options == null ? void 0 : options.waitUntil);
    }
}
/**
 * Production-only staged dynamic flight render for cache components (Node.js
 * streams). Uses staged rendering to separate static (RDC-backed) from
 * runtime/dynamic content.
 */ async function generateStagedDynamicFlightRenderResultNode(req, ctx, requestStore) {
    const { componentMod, workStore, renderOpts } = ctx;
    const { routeModule } = componentMod;
    const { loaderTree } = routeModule.userland;
    const { onInstrumentationRequestError, experimental } = renderOpts;
    function onFlightDataRenderError(err, silenceLog) {
        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
    }
    const onError = createReactServerErrorHandler(false, false, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
    const selectStaleTime = createSelectStaleTime(experimental);
    const staleTimeIterable = new StaleTimeIterable();
    const stageController = new StagedRenderingController({
        abortSignal: null,
        abandonController: null,
        // TODO(cached-navs): this assumes that we checked during build that there's no sync IO.
        // but it can happen e.g. after a revalidation or conditionally for a param that wasn't prerendered.
        // we should change this to track sync IO, log an error and advance to dynamic.
        syncIO: SyncIOMode.Untracked,
        finalStage: null
    });
    // Initialize stale time tracking on the request store.
    requestStore.stale = INFINITE_CACHE;
    requestStore.stagedRendering = stageController;
    requestStore.varyParamsAccumulator = createResponseVaryParamsAccumulator();
    requestStore.asyncApiPromises = createAsyncApiPromises(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
    trackStaleTime(requestStore, staleTimeIterable, selectStaleTime);
    const shellByteLengthDeferred = createPromiseWithResolvers();
    const staticStageByteLengthDeferred = createPromiseWithResolvers();
    let runtimePrefetchStream;
    // Check if this route should runtime-cache its navigation. This happens when
    // Partial Prefetching is enabled for the route, either per segment (a
    // `prefetch` of 'partial' or 'unstable_eager') or globally (the
    // `partialPrefetching` config). If so, we piggyback on the dynamic render to
    // fill caches and then spawn a final runtime prerender whose result stream
    // is embedded in the RSC payload. This is gated because it adds extra server
    // processing and increases the response payload size.
    if (Boolean(renderOpts.partialPrefetching) || await anySegmentHasPartialPrefetchingEnabled(loaderTree)) {
        // Create a mutable cache that gets filled during the dynamic render.
        const prerenderResumeDataCache = createPrerenderResumeDataCache();
        requestStore.resumeDataCache = prerenderResumeDataCache;
        const cacheSignal = new CacheSignal();
        trackPendingModules(cacheSignal);
        requestStore.cacheSignal = cacheSignal;
        // Create a deferred stream for the runtime prefetch result. Its readable
        // side goes into the RSC payload (Flight serializes it lazily). The
        // writable side receives the runtime prerender result once the dynamic
        // render has filled all caches.
        const runtimePrefetchTransform = new TransformStream();
        runtimePrefetchStream = runtimePrefetchTransform.readable;
        // Wait for the dynamic render to fill caches, then run the final runtime
        // prerender (fire-and-forget — does not block the response).
        void cacheSignal.cacheReady().then(()=>spawnRuntimePrefetchWithFilledCaches(runtimePrefetchTransform.writable, ctx, prerenderResumeDataCache, requestStore, onError));
    }
    const rscPayload = await workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, {
        staleTimeIterable,
        staticStageByteLengthPromise: staticStageByteLengthDeferred.promise,
        shellByteLengthPromise: shellByteLengthDeferred.promise,
        runtimePrefetchStream
    });
    const { clientModules } = getClientReferenceManifest();
    const flightStream = await runInSequentialTasks(()=>{
        stageController.advanceStage(RenderStage.ShellStatic);
        const sourceStream = workUnitAsyncStorage.run(requestStore, renderToNodeFlightStream, ctx.componentMod, rscPayload, clientModules, {
            onError,
            filterStackFrame
        });
        const replayable = new ReplayableNodeStream(sourceStream);
        const dynamicStream = replayable.createReplayStream();
        const staticStream = replayable.createReplayStream();
        void countShellAndStaticStageBytes(staticStream, stageController).then((byteLengths)=>{
            staticStageByteLengthDeferred.resolve(byteLengths[RenderStage.Static]);
            shellByteLengthDeferred.resolve(byteLengths[RenderStage.ShellStatic]);
        });
        return dynamicStream;
    }, ()=>{
        stageController.advanceStage(RenderStage.Static);
    }, ()=>{
        // This is a separate task that doesn't advance a stage. It forces
        // draining the immediate queue so that the stale time iterable and vary
        // params accumulators are flushed before we advance to the dynamic stage.
        staleTimeIterable.close();
        if (requestStore.varyParamsAccumulator) {
            finishAccumulatingVaryParams(requestStore.varyParamsAccumulator);
        }
    }, ()=>{
        stageController.advanceStage(RenderStage.Dynamic);
    });
    return new FlightRenderResult(flightStream, {
        fetchMetrics: workStore.fetchMetrics
    });
}
/**
 * Runs a final runtime prerender using the provided (already filled) cache and
 * pipes its output into the provided writable stream. The caller is responsible
 * for waiting until caches are warm before calling this function.
 */ async function spawnRuntimePrefetchWithFilledCaches(writable, ctx, prerenderResumeDataCache, requestStore, onError) {
    try {
        const { componentMod, getDynamicParamFromSegment } = ctx;
        const { loaderTree } = componentMod.routeModule.userland;
        const rootParams = getRootParams(loaderTree, getDynamicParamFromSegment);
        const staleTimeIterable = new StaleTimeIterable();
        // We want to be able to rewind the result to a session shell.
        const mode = {
            type: 'rewindable-session-shell',
            shellUsedSessionDataDeferred: createPromiseWithResolvers(),
            shellByteLengthDeferred: createPromiseWithResolvers()
        };
        const { result } = await finalRuntimeServerPrerender(mode, ctx, generateDynamicRSCPayload.bind(null, ctx, {
            staleTimeIterable,
            shellByteLengthPromise: mode.type === 'rewindable-session-shell' ? mode.shellByteLengthDeferred.promise : undefined,
            shellUsedSessionDataPromise: mode.shellUsedSessionDataDeferred.promise
        }), prerenderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode, onError, staleTimeIterable, // This path is only reached on the production Cache Components + Cached
        // Navigations renders (the staged Flight response and the HTML hydration
        // payload), which set up no React debug channel.
        undefined);
        await result.prelude.pipeTo(writable);
    } catch  {
        // Runtime prerender failed. Close the stream gracefully — the navigation
        // still works, we just won't get cached runtime data.
        try {
            await writable.close();
        } catch  {
        // Writable may already be closed/errored.
        }
    }
}
async function stagedRenderWithoutCachesInDevNode(ctx, requestStore, getPayload, options) {
    // We're rendering while bypassing caches,
    // so we have no hope of showing a useful runtime stage.
    // But we still want things like `params` to show up in devtools correctly,
    // which relies on mechanisms we've set up for staged rendering,
    // so we do a 2-task version (Static -> Dynamic) instead.
    // We aren't filling caches so we don't need to abort this render, it'll
    // stream in a single pass
    const stageController = new StagedRenderingController({
        abortSignal: null,
        abandonController: null,
        syncIO: SyncIOMode.Untracked,
        finalStage: null
    });
    const environmentName = ()=>{
        const currentStage = stageController.currentStage;
        return getEnvironmentNameForStageWithoutCaches(currentStage);
    };
    requestStore.stagedRendering = stageController;
    requestStore.asyncApiPromises = createAsyncApiPromises(stageController, requestStore.cookies, requestStore.mutableCookies, requestStore.headers);
    const { clientModules } = getClientReferenceManifest();
    const rscPayload = await getPayload(requestStore);
    return await runInSequentialTasks(()=>{
        stageController.advanceStage(RenderStage.ShellStatic);
        return workUnitAsyncStorage.run(requestStore, renderToNodeFlightStream, ctx.componentMod, rscPayload, clientModules, {
            ...options,
            environmentName
        });
    }, ()=>{
        stageController.advanceStage(RenderStage.Static);
    }, ()=>{
        stageController.advanceStage(RenderStage.Dynamic);
    });
}
function getEnvironmentNameForStageWithoutCaches(stage) {
    switch(stage){
        case RenderStage.Before:
        case RenderStage.ShellStatic:
        case RenderStage.Static:
            return 'Prerender';
        case RenderStage.ShellRuntime:
        case RenderStage.Runtime:
        case RenderStage.Dynamic:
        case RenderStage.Abandoned:
            return 'Server';
        default:
            stage;
            throw Object.defineProperty(new InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
                value: "E881",
                enumerable: false,
                configurable: true
            });
    }
}
/**
 * Fork of `generateDynamicFlightRenderResult` that renders using `renderWithRestartOnCacheMissInDev`
 * to ensure correct separation of environments Prerender/Server (for use in Cache Components)
 */ async function generateDynamicFlightRenderResultWithStagesInDev(req, ctx, initialRequestStore, createRequestStore, fallbackParams) {
    const { htmlRequestId, renderOpts, requestId, workStore, componentMod: { createElement, routeModule: { userland: { loaderTree } } }, url } = ctx;
    const { onInstrumentationRequestError, setReactDebugChannel, setCacheStatus, isBuildTimePrerendering = false } = renderOpts;
    let didErrorObservably = false;
    function onFlightDataRenderError(err, silenceLog) {
        didErrorObservably = true;
        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
    }
    const onError = createReactServerErrorHandler(process.env.NODE_ENV === 'development', isBuildTimePrerendering, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
    // We validate RSC requests for HMR refreshes and client navigations when
    // instant configs exist, since we render all the layouts necessary to perform
    // the validation in those cases.
    const shouldValidate = !ctx.isPrefetch && !isBypassingCachesInDev(initialRequestStore, workStore) && (initialRequestStore.isHmrRefresh === true || await anySegmentNeedsInstantValidationInDev(loaderTree));
    const getPayload = async (requestStore)=>{
        const payload = await workUnitAsyncStorage.run(requestStore, generateDynamicRSCPayload, ctx, undefined);
        if (isBypassingCachesInDev(requestStore, workStore)) {
            // Mark the RSC payload to indicate that caches were bypassed in dev.
            // This lets the client know not to cache anything based on this render.
            payload._bypassCachesInDev = createElement(WarnForBypassCachesInDev, {
                route: workStore.route
            });
        } else if (shouldValidate) {
            // If this payload will be used for validation, it needs to contain the
            // canonical URL. Without it we'd get an error.
            payload.c = prepareInitialCanonicalUrl(url);
        }
        return payload;
    };
    let debugChannel;
    let stream;
    if (// We only do this flow if we can safely recreate the store from scratch
    // (which is not the case for renders after an action)
    createRequestStore && // We only do this flow if we're not bypassing caches in dev using
    // "disable cache" in devtools, a hard refresh (cache-control: "no-cache"),
    // or draft mode.
    !isBypassingCachesInDev(initialRequestStore, workStore)) {
        // Before we kick off the render, we set the cache status back to it's initial state
        // in case a previous render bypassed the cache.
        if (setCacheStatus) {
            setCacheStatus('ready', htmlRequestId);
        }
        const prefetchMode = await getPrefetchingModeForPage(renderOpts, loaderTree);
        // A client navigation into a Partial Prefetching route extends the shell
        // through the runtime-prefetchable content: it has already settled on the
        // client (via the prefetch) by the time it navigates, so it belongs in this
        // response's shell. Everything else uses the static shell, like an initial
        // load: plain navigations, and HMR refreshes (a fresh render of the current
        // page, with no settled prefetch to draw on). Dynamic content always
        // streams in after the shell.
        let prefetchStage;
        if (initialRequestStore.isHmrRefresh === true) {
            prefetchStage = RenderStage.Static;
        } else {
            if (prefetchMode === 2) {
                // TODO(app-shells): model `partialPrefetching: "unstable_eager"`
                // TODO(app-shells): if this navigation came from <Link prefetch={true} />,
                // we should show the shell for a speculative prefetch
                // (which can have more data than the app shell)
                prefetchStage = RenderStage.ShellRuntime;
            } else {
                prefetchStage = RenderStage.Static;
            }
        }
        // With Server Components HMR cancellation enabled, a superseded HMR refresh
        // aborts its own client fetch (see the client-side supersession logic),
        // which closes this response. We use that response-close as the signal to
        // stop the server work this refresh started that's now discarded: the
        // streaming render below is aborted, and the detached validation is skipped
        // (including aborting the background renders it uses to prepare its
        // inputs). The render's in-flight `'use cache'` fills are left running,
        // since they aren't tied to its controller. A superseding refresh can't
        // reuse those fills today, because each edit changes the HMR hash baked
        // into the cache key; that becomes useful only once those keys use
        // implementation-derived hashes instead (see `use-cache-wrapper.ts`).
        //
        // The detached validation is Cache Components only: it runs only on this
        // staged dev render, so there's nothing to skip on the non-Cache Components
        // dev RSC path. That path (`generateDynamicFlightRenderResult`) aborts its
        // superseded render the same way; it just has no validation to skip.
        //
        // TODO: The gate is `isHmrRefresh` for now because that's the only case we
        // cancel today. The response-close signal itself is general, so this could
        // later be relaxed to also cover a browser stop or a devtools "cancel
        // render" button.
        const requestAbortSignal = renderOpts.experimental.serverComponentsHmrCancellation === true && initialRequestStore.isHmrRefresh === true && isNodeNextResponse(ctx.res) ? signalFromNodeResponse(ctx.res.originalResponse) : undefined;
        const result = await stagedRenderWithCachesInDev({
            prefetchMode,
            ctx,
            requestStore: initialRequestStore,
            createRequestStore,
            getPayload,
            onError,
            shouldValidate,
            fallbackRouteParams: fallbackParams,
            getDevRenderDidError: ()=>didErrorObservably,
            navigationKind: {
                type: 'prefetched-client',
                prefetchStage
            },
            requestAbortSignal
        });
        stream = result.stream;
        debugChannel = result.debugChannel;
    } else {
        // We're either bypassing caches or we can't restart the render.
        // Do a dynamic render, but with (basic) environment labels.
        // Set cache status to bypass when specifically bypassing caches in dev
        if (setCacheStatus) {
            setCacheStatus('bypass', htmlRequestId);
        }
        debugChannel = setReactDebugChannel && createNodeDebugChannel();
        stream = await stagedRenderWithoutCachesInDevNode(ctx, initialRequestStore, getPayload, {
            onError: onError,
            filterStackFrame,
            debugChannel: debugChannel == null ? void 0 : debugChannel.serverSide
        });
    }
    if (debugChannel && setReactDebugChannel) {
        setReactDebugChannel(debugChannel.clientSide, htmlRequestId, requestId);
    }
    return new FlightRenderResult(stream, {
        fetchMetrics: workStore.fetchMetrics
    });
}
async function generateRuntimePrefetchResult(req, ctx, requestStore, isShellPrefetch) {
    const { workStore, renderOpts, htmlRequestId, requestId } = ctx;
    const { isBuildTimePrerendering = false, onInstrumentationRequestError, setReactDebugChannel } = renderOpts;
    function onFlightDataRenderError(err, silenceLog) {
        return onInstrumentationRequestError == null ? void 0 : onInstrumentationRequestError(err, req, // TODO(runtime-ppr): should we use a different value?
        createErrorContext(ctx, 'react-server-components-payload'), silenceLog);
    }
    const onError = createReactServerErrorHandler(false, isBuildTimePrerendering, workStore.reactServerErrorsByDigest, onFlightDataRenderError);
    const metadata = {};
    const staleTimeIterable = new StaleTimeIterable();
    const { componentMod: { routeModule: { userland: { loaderTree } } }, getDynamicParamFromSegment } = ctx;
    const rootParams = getRootParams(loaderTree, getDynamicParamFromSegment);
    // We need to share caches between the prospective prerender and the final prerender,
    // but we're not going to persist this anywhere.
    const prerenderResumeDataCache = createPrerenderResumeDataCache();
    await prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, generateDynamicRSCPayload.bind(null, ctx), prerenderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode);
    const mode = isShellPrefetch ? {
        type: 'session-shell-only',
        shellUsedSessionDataDeferred: createPromiseWithResolvers()
    } : {
        type: 'rewindable-session-shell',
        shellUsedSessionDataDeferred: createPromiseWithResolvers(),
        shellByteLengthDeferred: createPromiseWithResolvers()
    };
    const debugChannel = setReactDebugChannel ? createWebDebugChannel() : undefined;
    if (debugChannel && setReactDebugChannel) {
        setReactDebugChannel(debugChannel.clientSide, htmlRequestId, requestId);
    }
    const response = await finalRuntimeServerPrerender(mode, ctx, generateDynamicRSCPayload.bind(null, ctx, {
        staleTimeIterable,
        shellByteLengthPromise: mode.type === 'rewindable-session-shell' ? mode.shellByteLengthDeferred.promise : undefined,
        shellUsedSessionDataPromise: mode.shellUsedSessionDataDeferred.promise
    }), prerenderResumeDataCache, rootParams, requestStore.headers, requestStore.cookies, requestStore.draftMode, onError, staleTimeIterable, debugChannel == null ? void 0 : debugChannel.serverSide);
    applyMetadataFromPrerenderResult(response, metadata, workStore);
    metadata.fetchMetrics = ctx.workStore.fetchMetrics;
    return new FlightRenderResult(response.result.prelude, metadata);
}
async function prospectiveRuntimeServerPrerender(ctx, isShellPrefetch, getPayload, resumeDataCache, rootParams, headers, cookies, draftMode) {
    const { implicitTags, renderOpts, workStore } = ctx;
    const { ComponentMod } = renderOpts;
    // Prerender controller represents the lifetime of the prerender.
    // It will be aborted when a Task is complete or a synchronously aborting
    // API is called. Notably during cache-filling renders this does not actually
    // 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();
    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: INFINITE_CACHE,
        tags: [
            ...implicitTags.tags
        ],
        resumeDataCache,
        hmrRefreshHash: undefined,
        // We don't track vary params during initial prerender, only the final one
        varyParamsAccumulator: null,
        // No stage sequencing needed for prospective renders.
        stagedRendering: null,
        isSessionShell: isShellPrefetch,
        // These are not present in regular prerenders, but allowed in a runtime
        // prerender.
        // Any cache keyed on headers() or cookies() needs to be invalidated.
        // Otherwise some Next.js API semantics leak across render passes.
        headers: HeadersAdapter.fresh(headers),
        cookies: RequestCookie