@rebask/core 0.2.1 → 0.4.0

package/dist/handlers/rsc.js

@@ -1,872 +0,0 @@
-import { createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, loadServerAction, } from "@vitejs/plugin-rsc/rsc";
-import { injectRSCPayload } from "rsc-html-stream/server";
-import { pprUpgradeConfig } from "virtual:rebask/ppr-upgrade-config";
-import { proxyPatterns } from "virtual:rebask/proxy-router";
-import { errorModules } from "../lib/app-manifest.js";
-import { readActionBody } from "../lib/body-size-limit.js";
-import {} from "../lib/cache-context.js";
-import { CacheEntryType } from "../lib/cache-storage.js";
-import { getCacheHandler } from "../lib/config.js";
-import { getDeploymentId, getDeploymentScopedCacheKey, REBASK_DEPLOYMENT_ID_HEADER, } from "../lib/deployment-id.js";
-import { sendDevError, sendDevWarning, resetDevOverlayReady, warmupSsrModules, } from "../lib/dev-server.js";
-import { isNotFoundError } from "../lib/errors.js";
-import { noPrerenderNotFoundError, noPrerenderWarning } from "../lib/messages.js";
-import { getCacheControlHeader, REBASK_PRERENDER_HEADER, REBASK_RESUME_HEADER, } from "../lib/ppr/headers.js";
-import { parseResumeState, serializeResumeState } from "../lib/ppr/postponed-state.js";
-import { ResumeMode } from "../lib/ppr/types.js";
-import { prerenderPaths } from "../lib/prerender-paths.js";
-import { getActiveErrorBoundary, getNearestErrorBoundaryIndex, getNearestNotFoundBoundaryIndex, maybeAbort, RenderStorage, } from "../lib/render-context.js";
-import {} from "../lib/route-matcher.js";
-import { getRoutePrediction } from "../lib/route-prediction.js";
-import { renderPageSegment, renderRouteSegments } from "../lib/route-renderer.js";
-import { buildRouteTree } from "../lib/route-tree.js";
-import { cacheRscStream, createRscResponse, readCachedRscResponse, renderRsc, runRscRequest, } from "../lib/rsc-request.js";
-import { waitForMicrotaskDrain } from "../lib/scheduler-patch.js";
-import { chainStreams } from "../lib/stream-utils.js";
-import { ActionErrorCode } from "../lib/types.js";
-import { getBoundaryError, getCacheLife, hasRenderError, hasRequestIO, isNotFound, markNotFound, markNotFoundThrown, markRenderError, mergeResponseHeaders, notFoundWasThrown, OutgoingResponseHeaders, setBoundaryError, withRequestStorage, } from "../request-context.js";
-import { actionNotFoundResponse, applyActionResponseHeaders, validateActionAccept, validateActionContentType, validateActionOrigin, } from "./server-actions.js";
-const STATIC = 31536000; // 365 days
-const CRAWLER_USER_AGENT_RE = /Googlebot(?!-)|Googlebot$|Mediapartners-Google|AdsBot-Google|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview/i;
-class RetryWithBoundaryError extends Error {
-    boundaryIndex;
-    originalError;
-    constructor(boundaryIndex, originalError) {
-        super(`Retry render with error boundary ${boundaryIndex}`);
-        this.boundaryIndex = boundaryIndex;
-        this.originalError = originalError;
-    }
-}
-class RetryWithNotFoundBoundaryError extends Error {
-    boundaryIndex;
-    constructor(boundaryIndex) {
-        super(`Retry render with not-found boundary ${boundaryIndex}`);
-        this.boundaryIndex = boundaryIndex;
-    }
-}
-async function cacheHtml(key, html, cacheLife, postponed) {
-    const revalidate = cacheLife?.revalidate ?? STATIC;
-    try {
-        return await getCacheHandler().set(key, {
-            type: CacheEntryType.HTML,
-            timestamp: Date.now(),
-            expire: cacheLife?.expire ?? revalidate,
-            revalidate,
-            html,
-            tags: cacheLife?.tags?.size ? [...cacheLife.tags] : undefined,
-            ...(postponed && { postponed }),
-        });
-    }
-    catch (error) {
-        console.error("[rebask] Failed to cache HTML:", error);
-    }
-}
-const pendingInlineRenders = new Map();
-function scheduleBackgroundInlineRender(key, render) {
-    if (pendingInlineRenders.has(key))
-        return;
-    const promise = (async () => {
-        const existing = await getCacheHandler().get(key);
-        if (existing?.type === CacheEntryType.HTML && !existing.postponed)
-            return;
-        await render();
-    })()
-        .catch((err) => console.error(`[rebask] Background inline render failed for ${key}:`, err))
-        .finally(() => pendingInlineRenders.delete(key));
-    pendingInlineRenders.set(key, promise);
-}
-// Pre-load the SSR entry module in production
-const ssrEntryModulePromise = import.meta.env.PROD ? loadSSREntryModule() : null;
-function loadSSREntryModule() {
-    return import.meta.viteRsc.loadModule("ssr", "index");
-}
-async function getSSREntryModule() {
-    return ssrEntryModulePromise ?? loadSSREntryModule();
-}
-/**
- * Parse the POST request body based on the request type (action, resume, or form).
- * Returns early Response for invalid resume requests.
- */
-async function parsePostBody(request, isResumeRequest) {
-    const csrfRejection = validateActionOrigin(request);
-    if (csrfRejection)
-        return csrfRejection;
-    if (isResumeRequest) {
-        const resumeStateString = await request.text();
-        if (!resumeStateString) {
-            return new Response("Missing resume state", {
-                status: 400,
-                headers: {
-                    "Content-Type": "text/plain",
-                    "cache-control": "no-store",
-                },
-            });
-        }
-        return { resumeState: parseResumeState(resumeStateString) };
-    }
-    const actionId = request.headers.get("x-rsc-action");
-    const responseHeaders = new OutgoingResponseHeaders();
-    if (actionId) {
-        const [file, name] = actionId.split("#");
-        if (!file || !name)
-            return actionNotFoundResponse();
-        const acceptRejection = validateActionAccept(request);
-        if (acceptRejection)
-            return acceptRejection;
-        const contentType = validateActionContentType(request, true);
-        if (typeof contentType !== "string")
-            return contentType;
-        const isFormAction = contentType.startsWith("multipart/form-data") ?? false;
-        const body = await readActionBody(request, isFormAction);
-        if (body instanceof Response)
-            return body;
-        let action;
-        try {
-            action = await loadServerAction(actionId);
-            if (typeof action !== "function")
-                return actionNotFoundResponse();
-        }
-        catch {
-            return actionNotFoundResponse();
-        }
-        const temporaryReferences = createTemporaryReferenceSet();
-        return await withRequestStorage({ input: { request }, response: { headers: responseHeaders }, isAction: true }, async () => {
-            try {
-                const args = await decodeReply(body, { temporaryReferences });
-                const data = await action.apply(null, args);
-                return {
-                    returnValue: { ok: true, data },
-                    temporaryReferences,
-                    responseHeaders,
-                };
-            }
-            catch (error) {
-                if (isNotFoundError(error)) {
-                    return { actionError: ActionErrorCode.NotFound, temporaryReferences, responseHeaders };
-                }
-                else {
-                    console.error(error);
-                    return {
-                        returnValue: {
-                            ok: false,
-                            data: import.meta.env.DEV
-                                ? error
-                                : new Error("An error occurred while running a Server Action. The specific message is omitted in production builds to avoid leaking sensitive details."),
-                        },
-                        temporaryReferences,
-                        responseHeaders,
-                    };
-                }
-            }
-        });
-    }
-    // Form action (no-JS path: native browser form submission, no `x-rsc-action`)
-    const contentType = validateActionContentType(request, false);
-    if (typeof contentType !== "string")
-        return contentType;
-    return await withRequestStorage({ input: { request }, response: { headers: responseHeaders }, isAction: true }, async () => {
-        try {
-            const formDataResult = await readActionBody(request, true);
-            if (formDataResult instanceof Response)
-                return formDataResult;
-            const formData = formDataResult;
-            const decodedAction = await decodeAction(formData);
-            const result = await decodedAction();
-            const formState = await decodeFormState(result, formData);
-            return { formState, responseHeaders };
-        }
-        catch (error) {
-            if (isNotFoundError(error)) {
-                return { actionError: ActionErrorCode.NotFound, responseHeaders };
-            }
-            else {
-                console.error(error);
-                return { actionThrownError: error, responseHeaders };
-            }
-        }
-    });
-}
-function buildErrorRoute(errorPath) {
-    return {
-        type: "error",
-        filePath: errorPath,
-        segments: [{ type: "static", value: "" }],
-        layouts: [],
-    };
-}
-function buildDefaultErrorRoute() {
-    return {
-        type: "error",
-        segments: [],
-        layouts: [],
-    };
-}
-function onNotFound() {
-    if (import.meta.env.DEV && notFoundWasThrown()) {
-        const msg = "A `<NotFoundBoundary>` fallback called `notFound()` during server rendering. A " +
-            "fallback must render UI, not re-trigger `notFound()` — if you need it to escalate " +
-            "to the parent boundary, make it a client component so React can handle in the client.";
-        console.error("[rebask]", msg);
-        sendDevError(msg);
-    }
-    markNotFoundThrown();
-}
-/**
- * Page route handler for RSC rendering.
- * Called by the router after a page route is matched, and during prerendering.
- */
-export async function handlePageRoute(request, route, params, handleOptions) {
-    const { isBuildPrerender = false, onBuildPrerenderMeta } = handleOptions ?? {};
-    const url = new URL(request.url);
-    const isPost = request.method === "POST";
-    const isResumeRequest = isPost && request.headers.get(REBASK_RESUME_HEADER) === "1";
-    const isNotFoundRoute = route.type === "not-found";
-    const isErrorRoute = route.type === "error";
-    const isPageRoute = route.type === "page";
-    // `handlePageRoute` does recursive calls with the original request, so we have check that the
-    // page type hasn't changed.
-    const isActionOrResumeRequest = isPost && !isNotFoundRoute && !isErrorRoute;
-    let postBody = {};
-    if (isActionOrResumeRequest) {
-        // Parse POST body (actions, resume requests, or form submissions).
-        const result = await parsePostBody(request, isResumeRequest);
-        if (result instanceof Response)
-            return result;
-        postBody = result;
-    }
-    const { returnValue, formState, temporaryReferences, actionError, actionThrownError } = postBody;
-    // resumeState can come from POST body or from cache lookup later
-    let resumeState = postBody.resumeState;
-    const match = { route, params };
-    const isRscRequest = request.headers.get("accept")?.includes("text/x-component") ?? false;
-    if (!isRscRequest && import.meta.env.DEV) {
-        resetDevOverlayReady();
-    }
-    const isActionRscRequest = isActionOrResumeRequest && isRscRequest && !isResumeRequest;
-    const isHtmlRequest = !isPost && !isRscRequest && !isErrorRoute;
-    const routeTree = buildRouteTree(match);
-    const routePrediction = getRoutePrediction(route);
-    const isBotRequest = __REBASK_FULL_HTML_FOR_BOTS &&
-        isHtmlRequest &&
-        CRAWLER_USER_AGENT_RE.test(request.headers.get("user-agent") ?? "");
-    // Handle route tree request (JSON, no async context needed)
-    const isTreeRequest = request.headers.get("x-rebask-tree") === "1";
-    if (isTreeRequest) {
-        const routeJson = JSON.stringify(routePrediction ? [routeTree, routePrediction] : [routeTree]);
-        return new Response(routeJson, {
-            headers: {
-                "content-type": "application/json",
-                // TODO: not sure if this can be cached, to evaluate later.
-                "cache-control": getCacheControlHeader({ revalidate: 0 }),
-                vary: "accept, x-rebask-tree",
-                ...(getDeploymentId() ? { [REBASK_DEPLOYMENT_ID_HEADER]: getDeploymentId() } : {}),
-            },
-        });
-    }
-    if (isRscRequest && !isPost && !resumeState && !isErrorRoute) {
-        const cachedResponse = await readCachedRscResponse(url);
-        if (cachedResponse)
-            return cachedResponse;
-    }
-    // PPR: Should we prerender and detect postponed content
-    const shouldPrerender = !__REBASK_SSR_STRATEGY && !isBotRequest && isHtmlRequest;
-    // Static generation mode (for data caching - includes RSC requests)
-    const isStaticGen = import.meta.env.PROD && !isPost;
-    const isDynamicRoute = route.segments.some((seg) => seg.type !== "static");
-    // Runtime prerender: render to completion (full HTML) instead of aborting on dynamic.
-    let isPrerenderUpgrade = false;
-    if (pprUpgradeConfig && !isResumeRequest) {
-        isPrerenderUpgrade = request.headers.get(pprUpgradeConfig.forceFullRenderHeader) !== null;
-    }
-    // If the params are resolved, then `routeParams()` resolves synchronously during prerendering
-    // and we don't abort the shell if it's used.
-    //
-    // Not founds are the exception: their params describe the unmatched path, which is per-request
-    // data. Resolving them inline at build would bake one path's value into a shared shell and serve
-    // it for every unmatched URL. Treating them as unresolved keeps `routeParams()` dynamic, so a
-    // not-found fallback that reads the path is captured as a per-request resume (and, when it lives
-    // inside <Suspense>, the `notFound()` surfaces during that resume and `NotFoundBoundary`
-    // recovers it on the client).
-    const paramsResolved = !isNotFoundRoute &&
-        (isBuildPrerender
-            ? route.segments.every((seg) => seg.type === "static" || seg.type === "group" || seg.name in params)
-            : isPrerenderUpgrade); // The adapter can enable runtime prerendering.
-    let htmlCacheKey = null;
-    // URL-specific cache key preserved before the lookup may overwrite
-    // htmlCacheKey to the shell key for dynamic routes. Used to cache the
-    // full page result (shell + resume) after the first PPR resume.
-    let fullPageCacheKey = null;
-    let isNoShellRoute = false;
-    let htmlCacheEntry = null;
-    if (shouldPrerender) {
-        if (isPageRoute) {
-            isNoShellRoute = await prerenderPaths.hasNoShell(route.filePath);
-        }
-        if (isNotFoundRoute) {
-            htmlCacheKey = getDeploymentScopedCacheKey("html:__default_not_found__");
-        }
-        else {
-            htmlCacheKey = getDeploymentScopedCacheKey(`html:${url.pathname}`);
-            fullPageCacheKey = htmlCacheKey;
-        }
-    }
-    if (htmlCacheKey && !isResumeRequest && !isErrorRoute) {
-        let cachedEntry = null;
-        if (isDynamicRoute && isPageRoute) {
-            const shellKey = getDeploymentScopedCacheKey(`html:${route.filePath}`);
-            const [pathnameEntry, shellEntry] = await Promise.all([
-                getCacheHandler().get(htmlCacheKey),
-                getCacheHandler().get(shellKey),
-            ]);
-            if (pathnameEntry?.type === CacheEntryType.HTML) {
-                cachedEntry = pathnameEntry;
-            }
-            else if (shellEntry?.type === CacheEntryType.HTML) {
-                cachedEntry = shellEntry;
-                htmlCacheKey = shellKey;
-            }
-        }
-        else {
-            const entry = await getCacheHandler().get(htmlCacheKey);
-            if (entry?.type === CacheEntryType.HTML) {
-                cachedEntry = entry;
-            }
-        }
-        if (cachedEntry) {
-            if (cachedEntry.postponed) {
-                // The cached entry has postponed state for PPR resume
-                const parsedState = parseResumeState(cachedEntry.postponed);
-                // Only ResumeMode.HTML (Suspense holes) for cached entries are expected.
-                // ResumeMode.RSC means dynamic access outside Suspense, which shouldn't
-                // be cached.
-                if (parsedState.type === ResumeMode.HTML) {
-                    htmlCacheEntry = cachedEntry;
-                    resumeState = parsedState;
-                    if (isBuildPrerender && onBuildPrerenderMeta) {
-                        onBuildPrerenderMeta({
-                            hasShell: true,
-                            postponedState: cachedEntry.postponed,
-                            cacheLife: {
-                                revalidate: cachedEntry.revalidate,
-                                expire: cachedEntry.expire,
-                            },
-                        });
-                    }
-                }
-            }
-            else {
-                // Fully static cached HTML - return it directly
-                if (isBuildPrerender && onBuildPrerenderMeta) {
-                    onBuildPrerenderMeta({
-                        hasShell: true,
-                        cacheLife: {
-                            revalidate: cachedEntry.revalidate,
-                            expire: cachedEntry.expire,
-                        },
-                    });
-                }
-                return new Response(cachedEntry.html, {
-                    status: isNotFoundRoute ? 404 : 200,
-                    headers: {
-                        "Content-Type": "text/html; charset=utf-8",
-                        "Cache-Control": getCacheControlHeader({
-                            revalidate: cachedEntry.revalidate,
-                            expire: cachedEntry.expire,
-                        }),
-                        "x-rebask-cache": "HIT",
-                        vary: "accept",
-                        ...(isNotFound() && { "x-robots-tag": "noindex" }),
-                    },
-                });
-            }
-        }
-    }
-    // Pre-warm SSR route modules before the RSC render registers inline server
-    // references. Importing the same modules in the SSR environment afterwards
-    // can invalidate plugin-rsc's dev server reference metadata.
-    if (import.meta.env.DEV && !isRscRequest) {
-        const warmupModules = new Set();
-        if (isPageRoute)
-            warmupModules.add(route.filePath);
-        for (const layout of route.layouts)
-            warmupModules.add(layout);
-        await warmupSsrModules([...warmupModules]);
-    }
-    // Server action RSC requests only return their action result or form state.
-    // Other RSC requests, including PPR resume requests, render route data.
-    const shouldRenderRscSegment = isRscRequest && !isActionRscRequest;
-    // For RSC segment requests, render only the page segment.
-    // For HTML requests (SSR), render the full tree.
-    let seedData = undefined;
-    async function createResponse(rscStream) {
-        function getResponseStatus() {
-            if (isErrorRoute || getActiveErrorBoundary() !== undefined)
-                return 500;
-            if (isNotFoundRoute || isNotFound())
-                return 404;
-            if (isRscRequest)
-                return 200;
-            if (actionError === ActionErrorCode.NotFound)
-                return 404;
-            return 200;
-        }
-        if (isRscRequest) {
-            // If the action threw an error, we consider the response a 500.
-            const rscStatus = returnValue?.ok === false ? 500 : getResponseStatus();
-            // See if the RSC can be cached, only when it's not a resume request.
-            if (!isPost &&
-                !isErrorRoute &&
-                !resumeState &&
-                !hasRequestIO() &&
-                !hasRenderError() &&
-                !isNotFound()) {
-                const [responseStream, cacheStream] = rscStream.tee();
-                cacheRscStream(url, cacheStream).catch((error) => console.error("[rebask] Failed to cache RSC:", error));
-                return createRscResponse(responseStream, {}, rscStatus);
-            }
-            return createRscResponse(rscStream, isActionRscRequest ? { "cache-control": "no-store" } : {}, rscStatus);
-        }
-        const ssrEntryModule = await getSSREntryModule();
-        function teeWithBackgroundInlineRender(combinedStream, cacheKey) {
-            const [clientStream, observerStream] = combinedStream.tee();
-            new Response(observerStream)
-                .text()
-                .then(() => {
-                if (hasRequestIO() || hasRenderError())
-                    return;
-                scheduleBackgroundInlineRender(cacheKey, async () => {
-                    await runRscRequest({
-                        input: { request, params },
-                        response: { headers: new OutgoingResponseHeaders() },
-                    }, { errorBoundary: {}, notFoundBoundary: {} }, async () => {
-                        if (!seedData) {
-                            throw new Error("Expected route seed data for background inline render.");
-                        }
-                        // Re-render RSC with the same payload
-                        const bgRscStream = renderRsc({
-                            seedData,
-                            routeTree,
-                            ...(routePrediction && { routePrediction }),
-                            ...(proxyPatterns && { proxyPatterns }),
-                        }, { temporaryReferences });
-                        const [bgRscStream1, bgRscStream2] = bgRscStream.tee();
-                        const routerCache = await ssrEntryModule.getRouterCache(bgRscStream1, routeTree);
-                        const bgResult = await ssrEntryModule.prerenderHTML(bgRscStream2, routerCache, {
-                            renderToCompletion: true, // forces React to render Suspense inline
-                        });
-                        // Pathname cache entries must be standalone full HTML documents.
-                        if (bgResult.postponed)
-                            return;
-                        const html = await new Response(bgResult.prelude).text();
-                        if (hasRequestIO() || hasRenderError())
-                            return;
-                        await cacheHtml(cacheKey, html, getCacheLife());
-                    });
-                });
-            })
-                .catch((error) => {
-                console.error("[rebask] Failed to read response html:", error);
-            });
-            return clientStream;
-        }
-        try {
-            let responseStream;
-            let isStatic = false;
-            let isPrerenderedResume = false;
-            let cacheLife;
-            if (resumeState?.type === ResumeMode.HTML) {
-                const [rscStream1, rscStream2] = rscStream.tee();
-                const cache = await ssrEntryModule.getRouterCache(rscStream1, routeTree);
-                const resumePromise = ssrEntryModule.resumeHTML(rscStream2, cache, resumeState.postponed, {
-                    routeTree,
-                });
-                // HTML resume - generate content to fill the "holes"
-                if (htmlCacheEntry) {
-                    const shellStream = new Response(htmlCacheEntry.html).body;
-                    // Internal cache HIT:
-                    // 1. Start streaming cached shell immediately
-                    // 2. Resume prepares in the background and streams after the shell
-                    const combinedStream = chainStreams(shellStream, resumePromise);
-                    if (fullPageCacheKey) {
-                        responseStream = teeWithBackgroundInlineRender(combinedStream, fullPageCacheKey);
-                    }
-                    else {
-                        responseStream = combinedStream;
-                    }
-                    isPrerenderedResume = true;
-                }
-                else {
-                    // External resume request - just send resume content
-                    responseStream = await resumePromise;
-                }
-            }
-            else if (resumeState?.type === ResumeMode.RSC) {
-                // External PPR resume (RSC only)
-                responseStream = streamRSCPayload(rscStream);
-                // We skip prerendering if we know the route has no shell, but not at
-                // build time.
-            }
-            else if (shouldPrerender && (!isNoShellRoute || isBuildPrerender)) {
-                // PPR: Prerender to capture static shell, then resume for dynamic content
-                const pprContext = RenderStorage.getStore()?.ppr;
-                const [rscStream1, rscStream2] = rscStream.tee();
-                const cache = await ssrEntryModule.getRouterCache(rscStream1, routeTree);
-                // Prerender to capture the static shell. Any suspended components
-                // (due to dynamic functions, async data) are captured as postponed state.
-                const result = ssrEntryModule.prerenderHTML(rscStream2, cache, {
-                    signal: pprContext?.controller.signal,
-                    onShell: () => {
-                        maybeAbort("prerender");
-                    },
-                    // For upgrade renders we want the cached HTML to render the resolved Suspense content
-                    // inline so a refresh shows real content immediately instead of using the fallback.
-                    renderToCompletion: isPrerenderUpgrade,
-                });
-                // Wait for React's microtask queue to drain, indicating Fizz is idle
-                // and waiting at our hanging promise. Then abort to capture the static
-                // shell.
-                waitForMicrotaskDrain().then(() => {
-                    maybeAbort("rsc");
-                });
-                const { prelude, postponed } = await result;
-                const [preludeForClient, preludeForCache] = prelude.tee();
-                const postponedState = postponed
-                    ? serializeResumeState({ type: ResumeMode.HTML, postponed })
-                    : undefined;
-                // When replaySlots === -1, it means the ROOT was postponed (dynamic access
-                // happened at the top level without any Suspense boundary). In this case,
-                // there's no static shell worth caching.
-                // See: React's getPostponedState in ReactFizzServer.js
-                const rootPostponed = postponed
-                    ? postponed.replaySlots === -1
-                    : false;
-                if (rootPostponed) {
-                    if (isPageRoute) {
-                        prerenderPaths.registerNoShell(route.filePath);
-                    }
-                    if (import.meta.env.DEV) {
-                        const devWarningMessage = noPrerenderWarning(url.pathname);
-                        console.warn(devWarningMessage);
-                        sendDevWarning(devWarningMessage);
-                    }
-                }
-                // notFound() can be thrown inside a <Suspense> boundary, where it's captured as postponed
-                // content, so the prerender still produced a shell. When that happens, activate the next
-                // boundary and retry.
-                if (notFoundWasThrown()) {
-                    const nextNotFoundIndex = getNearestNotFoundBoundaryIndex();
-                    if (nextNotFoundIndex !== undefined) {
-                        prelude.cancel().catch(console.error);
-                        throw new RetryWithNotFoundBoundaryError(nextNotFoundIndex);
-                    }
-                }
-                if (postponed) {
-                    // A valid shell exists if the root wasn't postponed
-                    if (isBuildPrerender) {
-                        // Build-time prerendering only needs the shell. Skip resume.
-                        responseStream = preludeForClient;
-                    }
-                    else {
-                        // PPR: There's postponed content (Suspense or async component suspended)
-                        if (!seedData) {
-                            throw new Error("Expected route seed data for PPR resume response.");
-                        }
-                        // Resume runs in a fresh RenderStorage context (preserving activated boundary indices)
-                        // so stale registry state from the prerender doesn't leak into the resume.
-                        const currentRenderContext = RenderStorage.getStore();
-                        const [resumeRscStream1, resumeRscStream2] = RenderStorage.run({
-                            errorBoundary: { activeIndex: currentRenderContext.errorBoundary.activeIndex },
-                            notFoundBoundary: {
-                                activeIndex: currentRenderContext.notFoundBoundary.activeIndex,
-                            },
-                            ppr: { controller: new AbortController(), abortOnDynamic: false, paramsResolved },
-                        }, () => renderRsc({
-                            seedData,
-                            routeTree,
-                            ...(routePrediction && { routePrediction }),
-                            ...(proxyPatterns && { proxyPatterns }),
-                        }, { temporaryReferences }, onNotFound).tee());
-                        const cache = await ssrEntryModule.getRouterCache(resumeRscStream1, routeTree);
-                        const resumeStream = await ssrEntryModule.resumeHTML(resumeRscStream2, cache, postponed, { routeTree });
-                        if (rootPostponed) {
-                            // Root was postponed - prelude is nothing (just closing tags).
-                            // Use resume stream directly which contains complete HTML.
-                            // Cancel the broken prelude to avoid resource leaks.
-                            preludeForClient.cancel().catch(console.error);
-                            preludeForCache.cancel().catch(console.error);
-                            responseStream = resumeStream;
-                        }
-                        else {
-                            // Concatenate: static shell + dynamic content
-                            const combinedStream = chainStreams(preludeForClient, resumeStream);
-                            if (fullPageCacheKey) {
-                                responseStream = teeWithBackgroundInlineRender(combinedStream, fullPageCacheKey);
-                            }
-                            else {
-                                responseStream = combinedStream;
-                            }
-                        }
-                    }
-                }
-                else {
-                    // Fully static - no dynamic content
-                    isStatic = true;
-                    responseStream = preludeForClient;
-                }
-                if (isBuildPrerender && rootPostponed && isNotFoundRoute) {
-                    // Not-found pages must be prerenderable at build time
-                    throw new Error(noPrerenderNotFoundError("(default)"));
-                }
-                // Capture aggregated cache life values from async context for static
-                // content. This is done after prerendering completes when all
-                // cacheLife() calls have been processed.
-                if (isStatic)
-                    cacheLife = getCacheLife();
-                // A servable static shell does not exit when:
-                //  - `rootPostponed`: dynamic data was accessed at the root with no <Suspense> to
-                //    absorb it, so React produced no prelude.
-                //  - `isNotFound()`: the render resolved to notFound(), which is never a servable shell.
-                //		The router's catch-all route for unmatched URLs is the exception — a 404 is its
-                //		shell. This is what forces pages put `notFound()` behind dynamic IO inside <Suspense>.
-                const hasServableShell = !rootPostponed && (isNotFoundRoute || !isNotFound());
-                if (htmlCacheKey && hasServableShell && !getBoundaryError()) {
-                    // If the page has postponed content, we cache the static shell so future requests can
-                    // resume from it.
-                    const isSharedShell = !!postponedState && !paramsResolved && (isPageRoute || isNotFoundRoute);
-                    // If the page is fully static (no postponed content), `preludeForCache` is the
-                    // complete HTML and gets cached with no postponed state.
-                    if (!postponedState || isSharedShell) {
-                        const cacheKey = isSharedShell
-                            ? isPageRoute
-                                ? getDeploymentScopedCacheKey(`html:${route.filePath}`)
-                                : htmlCacheKey
-                            : htmlCacheKey;
-                        const cacheWrite = new Response(preludeForCache)
-                            .text()
-                            .then((html) => cacheHtml(cacheKey, html, cacheLife, postponedState));
-                        // Await the write only during the build, just so that `handlePageRoute` finishes
-                        // when the cache has been written.
-                        if (isBuildPrerender)
-                            await cacheWrite;
-                    }
-                    else {
-                        preludeForCache.cancel().catch(console.error);
-                    }
-                }
-                if (isBuildPrerender && onBuildPrerenderMeta) {
-                    onBuildPrerenderMeta({
-                        hasShell: hasServableShell,
-                        postponedState,
-                        ...(rootPostponed && {
-                            cacheLife: {
-                                revalidate: cacheLife?.revalidate ?? STATIC,
-                                expire: cacheLife?.expire ?? cacheLife?.revalidate ?? STATIC,
-                            },
-                        }),
-                    });
-                }
-            }
-            else {
-                // Non-prerendering path: dynamic content, streaming
-                const [rscStream1, rscStream2] = rscStream.tee();
-                const cache = await ssrEntryModule.getRouterCache(rscStream1, routeTree);
-                if (isBotRequest) {
-                    const result = await ssrEntryModule.prerenderHTML(rscStream2, cache, {
-                        renderToCompletion: true,
-                    });
-                    responseStream = result.prelude;
-                }
-                else {
-                    responseStream = await ssrEntryModule.renderHTML(rscStream2, cache, {
-                        formState,
-                        routeTree,
-                    });
-                }
-            }
-            // Build Cache-Control header:
-            // - Static content: use aggregated cacheLife values (safe to cache at CDN)
-            // - Dynamic/streaming content (including prerendered resume): no caching
-            //   because the dynamic parts change per-request
-            const cacheControl = isStatic
-                ? getCacheControlHeader({
-                    revalidate: cacheLife?.revalidate ?? STATIC,
-                    expire: cacheLife?.expire,
-                })
-                : getCacheControlHeader({ revalidate: 0 });
-            const response = new Response(responseStream, {
-                status: getResponseStatus(),
-                headers: mergeResponseHeaders({
-                    "Content-Type": "text/html; charset=utf-8",
-                    vary: "accept",
-                    "Cache-Control": cacheControl,
-                    ...(isNotFoundRoute && { "x-robots-tag": "noindex" }),
-                    "x-rebask-cache": isErrorRoute ? "MISS" : isPrerenderedResume ? "HIT" : "MISS",
-                    ...(isPrerenderedResume && { [REBASK_PRERENDER_HEADER]: "1" }),
-                    ...(getDeploymentId() ? { [REBASK_DEPLOYMENT_ID_HEADER]: getDeploymentId() } : {}),
-                }),
-            });
-            return response;
-        }
-        catch (error) {
-            markRenderError();
-            // We want to throw during prerendering, instead of rendering an error page.
-            if (isBuildPrerender && !isNotFound()) {
-                throw error;
-            }
-            // Handle 404 if called before a Suspense boundary.
-            if (isNotFound()) {
-                // Render the nearest `NotFoundBoundary` only if the current render has called `notFound()`
-                if (notFoundWasThrown()) {
-                    // `isNotFound()` is the sticky 404 status (persists across retries).
-                    // `notFoundWasThrown()` is the per-render state.
-                    const nextNotFoundIndex = getNearestNotFoundBoundaryIndex();
-                    if (nextNotFoundIndex !== undefined) {
-                        throw new RetryWithNotFoundBoundaryError(nextNotFoundIndex);
-                    }
-                }
-                // Fall back to the built-in default 404
-                return handlePageRoute(request, { type: "not-found", segments: [], layouts: [], errorPath: route.errorPath }, params, handleOptions);
-            }
-            const nextBoundaryIndex = getNearestErrorBoundaryIndex();
-            if (!isErrorRoute && nextBoundaryIndex !== undefined) {
-                throw new RetryWithBoundaryError(nextBoundaryIndex, error);
-            }
-            const rootErrorPath = route.errorPath;
-            // Once a framework error route itself fails, fall back to the built-in default.
-            if (isErrorRoute) {
-                return handlePageRoute(request, buildDefaultErrorRoute(), params, handleOptions);
-            }
-            if (rootErrorPath && errorModules[rootErrorPath]) {
-                const rootErrorRoute = buildErrorRoute(rootErrorPath);
-                return handlePageRoute(request, rootErrorRoute, params, handleOptions);
-            }
-            return handlePageRoute(request, buildDefaultErrorRoute(), params, handleOptions);
-        }
-    }
-    // We're in PPR mode if we should prerender, this is not a resume request, we don't have a
-    // cached HTML entry already, and the route hasn't been flagged as having no shell
-    // (except at build time).
-    const isPpr = shouldPrerender && !isResumeRequest && !htmlCacheEntry && (!isNoShellRoute || isBuildPrerender);
-    // In upgrade mode, we still want the PPR render path (so cacheLife/postponed handling stays
-    // consistent) but we must NOT abort on dynamic access, as the goal is a fully-resolved render.
-    const shouldAbortOnDynamic = isPpr && !isPrerenderUpgrade;
-    let attempt = {};
-    let response;
-    while (true) {
-        const abortOnDynamic = shouldAbortOnDynamic && attempt.activeErrorIndex === undefined;
-        const renderContext = {
-            errorBoundary: {
-                isErrorPage: isErrorRoute,
-                activeIndex: attempt.activeErrorIndex,
-            },
-            notFoundBoundary: {
-                activeIndex: attempt.activeNotFoundIndex,
-                pathnameMode: route.type === "not-found" ? "client" : "request",
-            },
-            ...(isPpr && {
-                ppr: { controller: new AbortController(), abortOnDynamic, paramsResolved },
-            }),
-        };
-        try {
-            response = await runRscRequest({
-                input: { request, params: match.params, isStaticGeneration: isStaticGen },
-                response: { headers: new OutgoingResponseHeaders() },
-            }, renderContext, async () => {
-                if (attempt.boundaryError)
-                    setBoundaryError(attempt.boundaryError);
-                if (attempt.notFound)
-                    markNotFound();
-                if (!isBuildPrerender &&
-                    isDynamicRoute &&
-                    isPageRoute &&
-                    (await prerenderPaths.isStaticPathMiss(route.filePath, url.pathname))) {
-                    markNotFoundThrown();
-                }
-                // No-JS native forms cannot consume RSC streams, so they recurse to render the full HTML
-                // page. We bridge the action's 404 state here to ensure the subsequent page render knows to
-                // activate the not-found boundaries.
-                if (actionError === ActionErrorCode.NotFound && !isRscRequest) {
-                    markNotFound();
-                }
-                // Build seedData inside the request scope so renderPage can read isNotFound().
-                // For non-PPR routes this only needs to run once, but rebuilding is cheap because
-                // module loaders are cached.
-                seedData = shouldRenderRscSegment
-                    ? await renderPageSegment(match, attempt.boundaryError)
-                    : isRscRequest
-                        ? undefined
-                        : await renderRouteSegments(match, routeTree, 
-                        // Native no-JS form submissions execute the action before the main render starts.
-                        // Re-inject unexpected action errors to activate the nearest error boundary
-                        !attempt.boundaryError ? actionThrownError : undefined);
-                const boundaryError = getBoundaryError();
-                let payload;
-                if (isActionRscRequest) {
-                    if (returnValue !== undefined) {
-                        payload = { returnValue };
-                    }
-                    else if (formState !== undefined) {
-                        payload = { formState };
-                    }
-                    else if (actionError !== undefined) {
-                        payload = { actionError };
-                    }
-                    else {
-                        throw new Error("Expected an action result, form state, or action error for action RSC response.");
-                    }
-                }
-                else {
-                    if (!seedData) {
-                        throw new Error("Expected route seed data for route RSC response.");
-                    }
-                    payload = {
-                        seedData,
-                        routeTree,
-                        ...(routePrediction && { routePrediction }),
-                        ...(proxyPatterns && { proxyPatterns }),
-                        ...(formState !== undefined && { formState }),
-                        ...(boundaryError && { error: boundaryError }),
-                    };
-                }
-                const stream = isActionRscRequest
-                    ? renderRsc(payload, { temporaryReferences })
-                    : renderRsc(payload, { temporaryReferences }, onNotFound);
-                return await createResponse(stream);
-            });
-            break;
-        }
-        catch (error) {
-            if (error instanceof RetryWithBoundaryError) {
-                attempt.activeErrorIndex = error.boundaryIndex;
-                attempt.boundaryError = error.originalError;
-                continue;
-            }
-            if (error instanceof RetryWithNotFoundBoundaryError) {
-                attempt.activeNotFoundIndex = error.boundaryIndex;
-                attempt.notFound = true;
-                continue;
-            }
-            throw error;
-        }
-    }
-    return applyActionResponseHeaders(response, postBody.responseHeaders);
-}
-const closingTagsBytes = new TextEncoder().encode("</body></html>");
-/**
- * Stream RSC payload for ResumeMode.RSC.
- *
- * The HTML shell is complete (served from cache), we just need to send fresh
- * RSC data for React to reconcile on the client.
- */
-function streamRSCPayload(rscStream) {
-    // Create a minimal stream with just closing tags
-    // injectRSCPayload will insert RSC script tags before them
-    const closingStream = new ReadableStream({
-        start(controller) {
-            controller.enqueue(closingTagsBytes);
-            controller.close();
-        },
-    });
-    // Inject RSC payload as script tags before closing tags
-    return closingStream.pipeThrough(injectRSCPayload(rscStream));
-}