vinext 0.1.2 → 0.1.4

package/dist/server/app-page-dispatch.js

@@ -1,29 +1,31 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
+import { beginPprFallbackShellFinalRender, createPprFallbackShellState, getPprFallbackShellState, runWithPprFallbackShellState } from "../shims/ppr-fallback-shell.js";
+import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife, _peekRequestScopedCacheLife } from "../shims/cache.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import "./app-elements.js";
-import { consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
-import { readStreamAsText } from "../utils/text-stream.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
-import { buildAppPageSpecialErrorResponse, resolveAppPageSpecialError, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
+import { buildAppPageSpecialErrorResponse, probeAppPageThrownError, resolveAppPageSpecialError } from "./app-page-execution.js";
 import { createAppPageTreePath } from "./app-page-route-wiring.js";
-import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
-import { readAppPageCacheResponse } from "./app-page-cache.js";
+import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
+import { rewriteAppPprFallbackShellHtmlNavigation } from "./app-ppr-fallback-shell.js";
+import { readAppPageCacheResponse, readAppPageFallbackShellCacheResponse } from "./app-page-cache.js";
 import { resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule } from "./app-page-boundary.js";
-import { isAppSsrRenderResult } from "./app-page-stream.js";
 import { createAppLayoutParamAccessTracker, isAppLayoutObservationUnsafeForStaticReuse } from "./app-layout-param-observation.js";
+import { buildAppPageTags } from "./implicit-tags.js";
+import { renderAppPageCacheArtifacts } from "./app-page-cache-render.js";
+import { warmPprFallbackShellCaches } from "./app-ppr-fallback-shell-render.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
 import { renderAppPageLifecycle } from "./app-page-render.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import React from "react";
 //#region src/server/app-page-dispatch.ts
 function resolveAppPageRouteBoundaryModule(route, statusCode) {
@@ -107,9 +109,6 @@ function shouldReadAppPageCache(options) {
 function hasSearchParams(searchParams) {
 	return searchParams !== null && searchParams !== void 0 && searchParams.size > 0;
 }
-function buildAppPageTags(cleanPathname, extraTags, routeSegments) {
-	return buildPageCacheTags(cleanPathname, extraTags, [...routeSegments], "page");
-}
 async function runAppPageRevalidationContext(options, renderFn) {
 	return runWithRequestContext(createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
@@ -119,6 +118,7 @@ async function runAppPageRevalidationContext(options, renderFn) {
 			routePattern: options.routePattern
 		}),
 		currentFetchCacheMode: options.currentFetchCacheMode ?? null,
+		currentForceDynamicFetchDefault: options.dynamicConfig === "force-dynamic",
 		executionContext: getRequestExecutionContext(),
 		unstableCacheRevalidation: "foreground"
 	}), async () => {
@@ -132,10 +132,6 @@ async function runAppPageRevalidationContext(options, renderFn) {
 		return await runWithFetchDedupe(renderFn);
 	});
 }
-function getCapturedRscDataPromise(capturedRscDataPromise) {
-	if (!capturedRscDataPromise) throw new Error("[vinext] Expected captured RSC data while regenerating an app page cache entry");
-	return capturedRscDataPromise;
-}
 function toInterceptOptions(interceptionContext, intercept) {
 	return {
 		interceptionContext,
@@ -144,11 +140,77 @@ function toInterceptOptions(interceptionContext, intercept) {
 		interceptParams: intercept.matchedParams,
 		interceptSlotId: intercept.slotId ?? null,
 		interceptSlotKey: intercept.slotKey,
-		interceptSourceMatchedUrl: interceptionContext
+		interceptSourceMatchedUrl: interceptionContext,
+		interceptSourcePageSegments: intercept.sourcePageSegments ?? null
+	};
+}
+/**
+* Request-phase fallback-shell gate. Callers must run the exact cache read and
+* static-param validation before this classification step.
+*/
+function classifyPprFallbackShellEligibility(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) {
+	if (options.renderedConcreteUrlPaths?.has(options.cleanPathname) === true) return { kind: "skip-known-pregenerated-route" };
+	const fallbackShells = options.pprFallbackCacheShells;
+	if (!fallbackShells || fallbackShells.length === 0) return { kind: "skip-no-fallback-shells" };
+	if (options.isRscRequest) return { kind: "skip-rsc-request" };
+	if (options.request.method !== "GET") return { kind: "skip-non-get" };
+	if (!isForceStatic && hasSearchParams(options.searchParams)) return { kind: "skip-search-params" };
+	if (!shouldReadAppPageCache({
+		isDraftMode,
+		isForceDynamic,
+		isProgressiveActionRender: options.isProgressiveActionRender === true,
+		isProduction: options.isProduction,
+		isRscRequest: false,
+		revalidateSeconds: currentRevalidateSeconds,
+		scriptNonce: options.scriptNonce
+	})) return { kind: "skip-cache-disabled" };
+	return {
+		kind: "probe-fallback-shells",
+		fallbackShells
 	};
 }
+async function probePprFallbackShellCache(options, route, fallbackShells, currentRevalidateSeconds) {
+	for (const fallbackShell of fallbackShells) {
+		const fallbackShellResponse = await readAppPageFallbackShellCacheResponse({
+			clearRequestContext: options.clearRequestContext,
+			expireSeconds: options.expireSeconds,
+			fallbackPathname: fallbackShell.pathname,
+			isEdgeRuntime: options.isEdgeRuntime,
+			isrDebug: options.isrDebug,
+			isrGet: options.isrGet,
+			isrHtmlKey: options.isrHtmlKey,
+			middlewareHeaders: options.middlewareContext.headers,
+			middlewareStatus: options.middlewareContext.status,
+			revalidateSeconds: currentRevalidateSeconds ?? 0,
+			rewriteHtml(html) {
+				return rewriteAppPprFallbackShellHtmlNavigation({
+					html,
+					params: options.params,
+					pathname: options.cleanPathname,
+					searchParams: options.searchParams
+				});
+			}
+		});
+		if (fallbackShellResponse) return fallbackShellResponse;
+	}
+	return null;
+}
+async function tryServePprFallbackShell(options, route, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) {
+	const decision = classifyPprFallbackShellEligibility(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic);
+	switch (decision.kind) {
+		case "skip-known-pregenerated-route":
+		case "skip-no-fallback-shells":
+		case "skip-rsc-request":
+		case "skip-non-get":
+		case "skip-search-params":
+		case "skip-cache-disabled": return null;
+		case "probe-fallback-shells": return await probePprFallbackShellCache(options, route, decision.fallbackShells, currentRevalidateSeconds);
+	}
+}
 async function dispatchAppPage(options) {
-	return await runWithFetchDedupe(() => dispatchAppPageInner(options));
+	const dispatch = () => runWithFetchDedupe(() => dispatchAppPageInner(options));
+	if (!options.pprFallbackShell) return await dispatch();
+	return await runWithPprFallbackShellState(createPprFallbackShellState(options.pprFallbackShell), dispatch);
 }
 async function dispatchAppPageInner(options) {
 	const route = options.route;
@@ -161,6 +223,7 @@ async function dispatchAppPageInner(options) {
 	const layoutParamAccess = createAppLayoutParamAccessTracker();
 	setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], route.routeSegments));
 	setCurrentFetchCacheMode(options.fetchCache ?? null);
+	setCurrentForceDynamicFetchDefault(isForceDynamic);
 	if (options.hasPageModule && !options.hasPageDefaultExport) {
 		options.clearRequestContext();
 		return new Response("Page has no default export", { status: 500 });
@@ -242,7 +305,7 @@ async function dispatchAppPageInner(options) {
 					displayPathname: options.displayPathname,
 					currentFetchCacheMode: options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
 					draftModeSecret: options.draftModeSecret,
-					dynamicConfig,
+					dynamicConfig: options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0),
 					params: revalidationTarget.navigationParams,
 					routePattern: revalidationTarget.route.pattern,
 					routeSegments: revalidationTarget.route.routeSegments,
@@ -250,72 +313,34 @@ async function dispatchAppPageInner(options) {
 				}, async () => {
 					const revalidatedElement = await options.buildPageElement(revalidationTarget.route, revalidationTarget.params, revalidationTarget.interceptOpts, new URLSearchParams());
 					const revalidatedOnError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern);
-					const revalidatedRscCapture = teeAppPageRscStreamForCapture(options.renderToReadableStream(revalidatedElement, { onError: revalidatedOnError }), true);
-					const revalidatedSsrEntry = await options.loadSsrHandler();
-					const revalidatedCapturedRscRef = { value: null };
-					const revalidatedHtmlResult = await revalidatedSsrEntry.handleSsr(revalidatedRscCapture.ssrStream, options.getNavigationContext(), {
-						links: options.getFontLinks(),
-						styles: options.getFontStyles(),
-						preloads: options.getFontPreloads()
-					}, {
+					const rendered = await renderAppPageCacheArtifacts({
 						basePath: options.basePath,
+						captureRscData: true,
+						cleanPathname: options.cleanPathname,
 						clientTraceMetadata: options.clientTraceMetadata,
+						element: revalidatedElement,
+						getFontLinks: options.getFontLinks,
+						getFontPreloads: options.getFontPreloads,
+						getFontStyles: options.getFontStyles,
+						getNavigationContext: options.getNavigationContext,
+						loadSsrHandler: options.loadSsrHandler,
+						mountedSlotsHeader: options.mountedSlotsHeader,
+						navigationParams: revalidationTarget.navigationParams,
+						onError: revalidatedOnError,
 						reactMaxHeadersLength: options.reactMaxHeadersLength,
+						renderToReadableStream: options.renderToReadableStream,
 						rootParams: options.rootParams,
-						waitForAllReady: true,
-						...revalidatedRscCapture.sideStream ? {
-							sideStream: revalidatedRscCapture.sideStream,
-							capturedRscDataRef: revalidatedCapturedRscRef
-						} : {}
+						route: revalidationTarget.route,
+						waitForAllReady: true
 					});
-					const html = await readStreamAsText(isAppSsrRenderResult(revalidatedHtmlResult) ? revalidatedHtmlResult.htmlStream : revalidatedHtmlResult);
-					const rscData = await getCapturedRscDataPromise(revalidatedCapturedRscRef.value);
-					const cacheLife = _consumeRequestScopedCacheLife();
 					options.clearRequestContext();
-					const tags = buildAppPageTags(options.cleanPathname, getCollectedFetchTags(), revalidationTarget.route.routeSegments);
-					const observationState = {
-						dynamicFetches: consumeDynamicFetchObservations(),
-						requestApis: consumeRenderRequestApiUsage()
-					};
 					return {
-						html,
-						htmlRenderObservation: createAppPageRenderObservation({
-							boundaryOutcome: { kind: "success" },
-							cacheability: "public",
-							cacheTags: tags,
-							cleanPathname: options.cleanPathname,
-							completeness: "complete",
-							output: createAppPageHtmlOutputScope({
-								element: revalidatedElement,
-								renderEpoch: null,
-								rootBoundaryId: null,
-								routePattern: revalidationTarget.route.pattern
-							}),
-							params: revalidationTarget.navigationParams,
-							state: observationState
-						}),
-						rscData,
-						rscRenderObservation: createAppPageRenderObservation({
-							boundaryOutcome: { kind: "success" },
-							cacheability: "public",
-							cacheTags: tags,
-							cleanPathname: options.cleanPathname,
-							completeness: "complete",
-							output: createAppPageRscOutputScope({
-								element: revalidatedElement,
-								mountedSlotsHeader: options.mountedSlotsHeader,
-								renderEpoch: null,
-								rootBoundaryId: null,
-								routePattern: revalidationTarget.route.pattern
-							}),
-							params: revalidationTarget.navigationParams,
-							state: observationState
-						}),
-						tags,
-						cacheControl: typeof cacheLife?.revalidate === "number" ? {
-							revalidate: cacheLife.revalidate,
-							expire: cacheLife.expire
-						} : void 0
+						html: rendered.html,
+						htmlRenderObservation: rendered.htmlRenderObservation,
+						rscData: rendered.rscData,
+						rscRenderObservation: rendered.rscRenderObservation,
+						tags: rendered.tags,
+						cacheControl: rendered.cacheControl
 					};
 				});
 			},
@@ -329,18 +354,23 @@ async function dispatchAppPageInner(options) {
 		});
 		if (cachedPageResponse) return cachedPageResponse;
 	}
-	const dynamicParamsResponse = await validateAppPageDynamicParams({
-		clearRequestContext: options.clearRequestContext,
-		enforceStaticParamsOnly: options.dynamicParamsConfig === false,
-		generateStaticParams: options.generateStaticParams,
-		isDynamicRoute: route.isDynamic,
-		params: options.staticParamsValidationParams ?? options.params
-	});
-	if (dynamicParamsResponse) return dynamicParamsResponse;
+	if (options.skipStaticParamsValidation !== true) {
+		const dynamicParamsResponse = await validateAppPageDynamicParams({
+			clearRequestContext: options.clearRequestContext,
+			enforceStaticParamsOnly: options.dynamicParamsConfig === false,
+			generateStaticParams: options.generateStaticParams,
+			isDynamicRoute: route.isDynamic,
+			params: options.staticParamsValidationParams ?? options.params
+		});
+		if (dynamicParamsResponse) return dynamicParamsResponse;
+	}
+	const fallbackShellResponse = await tryServePprFallbackShell(options, route, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic);
+	if (fallbackShellResponse) return fallbackShellResponse;
 	const interceptResult = await resolveAppPageIntercept({
 		async buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess) {
 			await options.ensureRouteLoaded?.(interceptRoute);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(interceptRoute) ?? null);
+			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(interceptRoute) === "force-dynamic");
 			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess);
 		},
 		cleanPathname: options.cleanPathname,
@@ -380,11 +410,20 @@ async function dispatchAppPageInner(options) {
 		}
 	});
 	if (interceptResult.response) return interceptResult.response;
-	const pageBuildResult = await buildAppPageElement({
+	const buildCurrentPageElement = () => buildAppPageElement({
 		buildPageElement() {
 			if (options.actionFailed) throw options.actionError;
 			return options.buildPageElement(route, options.params, interceptResult.interceptOpts, options.searchParams, layoutParamAccess);
 		},
+		async probePageSpecialError() {
+			if (!shouldSuppressLoadingBoundaries(options.renderMode ?? "navigation") && route.loading?.default) return null;
+			return resolveAppPageSpecialError(await probeAppPageThrownError({
+				probePage: options.probePage,
+				runWithSuppressedHookWarning(probe) {
+					return options.runWithSuppressedHookWarning(probe);
+				}
+			}));
+		},
 		renderErrorBoundaryPage(buildError) {
 			return options.renderErrorBoundaryPage(buildError);
 		},
@@ -393,6 +432,19 @@ async function dispatchAppPageInner(options) {
 		},
 		resolveSpecialError: resolveAppPageSpecialError
 	});
+	const fallbackShellState = getPprFallbackShellState();
+	if (fallbackShellState && process.env.VINEXT_PRERENDER === "1" && !options.isRscRequest) {
+		const warmupBuildResult = await buildCurrentPageElement();
+		if (warmupBuildResult.response) return warmupBuildResult.response;
+		await warmPprFallbackShellCaches({
+			element: warmupBuildResult.element,
+			onError: options.createRscOnErrorHandler(options.cleanPathname, route.pattern),
+			renderToReadableStream: options.renderToReadableStream,
+			state: fallbackShellState
+		});
+		discardAppPageRenderState();
+	}
+	const pageBuildResult = await buildCurrentPageElement();
 	if (pageBuildResult.response) return pageBuildResult.response;
 	const navigationParams = resolveAppPageNavigationParams(route, options.params, options.cleanPathname, interceptResult.interceptOpts);
 	options.setNavigationContext({
@@ -401,6 +453,9 @@ async function dispatchAppPageInner(options) {
 		params: navigationParams
 	});
 	const layoutClassifications = getEffectiveLayoutClassifications(route, options.debugClassification);
+	const activeFallbackShellState = getPprFallbackShellState();
+	const pprFallbackShellSignal = activeFallbackShellState?.abortController.signal;
+	const pprFallbackShellReactSignal = activeFallbackShellState?.reactAbortController.signal;
 	return renderAppPageLifecycle({
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
@@ -409,12 +464,7 @@ async function dispatchAppPageInner(options) {
 		clearRequestContext: options.clearRequestContext,
 		consumeDynamicUsage,
 		consumeInvalidDynamicUsageError,
-		consumeRenderObservationState() {
-			return {
-				dynamicFetches: consumeDynamicFetchObservations(),
-				requestApis: consumeRenderRequestApiUsage()
-			};
-		},
+		consumeRenderObservationState: consumeAppPageRenderObservationState,
 		createRscOnErrorHandler(pathname, routePath) {
 			return options.createRscOnErrorHandler(pathname, routePath);
 		},
@@ -457,6 +507,11 @@ async function dispatchAppPageInner(options) {
 		middlewareContext: options.middlewareContext,
 		navigationParams,
 		params: options.params,
+		pprFallbackShellSignal,
+		pprFallbackShellReactSignal,
+		abortPprFallbackShell: activeFallbackShellState ? () => {
+			beginPprFallbackShellFinalRender(activeFallbackShellState);
+		} : void 0,
 		layoutParamAccess,
 		rootParams: options.rootParams,
 		peekRenderObservationState() {
@@ -509,6 +564,8 @@ async function dispatchAppPageInner(options) {
 			return renderPageSpecialError(options, specialError);
 		},
 		renderToReadableStream: options.renderToReadableStream,
+		hasCustomGlobalError: options.hasCustomGlobalError,
+		prerenderToReadableStream: options.prerenderToReadableStream,
 		routePattern: route.pattern,
 		runWithSuppressedHookWarning(probe) {
 			return options.runWithSuppressedHookWarning(probe);

package/dist/server/app-page-element-builder.d.ts

@@ -24,6 +24,7 @@ type AppPageInterceptOptions<TModule extends AppPageModule = AppPageModule> = {
   interceptSlotId?: string | null;
   interceptSlotKey?: string | null;
   interceptSourceMatchedUrl?: string | null;
+  interceptSourcePageSegments?: readonly string[] | null;
 };
 type AppPagePageRequest<TModule extends AppPageModule = AppPageModule> = {
   /** Interception context from current-route navigation (null for direct visits). */opts?: AppPageInterceptOptions<TModule> | null; /** URL search params from the incoming request (null when unavailable). */

package/dist/server/app-page-element-builder.js

@@ -6,7 +6,7 @@ import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { resolveActiveParallelRouteHeadInputs, resolveAppPageHead } from "./app-page-head.js";
 import { makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
-import { buildAppPageElements, createAppPageTreePath } from "./app-page-route-wiring.js";
+import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath } from "./app-page-route-wiring.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
 import "./app-rsc-route-matching.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
@@ -36,6 +36,7 @@ async function buildPageElements(options) {
 	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
 	const EffectivePageComponent = effectivePageModule?.default;
 	const effectiveParams = isSiblingIntercept ? opts.interceptParams ?? params : params;
+	const sourcePageSegments = isSiblingIntercept ? opts?.interceptSourcePageSegments : route.routeSegments;
 	const hasPageModule = !!pageModule;
 	const renderIdentity = createAppPageRenderIdentity({
 		displayPathname,
@@ -56,7 +57,8 @@ async function buildPageElements(options) {
 				interceptionContext: renderIdentity.interceptionContext,
 				layoutIds: noExportLayoutIds,
 				rootLayoutTreePath: noExportRootLayout,
-				routeId: renderIdentity.routeId
+				routeId: renderIdentity.routeId,
+				sourcePage: createAppPageSourcePage(sourcePageSegments)
 			}),
 			[renderIdentity.routeId]: createElement("div", null, "Page has no default export")
 		};
@@ -112,6 +114,7 @@ async function buildPageElements(options) {
 		resolvedViewport,
 		renderIdentity,
 		routePath,
+		sourcePageSegments,
 		rootNotFoundModule: rootNotFoundModule ?? null,
 		rootForbiddenModule: rootForbiddenModule ?? null,
 		rootUnauthorizedModule: rootUnauthorizedModule ?? null,

package/dist/server/app-page-execution.d.ts

@@ -121,13 +121,18 @@ type ProbeAppPageComponentOptions = {
   probePage: () => unknown;
   runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
 };
+type ProbeAppPageThrownErrorOptions = {
+  probePage: () => unknown;
+  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
+};
 declare function resolveAppPageSpecialError(error: unknown): AppPageSpecialError | null;
 declare function buildAppPageSpecialErrorResponse(options: BuildAppPageSpecialErrorResponseOptions): Promise<Response>;
 /** See `LayoutFlags` type docblock in app-elements.ts for lifecycle. */
 declare function probeAppPageLayouts(options: ProbeAppPageLayoutsOptions): Promise<ProbeAppPageLayoutsResult>;
 declare function probeAppPageComponent(options: ProbeAppPageComponentOptions): Promise<Response | null>;
+declare function probeAppPageThrownError(options: ProbeAppPageThrownErrorOptions): Promise<unknown>;
 declare function readAppPageBinaryStream(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
 declare function teeAppPageRscStreamForCapture(stream: ReadableStream<Uint8Array>, shouldCapture: boolean): AppPageRscStreamCapture;
 declare function buildAppPageFontLinkHeader(preloads: readonly AppPageFontPreload[] | null | undefined): string;
 //#endregion
-export { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions, type LayoutFlags, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };
+export { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions, type LayoutFlags, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, probeAppPageThrownError, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };

package/dist/server/app-page-execution.js

@@ -274,6 +274,26 @@ async function probeAppPageComponent(options) {
 		return outcome.completed ? outcome.result : null;
 	});
 }
+async function probeAppPageThrownError(options) {
+	return options.runWithSuppressedHookWarning(async () => {
+		const outcome = await runWithConnectionProbe(async () => {
+			try {
+				const pageResult = options.probePage();
+				if (isPromiseLike(pageResult)) await pageResult;
+			} catch (error) {
+				return {
+					error,
+					thrown: true
+				};
+			}
+			return {
+				error: null,
+				thrown: false
+			};
+		});
+		return outcome.completed && outcome.result.thrown ? outcome.result.error : null;
+	});
+}
 async function readAppPageBinaryStream(stream) {
 	const reader = stream.getReader();
 	const chunks = [];
@@ -305,4 +325,4 @@ function buildAppPageFontLinkHeader(preloads) {
 	return preloads.map((preload) => `<${preload.href}>; rel=preload; as=font; type=${preload.type}; crossorigin`).join(", ");
 }
 //#endregion
-export { buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };
+export { buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, probeAppPageThrownError, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };

package/dist/server/app-page-probe.d.ts

@@ -119,6 +119,7 @@ type ProbeAppPageBeforeRenderResult = {
 };
 type ProbeAppPageBeforeRenderOptions = {
   hasLoadingBoundary: boolean;
+  skipProbes?: boolean;
   layoutCount: number;
   probeLayoutAt: (layoutIndex: number) => unknown;
   probePage: () => unknown;

package/dist/server/app-page-probe.js

@@ -227,6 +227,10 @@ function buildAppPageProbes(options) {
 }
 async function probeAppPageBeforeRender(options) {
 	let layoutFlags = {};
+	if (options.skipProbes) return {
+		response: null,
+		layoutFlags
+	};
 	if (options.layoutCount > 0) {
 		const layoutProbeResult = await probeAppPageLayouts({
 			layoutCount: options.layoutCount,

package/dist/server/app-page-render-observation.d.ts

@@ -7,6 +7,8 @@ type AppPageRenderObservationState = Readonly<{
   requestApis: readonly RenderRequestApiKind[];
 }>;
 declare function createEmptyAppPageRenderObservationState(): AppPageRenderObservationState;
+declare function consumeAppPageRenderObservationState(): AppPageRenderObservationState;
+declare function discardAppPageRenderState(): void;
 declare function createAppPageRenderObservation(options: {
   boundaryOutcome: BoundaryOutcome;
   cacheTags: readonly string[];
@@ -31,4 +33,4 @@ declare function createAppPageHtmlOutputScope(options: {
   routePattern: string;
 }): CacheProofOutputScope;
 //#endregion
-export { AppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState };
+export { AppPageRenderObservationState, consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState, discardAppPageRenderState };

package/dist/server/app-page-render-observation.js

@@ -1,7 +1,10 @@
+import { consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage } from "../shims/headers.js";
 import { fnv1a64 } from "../utils/hash.js";
+import { _consumeRequestScopedCacheLife } from "../shims/cache.js";
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import "./app-elements.js";
+import { consumeDynamicFetchObservations } from "../shims/fetch-cache.js";
 import { buildRenderObservation, buildRenderRequestApiObservations } from "./cache-proof.js";
 //#region src/server/app-page-render-observation.ts
 function readRootBoundaryId(element) {
@@ -30,6 +33,19 @@ function createEmptyAppPageRenderObservationState() {
 		requestApis: []
 	};
 }
+function consumeAppPageRenderObservationState() {
+	return {
+		dynamicFetches: consumeDynamicFetchObservations(),
+		requestApis: consumeRenderRequestApiUsage()
+	};
+}
+function discardAppPageRenderState() {
+	_consumeRequestScopedCacheLife();
+	consumeDynamicFetchObservations();
+	consumeRenderRequestApiUsage();
+	consumeInvalidDynamicUsageError();
+	consumeDynamicUsage();
+}
 function createAppPageRenderObservation(options) {
 	return buildRenderObservation({
 		boundaryOutcome: options.boundaryOutcome,
@@ -63,4 +79,4 @@ function createAppPageHtmlOutputScope(options) {
 	};
 }
 //#endregion
-export { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState };
+export { consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState, discardAppPageRenderState };

package/dist/server/app-page-render.d.ts

@@ -7,8 +7,8 @@ import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageRenderObservationState } from "./app-page-render-observation.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { ReactNode } from "react";
 import { ReactFormState } from "react-dom/client";
 
@@ -49,6 +49,7 @@ type RenderAppPageLifecycleOptions = {
   peekRequestCacheLife?: () => AppPageRequestCacheLife | null;
   getDraftModeCookieHeader: () => string | null | undefined;
   handlerStart: number;
+  hasCustomGlobalError?: boolean;
   hasLoadingBoundary: boolean;
   dynamicStaleTimeSeconds?: number;
   isDynamicError: boolean;
@@ -70,6 +71,9 @@ type RenderAppPageLifecycleOptions = {
   middlewareContext: AppPageMiddlewareContext;
   navigationParams: Record<string, unknown>;
   params: Record<string, unknown>;
+  pprFallbackShellSignal?: AbortSignal;
+  pprFallbackShellReactSignal?: AbortSignal;
+  abortPprFallbackShell?: () => void;
   rootParams?: RootParams;
   peekRenderObservationState?: () => AppPageRenderObservationState;
   probeLayoutAt: (layoutIndex: number) => unknown;
@@ -82,7 +86,14 @@ type RenderAppPageLifecycleOptions = {
   renderPageSpecialError: (specialError: AppPageSpecialError) => Promise<Response>;
   renderToReadableStream: (element: ReactNode | AppOutgoingElements, options: {
     onError: AppPageBoundaryOnError;
+    signal?: AbortSignal;
   }) => ReadableStream<Uint8Array>;
+  prerenderToReadableStream?: (element: ReactNode | AppOutgoingElements, options: {
+    onError: AppPageBoundaryOnError;
+    signal?: AbortSignal;
+  }) => Promise<{
+    prelude: ReadableStream<Uint8Array>;
+  }>;
   routePattern: string;
   runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
   scriptNonce?: string;