vinext 0.1.2 → 0.1.3

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

@@ -0,0 +1,91 @@
+import { consumeDynamicUsage, consumeInvalidDynamicUsageError } from "../shims/headers.js";
+import { _consumeRequestScopedCacheLife } from "../shims/cache.js";
+import { getCollectedFetchTags } from "../shims/fetch-cache.js";
+import { readStreamAsText } from "../utils/text-stream.js";
+import { teeAppPageRscStreamForCapture } from "./app-page-execution.js";
+import { consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
+import { isAppSsrRenderResult } from "./app-page-stream.js";
+import { buildAppPageTags } from "./implicit-tags.js";
+//#region src/server/app-page-cache-render.ts
+/**
+* Render an App page element to HTML (and optionally its RSC payload) for cache
+* storage. Combines the RSC stream, SSR handler, observation consumption, and
+* cache-tag construction used by both normal ISR revalidation and PPR fallback
+* shell regeneration.
+*/
+async function renderAppPageCacheArtifacts(options) {
+	const rscCapture = teeAppPageRscStreamForCapture(options.renderToReadableStream(options.element, { onError: options.onError }), options.captureRscData);
+	const capturedRscDataRef = { value: null };
+	const htmlResult = await (await options.loadSsrHandler()).handleSsr(rscCapture.ssrStream, options.getNavigationContext(), {
+		links: options.getFontLinks(),
+		styles: options.getFontStyles(),
+		preloads: options.getFontPreloads()
+	}, {
+		basePath: options.basePath,
+		clientTraceMetadata: options.clientTraceMetadata,
+		reactMaxHeadersLength: options.reactMaxHeadersLength,
+		rootParams: options.rootParams,
+		waitForAllReady: options.waitForAllReady,
+		...rscCapture.sideStream ? {
+			sideStream: rscCapture.sideStream,
+			capturedRscDataRef
+		} : {}
+	});
+	const html = await readStreamAsText(isAppSsrRenderResult(htmlResult) ? htmlResult.htmlStream : htmlResult);
+	let rscData;
+	if (options.captureRscData) {
+		const capturedPromise = capturedRscDataRef.value;
+		if (!capturedPromise) throw new Error("[vinext] Expected captured RSC data while rendering app page cache artifacts");
+		rscData = await capturedPromise;
+	}
+	const cacheLife = _consumeRequestScopedCacheLife();
+	const tags = buildAppPageTags(options.cleanPathname, getCollectedFetchTags(), options.route.routeSegments);
+	const observationState = consumeAppPageRenderObservationState();
+	consumeInvalidDynamicUsageError();
+	consumeDynamicUsage();
+	const result = {
+		html,
+		htmlRenderObservation: createAppPageRenderObservation({
+			boundaryOutcome: { kind: "success" },
+			cacheability: "public",
+			cacheTags: tags,
+			cleanPathname: options.cleanPathname,
+			completeness: "complete",
+			output: createAppPageHtmlOutputScope({
+				element: options.element,
+				renderEpoch: null,
+				rootBoundaryId: null,
+				routePattern: options.route.pattern
+			}),
+			params: options.navigationParams,
+			state: observationState
+		}),
+		tags,
+		cacheControl: typeof cacheLife?.revalidate === "number" ? {
+			revalidate: cacheLife.revalidate,
+			expire: cacheLife.expire
+		} : void 0
+	};
+	if (options.captureRscData) {
+		result.rscData = rscData;
+		result.rscRenderObservation = createAppPageRenderObservation({
+			boundaryOutcome: { kind: "success" },
+			cacheability: "public",
+			cacheTags: tags,
+			cleanPathname: options.cleanPathname,
+			completeness: "complete",
+			output: createAppPageRscOutputScope({
+				element: options.element,
+				mountedSlotsHeader: options.mountedSlotsHeader,
+				renderEpoch: null,
+				rootBoundaryId: null,
+				routePattern: options.route.pattern
+			}),
+			params: options.navigationParams,
+			state: observationState
+		});
+	}
+	return result;
+}
+//#endregion
+export { renderAppPageCacheArtifacts };

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

@@ -1,8 +1,8 @@
 import { RenderObservation } from "./cache-proof.js";
 import { CacheControlMetadata, CachedAppPageValue } from "../shims/cache.js";
+import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { ISRCacheEntry } from "./isr-cache.js";
-import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 
 //#region src/server/app-page-cache.d.ts
 type AppPageDebugLogger = (event: string, detail: string) => void;
@@ -70,6 +70,19 @@ type ReadAppPageCacheResponseOptions = {
   renderFreshPageForCache: () => Promise<AppPageCacheRenderResult>;
   scheduleBackgroundRegeneration: AppPageBackgroundRegenerator;
 };
+type ReadAppPageFallbackShellCacheResponseOptions = {
+  clearRequestContext: () => void;
+  expireSeconds?: number;
+  fallbackPathname: string;
+  isEdgeRuntime?: boolean;
+  isrDebug?: AppPageDebugLogger;
+  isrGet: AppPageCacheGetter;
+  isrHtmlKey: (pathname: string) => string;
+  middlewareHeaders?: Headers | null;
+  middlewareStatus?: number | null;
+  revalidateSeconds: number;
+  rewriteHtml: (html: string) => string;
+};
 type FinalizeAppPageHtmlCacheResponseOptions = {
   capturedDynamicUsageBeforeContextCleanup?: () => boolean;
   capturedRscDataPromise: Promise<ArrayBuffer> | null;
@@ -113,8 +126,9 @@ type ScheduleAppPageRscCacheWriteOptions = {
 declare function buildAppPageCacheTags(pathname: string, extraTags: readonly string[]): string[];
 declare function buildAppPageCachedResponse(cachedValue: CachedAppPageValue, options: BuildAppPageCachedResponseOptions): Response | null;
 declare function readAppPageCacheResponse(options: ReadAppPageCacheResponseOptions): Promise<Response | null>;
+declare function readAppPageFallbackShellCacheResponse(options: ReadAppPageFallbackShellCacheResponseOptions): Promise<Response | null>;
 declare function finalizeAppPageHtmlCacheResponse(response: Response, options: FinalizeAppPageHtmlCacheResponseOptions): Response;
 declare function finalizeAppPageRscCacheResponse(response: Response, options: ScheduleAppPageRscCacheWriteOptions): Response;
 declare function scheduleAppPageRscCacheWrite(options: ScheduleAppPageRscCacheWriteOptions): boolean;
 //#endregion
-export { AppPageCacheOutcomeMetric, buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, scheduleAppPageRscCacheWrite };
+export { AppPageCacheOutcomeMetric, buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, readAppPageFallbackShellCacheResponse, scheduleAppPageRscCacheWrite };

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

@@ -10,6 +10,7 @@ import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { hasCompleteNegativeRequestApiProof } from "./cache-proof.js";
 import { createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
+import { isAppPprDynamicFallbackShellHtml } from "./app-ppr-fallback-shell.js";
 //#region src/server/app-page-cache.ts
 /**
 * Apply the CDN cache adapter's headers to a freshly-streamed response whose
@@ -121,6 +122,29 @@ function buildAppPageCachedResponse(cachedValue, options) {
 		headers: htmlHeaders
 	});
 }
+async function serveAppPageCachedHtml(options, transformValue) {
+	if (typeof options.cachedValue.html !== "string" || options.cachedValue.html.length === 0) {
+		if (options.cached?.isStale) options.scheduleRegeneration();
+		options.isrDebug?.(options.emptyDebugMessage, options.pathname);
+		return null;
+	}
+	const cacheState = options.cached?.isStale ? "STALE" : "HIT";
+	if (options.cached?.isStale) options.scheduleRegeneration();
+	const response = buildAppPageCachedResponse(transformValue ? transformValue(options.cachedValue) : options.cachedValue, {
+		cacheState,
+		cacheControl: options.cached?.value.cacheControl,
+		expireSeconds: options.expireSeconds,
+		isEdgeRuntime: options.isEdgeRuntime,
+		isRscRequest: false,
+		middlewareHeaders: options.middlewareHeaders,
+		middlewareStatus: options.middlewareStatus,
+		revalidateSeconds: options.revalidateSeconds
+	});
+	if (!response) return null;
+	options.isrDebug?.(`${cacheState} (${options.stateDebugLabel})`, options.pathname);
+	options.clearRequestContext();
+	return response;
+}
 async function readAppPageCacheResponse(options) {
 	const isrKey = options.isRscRequest ? options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext) : options.isrHtmlKey(options.cleanPathname);
 	const artifact = options.isRscRequest ? "rsc" : "html";
@@ -239,6 +263,43 @@ async function readAppPageCacheResponse(options) {
 	}
 	return null;
 }
+async function readAppPageFallbackShellCacheResponse(options) {
+	const isrKey = options.isrHtmlKey(options.fallbackPathname);
+	try {
+		const cached = await options.isrGet(isrKey);
+		const cachedValue = getCachedAppPageValue(cached);
+		if (!cachedValue) {
+			options.isrDebug?.("MISS (fallback shell)", options.fallbackPathname);
+			return null;
+		}
+		if (isAppPprDynamicFallbackShellHtml(cachedValue.html)) {
+			options.isrDebug?.("MISS (dynamic fallback shell requires resume)", options.fallbackPathname);
+			return null;
+		}
+		return await serveAppPageCachedHtml({
+			cached,
+			cachedValue,
+			clearRequestContext: options.clearRequestContext,
+			emptyDebugMessage: "MISS (empty fallback shell)",
+			expireSeconds: options.expireSeconds,
+			isEdgeRuntime: options.isEdgeRuntime,
+			isrDebug: options.isrDebug,
+			middlewareHeaders: options.middlewareHeaders,
+			middlewareStatus: options.middlewareStatus,
+			pathname: options.fallbackPathname,
+			revalidateSeconds: options.revalidateSeconds,
+			scheduleRegeneration() {},
+			stateDebugLabel: "fallback shell"
+		}, (value) => ({
+			...value,
+			html: options.rewriteHtml(value.html)
+		}));
+	} catch (isrReadError) {
+		options.isrDebug?.("MISS (fallback shell read error)", options.fallbackPathname);
+		console.error("[vinext] ISR fallback shell cache read error:", isrReadError);
+		return null;
+	}
+}
 function finalizeAppPageHtmlCacheResponse(response, options) {
 	if (!response.body) return response;
 	const [streamForClient, streamForCache] = response.body.tee();
@@ -334,4 +395,4 @@ function scheduleAppPageRscCacheWrite(options) {
 	return true;
 }
 //#endregion
-export { buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, scheduleAppPageRscCacheWrite };
+export { buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, readAppPageFallbackShellCacheResponse, scheduleAppPageRscCacheWrite };

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

@@ -11,6 +11,7 @@ import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { ISRCacheEntry } from "./isr-cache.js";
 import { FetchCacheMode } from "../shims/fetch-cache.js";
+import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { ValidateAppPageDynamicParamsOptions } from "./app-page-request.js";
 import { ReactNode } from "react";
 import { ReactFormState } from "react-dom/client";
@@ -36,6 +37,7 @@ type AppPageDispatchIntercept<TPage = unknown> = {
   slotId?: string | null;
   slotKey: string;
   sourceRouteIndex: number;
+  sourcePageSegments?: readonly string[] | null;
 };
 type AppPageDispatchInterceptOptions<TPage = unknown> = {
   interceptionContext: string | null;
@@ -45,6 +47,7 @@ type AppPageDispatchInterceptOptions<TPage = unknown> = {
   interceptSlotId?: string | null;
   interceptSlotKey: string;
   interceptSourceMatchedUrl?: string | null;
+  interceptSourcePageSegments?: readonly string[] | null;
 };
 type AppPageModule = {
   default?: unknown;
@@ -120,6 +123,7 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   getNavigationContext: () => NavigationContext | null;
   getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
   hasGenerateStaticParams: boolean;
+  hasCustomGlobalError?: boolean;
   hasPageDefaultExport: boolean;
   hasPageModule: boolean;
   handlerStart: number;
@@ -138,6 +142,20 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   middlewareContext: AppPageMiddlewareContext;
   mountedSlotsHeader?: string | null;
   params: AppPageParams;
+  pprFallbackCacheShells?: readonly AppPagePprFallbackCacheShell[] | null;
+  pprFallbackShell?: {
+    fallbackParamNames: readonly string[];
+    routePattern: string;
+  };
+  /**
+   * Set of concrete URL paths that were pre-rendered at build time for this
+   * route. When the exact cache entry for a known pregenerated path is absent
+   * (evicted, stale-empty, cold start, read error), the fallback shell must
+   * NOT be served — the route is a valid generated route whose cache merely
+   * has a transient gap. Falls through to a fresh render instead.
+   */
+  renderedConcreteUrlPaths?: ReadonlySet<string>;
+  skipStaticParamsValidation?: boolean;
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   probeLayoutAt: (layoutIndex: number, layoutParamAccess?: AppLayoutParamAccessTracker) => unknown;
@@ -152,10 +170,18 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   }, middlewareContext: AppPageMiddlewareContext | null) => Promise<Response | null>;
   renderToReadableStream: (element: AppPageRenderableElement, options: {
     onError: AppPageBoundaryOnError;
+    signal?: AbortSignal;
   }) => ReadableStream<Uint8Array>;
+  prerenderToReadableStream?: (element: AppPageRenderableElement, options: {
+    onError: AppPageBoundaryOnError;
+    signal?: AbortSignal;
+  }) => Promise<{
+    prelude: ReadableStream<Uint8Array>;
+  }>;
   request: Request;
   revalidateSeconds: number | null;
   resolveRouteFetchCacheMode?: (route: TRoute) => FetchCacheMode | null;
+  resolveRouteDynamicConfig?: (route: TRoute) => string | null | undefined;
   rootForbiddenModule?: AppPageModule | null;
   rootNotFoundModule?: AppPageModule | null;
   rootUnauthorizedModule?: AppPageModule | null;

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);