vinext 1.0.0-beta.8 → 1.0.0

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

@@ -10,6 +10,7 @@ import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
+import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
 import { AppPageCacheSetter, ISRCacheEntry } from "./isr-cache.js";
 import { PprFallbackShellState } from "../shims/ppr-fallback-shell.js";
 import { FetchCacheMode } from "../shims/fetch-cache.js";
@@ -21,14 +22,15 @@ import { ReactFormState } from "react-dom/client";
 //#region src/server/app-page-dispatch.d.ts
 type AppPageParams = Record<string, string | string[]>;
 type AppPageElement = ReactNode | Readonly<Record<string, ReactNode>>;
-type AppPageRenderableElement = ReactNode | AppOutgoingElements;
-type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
+export type AppPageRenderableElement = ReactNode | AppOutgoingElements;
+export type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 type AppPageDebugLogger = (event: string, detail: string) => void;
 type AppPageCacheGetter = (key: string) => Promise<ISRCacheEntry | null>;
 type AppPageBackgroundRegenerationErrorContext = {
   routerKind: "App Router";
   routePath: string;
   routeType: "render";
+  shouldReport?: (error: unknown) => boolean;
 };
 type AppPageBackgroundRegenerator = (key: string, renderFn: () => Promise<void>, errorContext?: AppPageBackgroundRegenerationErrorContext) => void;
 type AppPageDispatchIntercept<TPage = unknown> = {
@@ -86,7 +88,7 @@ type AppPageDispatchSlot = {
   slotPatternParts?: readonly string[] | null;
   slotParamNames?: readonly string[] | null;
 };
-type AppPageDispatchRoute = {
+export type AppPageDispatchRoute = {
   __buildTimeClassifications?: LayoutClassificationOptions["buildTimeClassifications"];
   __buildTimeReasons?: LayoutClassificationOptions["buildTimeReasons"];
   error?: AppPageModule | null;
@@ -110,17 +112,19 @@ type AppPageDispatchRoute = {
   unauthorizedTreePosition?: number | null;
   unauthorizeds?: readonly (AppPageModule | null | undefined)[];
 };
-type AppPagePprRuntime<TRoute extends AppPageDispatchRoute> = {
+export type AppPagePprRuntime<TRoute extends AppPageDispatchRoute> = {
   beginFinalRender(state: AppPagePprState): void;
   getState(): AppPagePprState | null;
   run<T>(shell: NonNullable<DispatchAppPageOptions<TRoute>["pprFallbackShell"]>, fn: () => T): T;
   tryServe(options: DispatchAppPageOptions<TRoute>, currentRevalidateSeconds: number | null, isDraftMode: boolean, isForceStatic: boolean, isForceDynamic: boolean): Promise<Response | null>;
   warm(options: WarmPprFallbackShellCachesOptions): Promise<void>;
 };
-type AppPagePprState = PprFallbackShellState;
-type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
+export type AppPagePprState = PprFallbackShellState;
+export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   /** Configured basePath (e.g. "/blog"). Used to prefix redirect Locations. */
   basePath?: string;
+  /** Bypass shared RSC caches when the client-supplied interception context was not verified. */
+  bypassInterceptionContextCache?: boolean;
   /**
    * Allow-list of OpenTelemetry propagation keys (from
    * `experimental.clientTraceMetadata`) to surface as `<meta>` tags in the
@@ -134,6 +138,7 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
    */
   reactMaxHeadersLength?: number;
   buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker, options?: {
+    isForceStatic?: boolean;
     observeMetadataSearchParamsAccess?: boolean;
     observePageSearchParamsAccess?: boolean;
     serveStreamingMetadata?: boolean;
@@ -142,7 +147,7 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   cleanPathname: string;
   displayPathname?: string;
   clearRequestContext: () => void;
-  createRscOnErrorHandler: (pathname: string, routePath: string) => AppPageBoundaryOnError;
+  createRscOnErrorHandler: (pathname: string, routePath: string, overrides?: AppRenderErrorContextOverrides) => AppPageBoundaryOnError;
   debugClassification?: (layoutId: string, reason: ClassificationReason) => void;
   draftModeSecret: string;
   dynamicConfig?: string;
@@ -165,7 +170,13 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   getFontStyles: () => string[];
   getNavigationContext: () => NavigationContext | null;
   getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  /**
+   * Whether `generateStaticParams` is exported at or below the route's last
+   * dynamic segment (`hasAppPageGenerateStaticParamsAtLastDynamicSegment`).
+   */
   hasGenerateStaticParams: boolean;
+  /** Whether any segment of the route exports `generateStaticParams`. */
+  hasAnyGenerateStaticParams: boolean;
   hasCustomGlobalError?: boolean;
   hasPageDefaultExport: boolean;
   hasPageModule: boolean;
@@ -173,6 +184,13 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   htmlLimitedBots?: string;
   interceptionContext: string | null;
   isEdgeRuntime?: boolean;
+  /**
+   * Whether the route's loader tree resolves `runtime = "edge"` (or
+   * `"experimental-edge"`), which disables static generation outside
+   * `cacheComponents`. Every parallel branch merges at each node, as
+   * in Next.js's Turbopack build (`collectAppPageStaticGenerationRuntimes`).
+   */
+  isStaticGenerationEdgeRuntime?: boolean;
   isProgressiveActionRender?: boolean;
   isProduction: boolean;
   isRscRequest: boolean;
@@ -229,6 +247,13 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   resolveRouteFetchCacheMode?: (route: TRoute) => FetchCacheMode | null;
   resolveRouteRevalidateSeconds?: (route: TRoute) => number | null;
   resolveRouteDynamicConfig?: (route: TRoute) => string | null | undefined;
+  /**
+   * `isAppPageStaticEligible` for another route, from that route's own segment
+   * config, `generateStaticParams`, dynamism and runtime. A direct intercepted
+   * RSC response renders its source route, so it takes the source's
+   * cacheability.
+   */
+  resolveRouteStaticEligible: (route: TRoute) => boolean;
   rootForbiddenModule?: AppPageModule | null;
   rootNotFoundModule?: AppPageModule | null;
   rootUnauthorizedModule?: AppPageModule | null;
@@ -244,7 +269,7 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   }) => void;
   renderMode?: AppRscRenderMode;
 };
-declare function shouldReadAppPageCache(options: {
+export declare function shouldReadAppPageCache(options: {
   isProgressiveActionRender: boolean;
   isDraftMode: boolean;
   isForceDynamic: boolean;
@@ -253,7 +278,6 @@ declare function shouldReadAppPageCache(options: {
   revalidateSeconds: number | null;
   scriptNonce?: string;
 }): boolean;
-declare function hasSearchParams(searchParams: URLSearchParams | null | undefined): boolean;
-declare function dispatchAppPage<TRoute extends AppPageDispatchRoute>(options: DispatchAppPageOptions<TRoute>): Promise<Response>;
-//#endregion
-export { AppPageBoundaryOnError, AppPageDispatchRoute, AppPagePprRuntime, AppPagePprState, AppPageRenderableElement, DispatchAppPageOptions, dispatchAppPage, hasSearchParams, shouldReadAppPageCache };
+export declare function hasSearchParams(searchParams: URLSearchParams | null | undefined): boolean;
+export declare function dispatchAppPage<TRoute extends AppPageDispatchRoute>(options: DispatchAppPageOptions<TRoute>): Promise<Response>;
+//#endregion

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

@@ -1,28 +1,35 @@
 import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
-import { getRequestExecutionContext } from "../shims/request-context.js";
 import "../utils/protocol-headers.js";
-import { VINEXT_INTERCEPTION_ID_HEADER } from "./headers.js";
-import { AppElementsWire } from "./app-elements-wire.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { VINEXT_INTERCEPTION_ID_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
+import "./headers.js";
+import { beginRouteCacheability, isRouteCacheabilityIdentityProbe, isRouteCacheabilityProbe, markRouteCacheabilityPatternDynamic, readRouteCacheabilityState } from "../shims/cacheability-classification.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL } from "./app-rsc-render-mode.js";
+import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersContext, isDraftModeRequest, peekDynamicUsage, peekRenderRequestApiUsage, runWithIsolatedDynamicUsage, setHeadersContext } from "../shims/headers.js";
 import { _captureRequestScopedCacheLifeAccessors } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground } from "../shims/fetch-cache.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
+import { cacheabilityManifestPageState } from "./cacheability-manifest.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
-import "./app-page-response.js";
+import { resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildRscRedirectFlightStream } from "./app-rsc-redirect-flight.js";
 import { buildAppPageSpecialErrorResponse, probeAppPageThrownError, resolveAppPageSpecialError } from "./app-page-execution.js";
+import { resolveAppPageTraceOperation } from "./app-page-tracing.js";
 import { createAppPageTreePath } from "./app-page-route-wiring.js";
+import { traceResponseStart } from "./response-start-tracing.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
+import { isAppPageStaticEligible } from "./app-segment-config.js";
 import { resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule } from "./app-page-boundary.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
+import { createAppPageRscErrorTracker } from "./app-page-stream.js";
 import { createAppLayoutParamAccessTracker, isAppLayoutObservationUnsafeForStaticReuse } from "./app-layout-param-observation.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
 import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
-import { renderAppPageLifecycle } from "./app-page-render.js";
+import { applyIneligibleRouteCachePolicy, renderAppPageLifecycle } from "./app-page-render.js";
 //#region src/server/app-page-dispatch.ts
 function getActiveLoadingTreePositions(route) {
 	const positions = [];
@@ -127,14 +134,15 @@ function hasSearchParams(searchParams) {
 }
 async function runAppPageRevalidationContext(options, renderFn) {
 	const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
+	const headersContext = createStaticGenerationHeadersContext({
+		draftModeEnabled: false,
+		draftModeSecret: options.draftModeSecret,
+		dynamicConfig: options.dynamicConfig,
+		routeKind: "page",
+		routePattern: options.routePattern
+	});
 	const requestContext = createRequestContext({
-		headersContext: createStaticGenerationHeadersContext({
-			draftModeEnabled: false,
-			draftModeSecret: options.draftModeSecret,
-			dynamicConfig: options.dynamicConfig,
-			routeKind: "page",
-			routePattern: options.routePattern
-		}),
+		headersContext,
 		currentFetchCacheMode: options.currentFetchCacheMode ?? null,
 		currentFetchRevalidate: options.currentFetchRevalidate ?? null,
 		currentForceDynamicFetchDefault: options.dynamicConfig === "force-dynamic",
@@ -181,20 +189,62 @@ function toInterceptOptions(interceptionContext, intercept) {
 		interceptTargetRouteGraphId: intercept.targetRouteGraphId ?? null
 	};
 }
+/**
+* Workers Cache never admits a path its deploy manifest gives no state: a
+* listed path that used a dynamic API, or an unlisted path of a route without
+* on-demand ISR. Next.js serves those per request, so they render normally,
+* with real values. Without a manifest, admission uses the `runtime` policy
+* and every path keeps candidate mode, as on core.
+*/
+function hasNoManifestAdmissionState(routePattern) {
+	const admission = readRouteCacheabilityState()?.admission;
+	return admission?.policy === "manifest" && admission.representation !== void 0 && admission.routePathname !== void 0 && cacheabilityManifestPageState(admission.manifest, {
+		kind: "app-page",
+		pattern: routePattern
+	}, admission.representation, admission.routePathname) === null;
+}
 async function dispatchAppPage(options) {
 	const dispatch = () => runWithFetchDedupe(() => dispatchAppPageInner(options));
-	if (!options.pprFallbackShell || !options.pprRuntime) return await dispatch();
-	return await options.pprRuntime.run(options.pprFallbackShell, dispatch);
+	let response;
+	if (!options.pprFallbackShell || !options.pprRuntime) response = await dispatch();
+	else response = await options.pprRuntime.run(options.pprFallbackShell, dispatch);
+	return options.isRscRequest ? response : traceResponseStart(response);
 }
 async function dispatchAppPageInner(options) {
 	const route = options.route;
+	beginRouteCacheability("app-page", route.pattern);
+	if (isRouteCacheabilityIdentityProbe()) {
+		options.clearRequestContext();
+		return new Response(null, { status: 204 });
+	}
 	const dynamicConfig = options.dynamicConfig;
-	const currentRevalidateSeconds = options.revalidateSeconds;
 	const interceptionId = options.isRscRequest ? options.request.headers.get(VINEXT_INTERCEPTION_ID_HEADER) : null;
 	const isForceStatic = dynamicConfig === "force-static";
 	const isDynamicError = dynamicConfig === "error";
 	const isForceDynamic = dynamicConfig === "force-dynamic";
+	const isNextStaticEligible = isAppPageStaticEligible({
+		dynamicConfig,
+		hasGenerateStaticParams: options.hasGenerateStaticParams,
+		isDynamicRoute: route.isDynamic,
+		isStaticGenerationEdgeRuntime: options.isStaticGenerationEdgeRuntime === true,
+		revalidateSeconds: options.revalidateSeconds
+	});
+	const isStaticEligible = options.pprRuntime !== void 0 || isNextStaticEligible;
+	const hasStaticRevalidateDefault = options.isProduction && options.pprRuntime === void 0 && isNextStaticEligible;
+	const currentRevalidateSeconds = options.revalidateSeconds ?? (hasStaticRevalidateDefault || options.hasAnyGenerateStaticParams ? Infinity : null);
+	if (isRouteCacheabilityProbe()) {
+		const isRouteStaticEligible = options.pprRuntime !== void 0 || isAppPageStaticEligible({
+			dynamicConfig: options.dynamicConfig,
+			hasGenerateStaticParams: options.hasGenerateStaticParams,
+			isDynamicRoute: route.isDynamic,
+			isStaticGenerationEdgeRuntime: options.isStaticGenerationEdgeRuntime === true,
+			revalidateSeconds: options.revalidateSeconds ?? null
+		});
+		const patternDynamicReason = isForceDynamic ? "dynamic = \"force-dynamic\"" : currentRevalidateSeconds === 0 ? "revalidate = 0" : !isRouteStaticEligible ? "route is not statically generated" : null;
+		if (patternDynamicReason) markRouteCacheabilityPatternDynamic(patternDynamicReason);
+	}
 	const isPrerender = process.env.VINEXT_PRERENDER === "1";
+	let traceOperation = isPrerender ? "prerender" : "render";
 	const serveStreamingMetadata = shouldServeStreamingMetadata(options.request.headers.get("user-agent") ?? "", options.htmlLimitedBots);
 	const placeGeneratedMetadataInBody = (!isPrerender || options.pprFallbackShell !== void 0) && serveStreamingMetadata;
 	const isPrefetchDynamicShell = options.renderMode === APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL;
@@ -212,15 +262,25 @@ async function dispatchAppPageInner(options) {
 	setCurrentForceDynamicFetchDefault(isForceDynamic);
 	if (options.hasPageModule && !options.hasPageDefaultExport) {
 		options.clearRequestContext();
-		return new Response("Page has no default export", { status: 500 });
+		return applyIneligibleRouteCachePolicy(new Response("Page has no default export", { status: 500 }), {
+			isDraftMode,
+			isDynamicError,
+			isForceDynamic,
+			isForceStatic,
+			isProduction: options.isProduction,
+			isProgressiveActionRender: options.isProgressiveActionRender === true,
+			isRscRequest: options.isRscRequest,
+			isStaticEligible,
+			middlewareContext: options.middlewareContext,
+			peekDynamicUsage,
+			revalidateSeconds: currentRevalidateSeconds,
+			scriptNonce: options.scriptNonce
+		});
 	}
 	const methodResponse = resolveAppPageMethodResponse({
-		dynamicConfig,
-		hasGenerateStaticParams: options.hasGenerateStaticParams,
-		isDynamicRoute: route.isDynamic,
+		isStaticEligible: isNextStaticEligible,
 		middlewareHeaders: options.middlewareContext.headers,
-		request: options.request,
-		revalidateSeconds: currentRevalidateSeconds
+		request: options.request
 	});
 	if (methodResponse) {
 		options.clearRequestContext();
@@ -242,7 +302,7 @@ async function dispatchAppPageInner(options) {
 			params: staticNavigationParams
 		});
 	}
-	if (shouldReadAppPageCache({
+	const isCacheEligibleRender = options.bypassInterceptionContextCache !== true && shouldReadAppPageCache({
 		isDraftMode,
 		isForceDynamic,
 		isProgressiveActionRender: options.isProgressiveActionRender === true,
@@ -250,13 +310,48 @@ async function dispatchAppPageInner(options) {
 		isRscRequest: options.isRscRequest,
 		revalidateSeconds: currentRevalidateSeconds,
 		scriptNonce: options.scriptNonce
-	})) {
+	});
+	const isNeverStoredPath = options.pprRuntime === void 0 && hasNoManifestAdmissionState(route.pattern);
+	const shouldReadCache = !isRouteCacheabilityProbe() && isCacheEligibleRender && !isNeverStoredPath;
+	const isCacheCandidate = isCacheEligibleRender && isStaticEligible && options.pprRuntime === void 0 && !isNeverStoredPath;
+	if (shouldReadCache && isStaticEligible) {
+		traceOperation = resolveAppPageTraceOperation({
+			hasRequestSearchParams,
+			isDynamicError,
+			isForceStatic,
+			isKnownPrerenderedRoute: options.renderedConcreteUrlPaths !== void 0,
+			isPrerender
+		});
 		const { readAppPageCacheResponse } = await import("./app-page-cache.js");
+		const reportedSsrRevalidationErrors = /* @__PURE__ */ new Set();
+		let revalidationRscErrorTracker = null;
+		const resolveCacheRenderTarget = async () => {
+			const revalidationTarget = await resolveAppPageInterceptionRerenderTarget({
+				cleanPathname: options.cleanPathname,
+				currentParams: options.params,
+				currentRoute: route,
+				findIntercept: options.findIntercept,
+				getRouteParamNames(sourceRoute) {
+					return sourceRoute.params;
+				},
+				getSourceRoute(sourceRouteIndex) {
+					return options.getSourceRoute(sourceRouteIndex);
+				},
+				isRscRequest: options.isRscRequest,
+				toInterceptOpts(intercept) {
+					return toInterceptOptions(options.interceptionContext, intercept);
+				}
+			});
+			await options.ensureRouteLoaded?.(revalidationTarget.route);
+			revalidationTarget.navigationParams = resolveAppPageNavigationParams(revalidationTarget.route, revalidationTarget.navigationParams, options.cleanPathname, revalidationTarget.interceptOpts);
+			return revalidationTarget;
+		};
 		const cachedPageResponse = await readAppPageCacheResponse({
 			cleanPathname: options.cleanPathname,
 			clearRequestContext: options.clearRequestContext,
 			hasRequestSearchParams,
 			isEdgeRuntime: options.isEdgeRuntime,
+			isRoutePPREnabled: options.pprRuntime !== void 0,
 			isRscRequest: options.isRscRequest,
 			isrDebug: options.isrDebug,
 			isrGet: options.isrGet,
@@ -268,6 +363,10 @@ async function dispatchAppPageInner(options) {
 			middlewareHeaders: options.middlewareContext.headers,
 			middlewareStatus: options.middlewareContext.status,
 			mountedSlotsHeader: options.mountedSlotsHeader,
+			async resolveParams() {
+				return (await resolveCacheRenderTarget()).navigationParams;
+			},
+			renderedPathAndSearch: options.renderedPathAndSearch,
 			renderMode: options.renderMode,
 			expireSeconds: options.expireSeconds,
 			revalidateSeconds: resolveAppPageCacheReadRevalidateSeconds({
@@ -276,30 +375,15 @@ async function dispatchAppPageInner(options) {
 				revalidateSeconds: currentRevalidateSeconds
 			}),
 			renderFreshPageForCache: async () => {
-				const revalidationTarget = await resolveAppPageInterceptionRerenderTarget({
-					cleanPathname: options.cleanPathname,
-					currentParams: options.params,
-					currentRoute: route,
-					findIntercept: options.findIntercept,
-					getRouteParamNames(sourceRoute) {
-						return sourceRoute.params;
-					},
-					getSourceRoute(sourceRouteIndex) {
-						return options.getSourceRoute(sourceRouteIndex);
-					},
-					isRscRequest: options.isRscRequest,
-					toInterceptOpts(intercept) {
-						return toInterceptOptions(options.interceptionContext, intercept);
-					}
-				});
-				revalidationTarget.navigationParams = resolveAppPageNavigationParams(revalidationTarget.route, revalidationTarget.navigationParams, options.cleanPathname, revalidationTarget.interceptOpts);
-				await options.ensureRouteLoaded?.(revalidationTarget.route);
+				const revalidationTarget = await resolveCacheRenderTarget();
 				const revalidationDynamicConfig = options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0);
+				const revalidationConfigRevalidateSeconds = options.resolveRouteRevalidateSeconds?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? currentRevalidateSeconds : null);
+				const revalidationRouteRevalidateSeconds = revalidationTarget.route === route ? void 0 : revalidationConfigRevalidateSeconds ?? (revalidationDynamicConfig === "force-static" || revalidationDynamicConfig === "error" || options.isProduction && options.pprRuntime === void 0 && options.resolveRouteStaticEligible(revalidationTarget.route) ? Infinity : null);
 				return runAppPageRevalidationContext({
 					cleanPathname: options.cleanPathname,
 					displayPathname: options.displayPathname,
 					currentFetchCacheMode: options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
-					currentFetchRevalidate: options.resolveRouteRevalidateSeconds?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? currentRevalidateSeconds : null),
+					currentFetchRevalidate: revalidationConfigRevalidateSeconds,
 					draftModeSecret: options.draftModeSecret,
 					dynamicConfig: revalidationDynamicConfig,
 					params: revalidationTarget.navigationParams,
@@ -309,11 +393,17 @@ async function dispatchAppPageInner(options) {
 				}, async () => {
 					const { renderAppPageCacheArtifacts } = await import("./app-page-cache-render.js");
 					const revalidatedElement = await options.buildPageElement(revalidationTarget.route, revalidationTarget.params, revalidationTarget.interceptOpts, new URLSearchParams(), void 0, {
+						isForceStatic: revalidationDynamicConfig === "force-static",
 						observeMetadataSearchParamsAccess: revalidationDynamicConfig !== "force-static",
 						observePageSearchParamsAccess: revalidationDynamicConfig !== "force-static",
 						serveStreamingMetadata: false
 					});
-					const revalidatedOnError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern);
+					const baseRevalidatedOnError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern, { revalidateReason: "stale" });
+					const baseRevalidatedOnSsrError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern, {
+						renderSource: "server-rendering",
+						revalidateReason: "stale"
+					});
+					revalidationRscErrorTracker = createAppPageRscErrorTracker(baseRevalidatedOnError);
 					const rendered = await renderAppPageCacheArtifacts({
 						basePath: options.basePath,
 						captureRscData: true,
@@ -327,7 +417,12 @@ async function dispatchAppPageInner(options) {
 						loadSsrHandler: options.loadSsrHandler,
 						mountedSlotsHeader: options.mountedSlotsHeader,
 						navigationParams: revalidationTarget.navigationParams,
-						onError: revalidatedOnError,
+						isCapturedRscError: revalidationRscErrorTracker.isCapturedError,
+						onError: revalidationRscErrorTracker.onRenderError,
+						onSsrError(error) {
+							reportedSsrRevalidationErrors.add(error);
+							return baseRevalidatedOnSsrError(error, void 0, void 0);
+						},
 						reactMaxHeadersLength: options.reactMaxHeadersLength,
 						renderToReadableStream: options.renderToReadableStream,
 						rootParams: options.rootParams,
@@ -343,7 +438,9 @@ async function dispatchAppPageInner(options) {
 						rscData: rendered.rscData,
 						rscRenderObservation: rendered.rscRenderObservation,
 						tags: rendered.tags,
-						cacheControl: rendered.cacheControl
+						cacheControl: rendered.cacheControl,
+						revalidateSeconds: revalidationRouteRevalidateSeconds,
+						usedDynamicApi: rendered.usedDynamicApi
 					};
 				});
 			},
@@ -351,7 +448,8 @@ async function dispatchAppPageInner(options) {
 				options.scheduleBackgroundRegeneration(key, renderFn, {
 					routerKind: "App Router",
 					routePath: route.pattern,
-					routeType: "render"
+					routeType: "render",
+					shouldReport: (error) => !reportedSsrRevalidationErrors.has(error) && !revalidationRscErrorTracker?.isCapturedError(error)
 				});
 			}
 		});
@@ -366,15 +464,30 @@ async function dispatchAppPageInner(options) {
 		});
 		if (dynamicParamsResponse) {
 			const renderedNotFound = await options.renderHttpAccessFallbackPage(404, { matchedParams: options.params }, options.middlewareContext);
-			if (renderedNotFound) return renderedNotFound;
+			const cachePolicy = {
+				isDraftMode,
+				isDynamicError,
+				isForceDynamic,
+				isForceStatic,
+				isProduction: options.isProduction,
+				isProgressiveActionRender: options.isProgressiveActionRender === true,
+				isRscRequest: options.isRscRequest,
+				isStaticEligible,
+				middlewareContext: options.middlewareContext,
+				peekDynamicUsage,
+				revalidateSeconds: currentRevalidateSeconds,
+				scriptNonce: options.scriptNonce
+			};
+			if (renderedNotFound) return applyIneligibleRouteCachePolicy(renderedNotFound, cachePolicy);
 			options.clearRequestContext();
-			return dynamicParamsResponse;
+			return applyIneligibleRouteCachePolicy(dynamicParamsResponse, cachePolicy);
 		}
 	}
 	const fallbackShellResponse = options.pprRuntime ? await options.pprRuntime.tryServe(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) : null;
 	if (fallbackShellResponse) return fallbackShellResponse;
 	let interceptDynamicConfig;
 	let interceptDynamicConfigResolved = false;
+	let isInterceptSourceKnownDynamic = false;
 	const interceptResult = await resolveAppPageIntercept({
 		async buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess) {
 			const sourceDynamicConfig = interceptDynamicConfigResolved ? interceptDynamicConfig : options.resolveRouteDynamicConfig?.(interceptRoute);
@@ -388,10 +501,13 @@ async function dispatchAppPageInner(options) {
 					routePattern: interceptRoute.pattern
 				}));
 			} else setHeadersContext(requestHeadersContext);
+			const sourceRevalidateSeconds = options.resolveRouteRevalidateSeconds?.(interceptRoute) ?? null;
+			isInterceptSourceKnownDynamic = sourceDynamicConfig === "force-dynamic" || sourceRevalidateSeconds === 0;
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(interceptRoute) ?? null);
-			setCurrentFetchRevalidate(options.resolveRouteRevalidateSeconds?.(interceptRoute) ?? null);
+			setCurrentFetchRevalidate(sourceRevalidateSeconds);
 			setCurrentForceDynamicFetchDefault(sourceDynamicConfig === "force-dynamic");
 			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess, {
+				isForceStatic: sourceDynamicConfig === "force-static",
 				observeMetadataSearchParamsAccess: sourceDynamicConfig !== "force-static",
 				observePageSearchParamsAccess: sourceDynamicConfig !== "force-static",
 				serveStreamingMetadata: placeGeneratedMetadataInBody
@@ -420,6 +536,7 @@ async function dispatchAppPageInner(options) {
 				"Content-Type": VINEXT_RSC_CONTENT_TYPE,
 				Vary: VINEXT_RSC_VARY_HEADER
 			});
+			if (!(options.pprRuntime !== void 0 || options.resolveRouteStaticEligible(sourceRoute)) || isDraftMode || isInterceptSourceKnownDynamic) interceptHeaders.set("Cache-Control", resolveUncacheableCacheControl(options.isProduction));
 			mergeMiddlewareResponseHeaders(interceptHeaders, options.middlewareContext.headers);
 			applyRscCompatibilityIdHeader(interceptHeaders);
 			applyRscDeploymentIdHeader(interceptHeaders);
@@ -445,6 +562,7 @@ async function dispatchAppPageInner(options) {
 		buildPageElement() {
 			if (options.actionFailed) throw options.actionError;
 			return options.buildPageElement(route, options.params, interceptResult.interceptOpts, pageSearchParams, layoutParamAccess, {
+				isForceStatic,
 				observeMetadataSearchParamsAccess: !isForceStatic,
 				observePageSearchParamsAccess: !isForceStatic,
 				serveStreamingMetadata: placeGeneratedMetadataInBody
@@ -452,12 +570,13 @@ async function dispatchAppPageInner(options) {
 		},
 		async probePageSpecialError() {
 			if (hasActiveLoadingBoundary) return null;
-			return resolveAppPageSpecialError(await probeAppPageThrownError({
+			const pageError = await probeAppPageThrownError({
 				probePage: () => options.probePage(pageSearchParams),
 				runWithSuppressedHookWarning(probe) {
 					return options.runWithSuppressedHookWarning(probe);
 				}
-			}));
+			});
+			return resolveAppPageSpecialError(pageError);
 		},
 		renderErrorBoundaryPage(buildError) {
 			return options.renderErrorBoundaryPage(buildError);
@@ -479,14 +598,7 @@ async function dispatchAppPageInner(options) {
 		});
 		discardAppPageRenderState();
 	}
-	const pageBuildResult = await buildCurrentPageElement();
-	if (pageBuildResult.response) return pageBuildResult.response;
 	const navigationParams = resolveAppPageNavigationParams(route, options.params, options.cleanPathname, interceptResult.interceptOpts);
-	options.setNavigationContext({
-		pathname: options.displayPathname ?? options.cleanPathname,
-		searchParams: pageSearchParams,
-		params: navigationParams
-	});
 	const layoutClassifications = getEffectiveLayoutClassifications(route, options.debugClassification);
 	const activeFallbackShellState = options.pprRuntime?.getState() ?? null;
 	const pprFallbackShellSignal = activeFallbackShellState?.abortController.signal;
@@ -495,6 +607,7 @@ async function dispatchAppPageInner(options) {
 	const requestCacheLife = _captureRequestScopedCacheLifeAccessors();
 	return renderAppPageLifecycle({
 		basePath: options.basePath,
+		bypassInterceptionContextCache: options.bypassInterceptionContextCache,
 		clientTraceMetadata: options.clientTraceMetadata,
 		reactMaxHeadersLength: options.reactMaxHeadersLength,
 		cleanPathname: options.cleanPathname,
@@ -503,10 +616,19 @@ async function dispatchAppPageInner(options) {
 		peekDynamicUsage,
 		consumeInvalidDynamicUsageError,
 		consumeRenderObservationState: consumeAppPageRenderObservationState,
-		createRscOnErrorHandler(pathname, routePath) {
-			return options.createRscOnErrorHandler(pathname, routePath);
+		createRscOnErrorHandler(pathname, routePath, overrides) {
+			return options.createRscOnErrorHandler(pathname, routePath, overrides);
+		},
+		async prepareElement() {
+			const pageBuildResult = await buildCurrentPageElement();
+			if (pageBuildResult.response) return { response: pageBuildResult.response };
+			options.setNavigationContext({
+				pathname: options.displayPathname ?? options.cleanPathname,
+				searchParams: pageSearchParams,
+				params: navigationParams
+			});
+			return { element: pageBuildResult.element };
 		},
-		element: pageBuildResult.element,
 		clientReuseManifest: options.clientReuseManifest,
 		getDraftModeCookieHeader,
 		getFontLinks: options.getFontLinks,
@@ -524,7 +646,7 @@ async function dispatchAppPageInner(options) {
 		},
 		handlerStart: options.handlerStart,
 		hasLoadingBoundary: hasActiveLoadingBoundary,
-		omitPendingDynamicCacheState: hasRequestSearchParams,
+		omitPendingDynamicCacheState: hasRequestSearchParams && !(isCacheCandidate && !options.isRscRequest),
 		formState: options.formState ?? null,
 		isProgressiveActionRender: options.isProgressiveActionRender === true,
 		isDynamicError,
@@ -532,10 +654,13 @@ async function dispatchAppPageInner(options) {
 		isForceDynamic,
 		isForceStatic,
 		isEdgeRuntime: options.isEdgeRuntime === true,
+		isStaticEligible,
+		isCacheCandidate,
 		isPrerender,
 		isSpeculativePrerender,
 		isProduction: options.isProduction,
 		isRscRequest: options.isRscRequest,
+		traceOperation,
 		isrDebug: options.isrDebug,
 		isrHtmlKey: options.isrHtmlKey,
 		isrRscKey: options.isrRscKey,