@rebask/core 0.2.1 → 0.4.0

package/dist/handlers/rsc/create-response.js

@@ -1,378 +0,0 @@
-import { injectRSCPayload } from "rsc-html-stream/server";
-import { proxyPatterns } from "virtual:rebask/proxy-router";
-import { errorModules } from "../../lib/app-manifest.js";
-import { scheduleBackgroundRevalidation } from "../../lib/background-revalidation.js";
-import {} from "../../lib/cache-context.js";
-import { getDeploymentId, getDeploymentScopedCacheKey, REBASK_DEPLOYMENT_ID_HEADER, } from "../../lib/deployment-id.js";
-import { sendDevWarning } from "../../lib/dev-server.js";
-import { noPrerenderNotFoundError, noPrerenderWarning } from "../../lib/messages.js";
-import { getCacheControlHeader, REBASK_PRERENDER_HEADER } from "../../lib/ppr/headers.js";
-import { 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 { cacheRscStream, createRscResponse, renderRsc } from "../../lib/rsc-request.js";
-import { waitForMicrotaskDrain } from "../../lib/scheduler-patch.js";
-import { encodeShellParams } from "../../lib/shell-params.js";
-import { chainStreams } from "../../lib/stream-utils.js";
-import { ActionErrorCode } from "../../lib/types.js";
-import { getBoundaryError, getCacheLife, hasRenderError, hasRequestIO, isNotFound, markRenderError, mergeResponseHeaders, notFoundWasThrown, } from "../../request-context.js";
-import { renderFullPageInBackground, renderPartialShellInBackground, withBackgroundHtmlWrite, } from "./background-render.js";
-import { cacheHtml } from "./cache-html.js";
-import { STATIC } from "./constants.js";
-import { buildDefaultErrorRoute, buildErrorRoute, FallbackRouteError, onNotFound, RetryWithBoundaryError, RetryWithNotFoundBoundaryError, } from "./errors.js";
-import { getSSREntryModule } from "./ssr-entry.js";
-import { CacheLookupKind } from "./types.js";
-function getResponseStatus(state) {
-    // If the action threw an error, we consider the response a 500.
-    if (state.postBody.returnValue?.ok === false)
-        return 500;
-    if (state.isErrorRoute || getActiveErrorBoundary() !== undefined)
-        return 500;
-    if (state.isNotFoundRoute || isNotFound())
-        return 404;
-    if (state.isRscRequest)
-        return 200;
-    if (state.postBody.actionError === ActionErrorCode.NotFound)
-        return 404;
-    return 200;
-}
-const closingTagsBytes = new TextEncoder().encode("</body></html>");
-/** Stream RSC payload for ResumeMode.RSC. */
-function streamRSCPayload(rscStream) {
-    const closingStream = new ReadableStream({
-        start(controller) {
-            controller.enqueue(closingTagsBytes);
-            controller.close();
-        },
-    });
-    // The transform reads the closing tags, waits for RSC data, and emits the RSC payload as script
-    // tags followed by the closing tags.
-    return closingStream.pipeThrough(injectRSCPayload(rscStream));
-}
-export async function renderToResponse(state, cacheContext, rscStream) {
-    if (state.isRscRequest) {
-        const rscStatus = getResponseStatus(state);
-        const isCacheableRsc = !state.isPost && !state.isErrorRoute && !state.resumeState;
-        const isCleanRender = !hasRequestIO() && !hasRenderError() && !isNotFound();
-        // See if the RSC can be cached
-        if (isCacheableRsc && isCleanRender) {
-            const [responseStream, cacheStream] = rscStream.tee();
-            cacheRscStream(state.url, cacheStream).catch((error) => console.error("[rebask] Failed to cache RSC:", error));
-            return createRscResponse(responseStream, {}, rscStatus);
-        }
-        return createRscResponse(rscStream, {}, rscStatus);
-    }
-    const ssrEntryModule = await getSSREntryModule();
-    state.ssrEntryModule = ssrEntryModule;
-    try {
-        let renderResult;
-        const { resumeState } = state;
-        if (resumeState?.type === ResumeMode.HTML) {
-            const [rscStream1, rscStream2] = rscStream.tee();
-            const cache = await ssrEntryModule.getRouterCache(rscStream1, state.routeTree);
-            const resumePromise = ssrEntryModule.resumeHTML(rscStream2, cache, resumeState.postponed, {
-                routeTree: state.routeTree,
-            });
-            // HTML resume from a cached PPR shell — stream the cached shell immediately,
-            // then resume prepares in the background and streams after the shell.
-            if (cacheContext.kind === CacheLookupKind.PprHit) {
-                const shellStream = new Response(cacheContext.entry.html).body;
-                const combinedStream = chainStreams(shellStream, resumePromise);
-                const responseStream = withBackgroundHtmlWrite(state, combinedStream, state.fullPageCacheKey, cacheContext.promotionResolvedParams);
-                renderResult = { responseStream, isPrerenderedResume: true };
-            }
-            else {
-                // External resume request - just send resume content
-                renderResult = { responseStream: await resumePromise };
-            }
-        }
-        else if (state.resumeState?.type === ResumeMode.RSC) {
-            // External PPR resume (RSC only).
-            //
-            // The client already has the full cached HTML document rendered, and is requesting fresh RSC
-            // data to reconcile the dynamic parts that were deferred. Unlike other resume modes, we
-            // bypass React's HTML renderer entirely because the shell is already on the client.
-            //
-            // The response is still `text/html`, so the browser needs a valid HTML document to parse.
-            // We create one with just the closing tags and the RSC script tags before them.
-            // The client's HTML parser extracts those scripts and React reconciles on the client.
-            renderResult = { responseStream: streamRSCPayload(rscStream) };
-        }
-        else if (state.shouldPrerender && (!state.isNoShellRoute || state.isBuildPrerender)) {
-            // We skip prerendering if we know the route has no shell, but not at build time.
-            renderResult = await prerenderBranch(state, rscStream);
-        }
-        else {
-            // Non-prerendering path: dynamic content, streaming
-            const [rscStream1, rscStream2] = rscStream.tee();
-            const cache = await ssrEntryModule.getRouterCache(rscStream1, state.routeTree);
-            let responseStream;
-            if (state.isBotRequest) {
-                const result = await ssrEntryModule.prerenderHTML(rscStream2, cache, {
-                    renderToCompletion: true,
-                });
-                responseStream = result.prelude;
-            }
-            else {
-                responseStream = await ssrEntryModule.renderHTML(rscStream2, cache, {
-                    formState: state.postBody.formState,
-                    routeTree: state.routeTree,
-                });
-            }
-            renderResult = { responseStream, isStatic: false, isPrerenderedResume: false };
-        }
-        const { responseStream, isStatic, isPrerenderedResume, cacheLife } = renderResult;
-        // 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(state),
-            headers: mergeResponseHeaders({
-                "Content-Type": "text/html; charset=utf-8",
-                vary: "accept",
-                "Cache-Control": cacheControl,
-                ...(state.isNotFoundRoute && { "x-robots-tag": "noindex" }),
-                "x-rebask-cache": state.isErrorRoute ? "MISS" : isPrerenderedResume ? "HIT" : "MISS",
-                ...(isPrerenderedResume && { [REBASK_PRERENDER_HEADER]: "1" }),
-                ...(getDeploymentId() ? { [REBASK_DEPLOYMENT_ID_HEADER]: getDeploymentId() } : {}),
-            }),
-        });
-        // Schedule background revalidations for stale or missing entries.
-        if (!state.isBuildPrerender &&
-            (cacheContext.kind === CacheLookupKind.PprHit || cacheContext.kind === CacheLookupKind.Miss)) {
-            for (const { key, resolvedParams } of cacheContext.revalidations) {
-                if (resolvedParams) {
-                    scheduleBackgroundRevalidation(key, () => renderPartialShellInBackground(state, key, resolvedParams));
-                }
-                else {
-                    scheduleBackgroundRevalidation(key, () => renderFullPageInBackground(state, key));
-                }
-            }
-        }
-        return response;
-    }
-    catch (error) {
-        markRenderError();
-        // We want to throw during prerendering, instead of rendering an error page.
-        if (state.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
-            throw new FallbackRouteError({
-                type: "not-found",
-                segments: [],
-                layouts: [],
-                errorPath: state.route.errorPath,
-            });
-        }
-        const nextBoundaryIndex = getNearestErrorBoundaryIndex();
-        if (!state.isErrorRoute && nextBoundaryIndex !== undefined) {
-            throw new RetryWithBoundaryError(nextBoundaryIndex, error);
-        }
-        const rootErrorPath = state.route.errorPath;
-        // Once a framework error route itself fails, fall back to the built-in default.
-        if (state.isErrorRoute) {
-            throw new FallbackRouteError(buildDefaultErrorRoute());
-        }
-        if (rootErrorPath && errorModules[rootErrorPath]) {
-            throw new FallbackRouteError(buildErrorRoute(rootErrorPath));
-        }
-        throw new FallbackRouteError(buildDefaultErrorRoute());
-    }
-    finally {
-        state.resolveShellInFlight?.();
-    }
-}
-async function prerenderBranch(state, rscStream) {
-    const { temporaryReferences } = state.postBody;
-    const ssrEntryModule = state.ssrEntryModule;
-    // 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, state.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: state.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 (state.isPageRoute) {
-            prerenderPaths.registerNoShell(state.route.filePath);
-        }
-        if (import.meta.env.DEV) {
-            const devWarningMessage = noPrerenderWarning(state.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);
-        }
-    }
-    let responseStream;
-    let isStatic = false;
-    if (postponed) {
-        // A valid shell exists if the root wasn't postponed
-        if (state.isBuildPrerender) {
-            // Build-time prerendering only needs the shell. Skip resume.
-            responseStream = preludeForClient;
-        }
-        else {
-            // PPR: There's postponed content (Suspense or async component suspended)
-            if (!state.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,
-                    resolvedParams: state.resolvedParams,
-                },
-            }, () => renderRsc({
-                seedData: state.seedData,
-                routeTree: state.routeTree,
-                ...(state.routePrediction && { routePrediction: state.routePrediction }),
-                ...(proxyPatterns && { proxyPatterns }),
-            }, { temporaryReferences }, onNotFound).tee());
-            const resumeCache = await ssrEntryModule.getRouterCache(resumeRscStream1, state.routeTree);
-            const resumeStream = await ssrEntryModule.resumeHTML(resumeRscStream2, resumeCache, postponed, { routeTree: state.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 (state.fullPageCacheKey && state.resolvedParams.size === 0 && state.isPageRoute) {
-                    responseStream = withBackgroundHtmlWrite(state, combinedStream, state.fullPageCacheKey, state.fullParamsSet);
-                }
-                else {
-                    responseStream = combinedStream;
-                }
-            }
-        }
-    }
-    else {
-        // Fully static - no dynamic content
-        isStatic = true;
-        responseStream = preludeForClient;
-    }
-    if (state.isBuildPrerender && rootPostponed && state.isNotFoundRoute) {
-        // Not-found pages must be prerenderable at build time
-        throw new Error(noPrerenderNotFoundError("(default)"));
-    }
-    // Capture aggregated cache life values from async context.
-    // This is done after prerendering completes when all cacheLife() calls
-    // have been processed. Applies to both fully static pages and postponed
-    // shells (shared + intermediate) so that tags/revalidate/expire are
-    // preserved on the cache entry.
-    const 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 why pages must put `notFound()` behind dynamic IO inside <Suspense>.
-    const hasServableShell = !rootPostponed && (state.isNotFoundRoute || !isNotFound());
-    if (state.htmlCacheKey && hasServableShell && !getBoundaryError()) {
-        // Cache the static shell so future requests can resume from it.
-        // For fully static pages (no postponed content), `preludeForCache` is the
-        // complete HTML and gets cached with no postponed state.
-        const isSharedShell = !!postponedState &&
-            state.resolvedParams.size === 0 &&
-            (state.isPageRoute || state.isNotFoundRoute);
-        const isIntermediateShell = state.isPageRoute && !!postponedState && state.hasIntermediateShellParams;
-        let cacheKey = state.htmlCacheKey;
-        if (isIntermediateShell && state.isPageRoute) {
-            cacheKey = getDeploymentScopedCacheKey(`html:${state.route.filePath}:${encodeShellParams(state.route, state.shellParams, state.params)}`);
-        }
-        else if (isSharedShell && state.isPageRoute) {
-            cacheKey = getDeploymentScopedCacheKey(`html:${state.route.filePath}`);
-        }
-        const cacheWrite = new Response(preludeForCache)
-            .text()
-            .then((html) => cacheHtml(cacheKey, html, cacheLife, postponedState));
-        const resolve = state.resolveShellInFlight;
-        if (resolve) {
-            state.resolveShellInFlight = null;
-            cacheWrite.finally(() => resolve());
-        }
-        // Await the write only during the build, just so that `handlePageRoute` finishes
-        // when the cache has been written.
-        if (state.isBuildPrerender)
-            await cacheWrite;
-    }
-    if (state.isBuildPrerender && state.handleOptions?.onBuildPrerenderMeta) {
-        state.handleOptions.onBuildPrerenderMeta({
-            hasShell: hasServableShell,
-            postponedState,
-            ...(cacheLife && {
-                cacheLife: {
-                    revalidate: cacheLife.revalidate ?? STATIC,
-                    expire: cacheLife.expire ?? cacheLife.revalidate ?? STATIC,
-                },
-            }),
-        });
-    }
-    return { responseStream, isStatic, isPrerenderedResume: false, cacheLife };
-}

package/dist/handlers/rsc/render-with-retries.d.ts

@@ -1,4 +0,0 @@
-import { type CacheLookupOutcome } from "./cache-lookup.js";
-import type { RenderRequestState } from "./state.js";
-export declare function renderWithRetries(state: RenderRequestState, cacheContext: CacheLookupOutcome): Promise<Response>;
-//# sourceMappingURL=render-with-retries.d.ts.map

package/dist/handlers/rsc/render-with-retries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"render-with-retries.d.ts","sourceRoot":"","sources":["../../../src/handlers/rsc/render-with-retries.ts"],"names":[],"mappings":"AAeA,OAAO,EAAmB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAS5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AASpD,wBAAsB,iBAAiB,CACtC,KAAK,EAAE,kBAAkB,EACzB,YAAY,EAAE,kBAAkB,GAC9B,OAAO,CAAC,QAAQ,CAAC,CAkKnB"}

package/dist/handlers/rsc/render-with-retries.js

@@ -1,154 +0,0 @@
-import { proxyPatterns } from "virtual:rebask/proxy-router";
-import { ResumeMode } from "../../lib/ppr/types.js";
-import { prerenderPaths } from "../../lib/prerender-paths.js";
-import {} from "../../lib/render-context.js";
-import { renderPageSegment, renderRouteSegments } from "../../lib/route-renderer.js";
-import { discardRscCacheWrite, renderRsc, runRscRequest } from "../../lib/rsc-request.js";
-import { ActionErrorCode } from "../../lib/types.js";
-import { getBoundaryError, markNotFound, markNotFoundThrown, OutgoingResponseHeaders, setBoundaryError, } from "../../request-context.js";
-import { CacheLookupKind } from "./cache-lookup.js";
-import { FallbackRouteError, onNotFound, RetryWithBoundaryError, RetryWithNotFoundBoundaryError, } from "./errors.js";
-import { handlePageRoute } from "./index.js";
-import { renderToResponse } from "./render-to-response.js";
-export async function renderWithRetries(state, cacheContext) {
-    const { returnValue, formState, temporaryReferences, actionError, actionThrownError } = state.postBody;
-    const match = { route: state.route, params: state.params };
-    const shouldRenderRscSegment = state.isRscRequest && !state.isActionRscRequest;
-    // 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 = state.shouldPrerender &&
-        !state.isResumeRequest &&
-        cacheContext.kind !== CacheLookupKind.PprHit &&
-        (!state.isNoShellRoute || state.isBuildPrerender);
-    // Resuming a cached shell serves HTML that was rendered earlier, so this render must not
-    // regenerate the cached data that HTML already contains.
-    const isGeneratingCacheEntry = state.isStaticGen && cacheContext.kind !== CacheLookupKind.PprHit;
-    let attempt = {};
-    let response;
-    while (true) {
-        const abortOnDynamic = isPpr && attempt.activeErrorIndex === undefined;
-        const renderContext = {
-            errorBoundary: {
-                activeIndex: attempt.activeErrorIndex,
-            },
-            notFoundBoundary: {
-                activeIndex: attempt.activeNotFoundIndex,
-            },
-            ...(isPpr && {
-                ppr: {
-                    controller: new AbortController(),
-                    abortOnDynamic,
-                    // This render fills a cache rather than streaming to a user, so it waits for a hanging
-                    // dynamic read instead of aborting as soon as the shell is ready.
-                    isCachePrerender: state.isBuildPrerender || state.isPrerenderUpgrade,
-                    resolvedParams: state.resolvedParams,
-                    paramNames: state.fullParamsSet,
-                    pendingShellWork: new Set(),
-                    usedUnresolvedParams: new Set(),
-                },
-            }),
-        };
-        try {
-            response = await runRscRequest({
-                input: {
-                    request: state.request,
-                    params: match.params,
-                    isStaticGeneration: isGeneratingCacheEntry,
-                    resumeData: state.resumeState?.type === ResumeMode.HTML
-                        ? state.resumeState.resumeData
-                        : undefined,
-                },
-                response: { headers: new OutgoingResponseHeaders() },
-            }, renderContext, async () => {
-                if (attempt.boundaryError)
-                    setBoundaryError(attempt.boundaryError);
-                if (attempt.notFound)
-                    markNotFound();
-                if (!state.isBuildPrerender &&
-                    state.isDynamicRoute &&
-                    state.isPageRoute &&
-                    (await prerenderPaths.isStaticPathMiss(state.route.filePath, state.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 && !state.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.
-                state.seedData = shouldRenderRscSegment
-                    ? await renderPageSegment(match, attempt.boundaryError)
-                    : state.isRscRequest
-                        ? undefined
-                        : await renderRouteSegments(match, state.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 (state.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 (!state.seedData) {
-                        throw new Error("Expected route seed data for route RSC response.");
-                    }
-                    payload = {
-                        seedData: state.seedData,
-                        routeTree: state.routeTree,
-                        ...(state.routePrediction && { routePrediction: state.routePrediction }),
-                        ...(proxyPatterns && { proxyPatterns }),
-                        ...(formState !== undefined && { formState }),
-                        ...(boundaryError && { error: boundaryError }),
-                    };
-                }
-                const pprSignal = renderContext.ppr?.controller.signal;
-                // Renders that only fill a cache skip the resume phase, so pass them the PPR abort
-                // signal to stop the RSC stream hanging on data that will never arrive. A render that
-                // serves a user must not get it, because its RSC stream feeds the resume.
-                const rscOptions = state.isBuildPrerender || state.isPrerenderUpgrade
-                    ? { temporaryReferences, ...(pprSignal && { signal: pprSignal }) }
-                    : { temporaryReferences };
-                const stream = state.isActionRscRequest
-                    ? renderRsc(payload, rscOptions)
-                    : renderRsc(payload, rscOptions, onNotFound);
-                return await renderToResponse(state, cacheContext, 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;
-            }
-            if (state.rscCacheWrite)
-                discardRscCacheWrite(state.rscCacheWrite);
-            if (error instanceof FallbackRouteError) {
-                return handlePageRoute(state.request, error.fallbackRoute, state.params, state.handleOptions);
-            }
-            throw error;
-        }
-    }
-    return response;
-}

package/dist/handlers/rsc/retry-loop.d.ts

@@ -1,3 +0,0 @@
-import type { CacheLookupOutcome, RenderRequestState } from "./types.js";
-export declare function renderWithRetries(state: RenderRequestState, cacheContext: CacheLookupOutcome): Promise<Response>;
-//# sourceMappingURL=retry-loop.d.ts.map

package/dist/handlers/rsc/retry-loop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry-loop.d.ts","sourceRoot":"","sources":["../../../src/handlers/rsc/retry-loop.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAgB,MAAM,YAAY,CAAA;AAEtF,wBAAsB,iBAAiB,CACtC,KAAK,EAAE,kBAAkB,EACzB,YAAY,EAAE,kBAAkB,GAC9B,OAAO,CAAC,QAAQ,CAAC,CAyJnB"}