vinext 1.3.0 → 1.4.0

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

@@ -1,3 +1,4 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { NEXTJS_CACHE_HEADER, VINEXT_CACHE_HEADER } from "./headers.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { captureRouteCacheabilityResponsePolicy, deferRouteCacheability, isRouteCacheabilityEvaluation } from "../shims/cacheability-classification.js";
@@ -6,7 +7,6 @@ import { buildAppPageCacheValue, isrCacheControl, resolveRouteExpireSeconds } fr
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
 import { readStreamAsText } from "../utils/text-stream.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 import { hasQueryInvariantRenderProof } from "./cache-proof.js";
 import { createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
@@ -67,55 +67,79 @@ function applyRscRenderStatus(outcome, renderStatus) {
 		...renderStatus.headers ? { headers: renderStatus.headers } : {}
 	};
 }
+/** Hand an adapter the document; its failure never holds back admission. */
+function settleAdmittedDocument(capture, document) {
+	try {
+		capture?.(document);
+	} catch (error) {
+		console.error("[vinext] CDN adapter document capture error:", error);
+	}
+}
 function finalizeEvaluatedAppPageResponse(response, options) {
 	if (!isRouteCacheabilityEvaluation()) return null;
 	const complete = deferRouteCacheability();
-	if (!complete) return response;
+	if (!complete) {
+		settleAdmittedDocument(options.captureAdmittedDocument, null);
+		return response;
+	}
 	captureRouteCacheabilityResponsePolicy(captureCdnResponsePolicyHeaders(response.headers));
+	const admit = (renderStatus) => {
+		const observationState = options.consumeRenderObservationState?.();
+		const cacheControl = resolveAppPageCacheControl({
+			expireSeconds: options.expireSeconds,
+			requestCacheLife: options.getRequestCacheLife?.(),
+			revalidateSeconds: options.revalidateSeconds
+		});
+		const outcome = cacheControl ? {
+			cacheable: true,
+			cacheControl: appPageCacheControlHeader(cacheControl),
+			...observationState && !observationState.requestApis.includes("searchParams") ? { searchParamsUnread: true } : {},
+			...cacheControl.stale !== void 0 ? { staleTimeSeconds: cacheControl.stale } : {},
+			tags: options.getPageTags()
+		} : {
+			cacheable: false,
+			reason: "render did not produce a cache policy"
+		};
+		const admitted = renderStatus ? applyRscRenderStatus(outcome, renderStatus) : outcome;
+		settleAdmittedDocument(options.captureAdmittedDocument, admitted.cacheable && admitted.searchParamsUnread === true && renderStatus?.kind === "page" ? renderStatus.document ?? null : null);
+		complete(admitted);
+	};
 	let completed = false;
 	const finish = () => {
 		if (completed) return;
 		completed = true;
-		const observationState = options.consumeRenderObservationState?.();
-		let outcome;
-		if (options.capturedDynamicUsageBeforeContextCleanup?.() === true || options.consumeDynamicUsage()) outcome = {
+		let ineligible;
+		if (options.capturedDynamicUsageBeforeContextCleanup?.() === true || options.consumeDynamicUsage()) ineligible = {
 			cacheable: false,
 			dynamicUsage: true,
 			reason: "dynamic API used during render"
 		};
-		else if (options.isStaticEligible === false) outcome = {
+		else if (options.isStaticEligible === false) ineligible = {
 			cacheable: false,
 			reason: "route is not statically generated"
 		};
-		else if (response.headers.has("set-cookie") || hasExplicitNonCacheableResponsePolicy(response.headers)) outcome = {
+		else if (response.headers.has("set-cookie") || hasExplicitNonCacheableResponsePolicy(response.headers)) ineligible = {
 			cacheable: false,
 			reason: "response explicitly opts out of shared caching"
 		};
-		else {
-			const cacheControl = resolveAppPageCacheControl({
-				expireSeconds: options.expireSeconds,
-				requestCacheLife: options.getRequestCacheLife?.(),
-				revalidateSeconds: options.revalidateSeconds
-			});
-			outcome = cacheControl ? {
-				cacheable: true,
-				cacheControl: appPageCacheControlHeader(cacheControl),
-				...observationState && !observationState.requestApis.includes("searchParams") ? { searchParamsUnread: true } : {},
-				tags: options.getPageTags()
-			} : {
-				cacheable: false,
-				reason: "render did not produce a cache policy"
-			};
+		if (ineligible) {
+			options.consumeRenderObservationState?.();
+			settleAdmittedDocument(options.captureAdmittedDocument, null);
+			complete(ineligible);
+			return;
 		}
-		if (outcome.cacheable && options.resolveRscRenderStatus) {
-			const cacheableOutcome = outcome;
-			options.resolveRscRenderStatus().then((renderStatus) => complete(applyRscRenderStatus(cacheableOutcome, renderStatus)), () => complete({
-				cacheable: false,
-				reason: "render status could not be resolved"
-			}));
+		if (!options.resolveRscRenderStatus) {
+			admit();
 			return;
 		}
-		complete(outcome);
+		options.resolveRscRenderStatus().then(admit, () => {
+			options.consumeRenderObservationState?.();
+			settleAdmittedDocument(options.captureAdmittedDocument, null);
+			complete({
+				cacheable: false,
+				reason: "render status could not be resolved"
+			});
+		});
 	};
 	if (!response.body) {
 		finish();
@@ -230,6 +254,7 @@ function finalizeAppPageRscCacheResponse(response, options) {
 		options.capturedRscDataPromise?.catch(() => {});
 		return probeResponse;
 	}
+	settleAdmittedDocument(options.captureAdmittedDocument, null);
 	scheduleAppPageRscCacheWrite(options);
 	const isUncacheableVariant = Boolean(options.mountedSlotsHeader) || options.bypassInterceptionContextCache === true;
 	if (options.preserveClientResponseHeaders === true && !isUncacheableVariant) return response;
@@ -253,6 +278,7 @@ function scheduleAppPageRscCacheWrite(options) {
 				options.isrDebug?.("RSC cache write skipped (dynamic usage during render)", rscKey);
 				return;
 			}
+			const renderStatus = await options.resolveRscRenderStatus?.() ?? { kind: "page" };
 			const cacheControl = resolveAppPageCacheControl({
 				expireSeconds: options.expireSeconds,
 				requestCacheLife: options.getRequestCacheLife?.(),
@@ -272,7 +298,6 @@ function scheduleAppPageRscCacheWrite(options) {
 				options.isrDebug?.("RSC cache write skipped (searchParams not proven unread)", rscKey);
 				return;
 			}
-			const renderStatus = await options.resolveRscRenderStatus?.() ?? { kind: "page" };
 			if (renderStatus.kind === "unstorable") {
 				options.isrDebug?.("RSC cache write skipped (unstorable special error)", rscKey);
 				return;
@@ -282,6 +307,22 @@ function scheduleAppPageRscCacheWrite(options) {
 				tags: pageTags
 			});
 			options.isrDebug?.("RSC cache written", rscKey);
+			const document = renderStatus.kind === "page" ? renderStatus.document : void 0;
+			if (!document || !options.isrHtmlKey || !options.createHtmlRenderObservation) return;
+			const htmlKey = options.isrHtmlKey(options.cleanPathname);
+			const htmlRenderObservation = options.createHtmlRenderObservation({
+				cacheTags: pageTags,
+				state: observationState
+			});
+			if (!hasQueryInvariantRenderProof(htmlRenderObservation)) {
+				options.isrDebug?.("HTML cache write skipped (searchParams not proven unread)", htmlKey);
+				return;
+			}
+			await options.isrSet(htmlKey, buildAppPageCacheValue(document.html, void 0, 200, htmlRenderObservation, document.linkHeader ? { link: document.linkHeader } : void 0), {
+				cacheControl,
+				tags: pageTags
+			});
+			options.isrDebug?.("HTML cache written", htmlKey);
 		} catch (cacheError) {
 			console.error("[vinext] ISR RSC cache write error:", cacheError);
 		}

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

@@ -35,7 +35,14 @@ export type RenderAppPageCacheArtifactsOptions = {
    * Render the document of a special error that rejected the shell, or return
    * null to fail the render with it.
    */
-  renderShellSpecialError?: (error: unknown) => Promise<AppPageCacheSpecialErrorDocument | null>;
+  renderShellSpecialError?: (error: unknown,
+  /** The page's own document, in which parallel slot boundaries caught it. */
+  caughtDocument?: {
+    html: string;
+    linkHeader?: string;
+  }) => Promise<AppPageCacheSpecialErrorDocument | null>;
+  /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
+  resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
   renderToReadableStream: (element: AppPageRenderableElement, options: {
     onError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
   }) => ReadableStream<Uint8Array>;
@@ -73,4 +80,5 @@ export type RenderAppPageCacheArtifactsResult = {
  * shell regeneration.
  */
 export declare function renderAppPageCacheArtifacts(options: RenderAppPageCacheArtifactsOptions): Promise<RenderAppPageCacheArtifactsResult>;
-//#endregion
+//#endregion
+export {};

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

@@ -5,9 +5,9 @@ import { getCollectedFetchTags } from "../shims/fetch-cache.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { buildAppPageFontLinkHeader, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
 import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
-import { buildAppPageTags } from "./implicit-tags.js";
-import { consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
 import { buildAppPageLinkHeader, createAppPageSsrErrorHandler, isAppSsrRenderResult } from "./app-page-stream.js";
+import { consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.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
@@ -44,6 +44,7 @@ async function renderAppPageCacheArtifactsImpl(options, renderSpan) {
 			isStaticGeneration: true,
 			isForceStatic: options.isForceStatic,
 			preloadRoutePattern: options.route.pattern,
+			resolveCaughtNotFoundBoundaries: options.resolveCaughtNotFoundBoundaries,
 			onSsrError: options.onSsrError && options.isCapturedRscError ? createAppPageSsrErrorHandler((error) => {
 				recordAppPageRenderError(renderSpan, error);
 				return options.onSsrError?.(error);
@@ -69,6 +70,17 @@ async function renderAppPageCacheArtifactsImpl(options, renderSpan) {
 		const reactLinkHeader = isAppSsrRenderResult(htmlResult) ? htmlResult.linkHeader : void 0;
 		linkHeader = buildAppPageLinkHeader(reactLinkHeader, buildAppPageFontLinkHeader(fontPreloads), options.reactMaxHeadersLength);
 		html = await readStreamAsText(htmlStream);
+		const caughtShellError = isAppSsrRenderResult(htmlResult) ? htmlResult.caughtShellError : void 0;
+		if (caughtShellError !== void 0) {
+			await capturedRscDataRef.value?.catch(() => {});
+			specialErrorDocument = await options.renderShellSpecialError?.(caughtShellError, {
+				html,
+				linkHeader
+			}) ?? null;
+			if (!specialErrorDocument) throw caughtShellError;
+			html = specialErrorDocument.html;
+			linkHeader = specialErrorDocument.linkHeader;
+		}
 	}
 	let rscData;
 	if (options.captureRscData) {

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

@@ -83,7 +83,19 @@ type ReadAppPageCacheResponseOptions = {
   renderMode?: AppRscRenderMode;
   expireSeconds?: number;
   revalidateSeconds: number;
-  renderFreshPageForCache: () => Promise<AppPageCacheRenderResult>;
+  /**
+   * Whether this is an RSC request Next.js renders dynamically under PPR (one
+   * that is not a prefetch, for a path not generated at build time), and so
+   * never regenerates the page's document.
+   */
+  isDynamicRscRequest?: boolean;
+  /**
+   * Renders the page for its cache entries. `renderDocument` asks for the
+   * document as an HTML request renders it, to be stored beside the RSC payload.
+   */
+  renderFreshPageForCache: (options: {
+    renderDocument: boolean;
+  }) => Promise<AppPageCacheRenderResult>;
   scheduleBackgroundRegeneration: AppPageBackgroundRegenerator;
 };
 type ReadAppPageFallbackShellCacheResponseOptions = {

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

@@ -6,14 +6,14 @@ import { buildAppPageCacheValue, isrCacheControl, resolveRouteExpireSeconds } fr
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
 import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
-import { applyClientStaleTimeHeader, applyEdgeRuntimeHeader } from "./app-page-response.js";
-import { hasQueryInvariantRenderProof } from "./cache-proof.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { isAppPprDynamicFallbackShellHtml } from "./app-ppr-fallback-shell.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
+import { hasQueryInvariantRenderProof } from "./cache-proof.js";
+import { applyClientStaleTimeHeader, applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, scheduleAppPageRscCacheWrite } from "./app-page-cache-finalizer.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
 //#region src/server/app-page-cache.ts
 function recordAppPageCacheOutcome(recordCacheOutcome, input) {
 	try {
@@ -92,6 +92,25 @@ function resolveRegenerationFailureCacheControl(previous) {
 		...previous.stale === void 0 ? {} : { stale: previous.stale }
 	};
 }
+/**
+* Next.js stamps every prerender with the stale time it collected. A render
+* that made no `cacheLife` claim keeps the `INFINITE_CACHE` sentinel, which
+* resolves to `experimental.staleTimes.static` (`createSelectStaleTime` in
+* `server/app-render/stale-time.ts`, applied by
+* `applyMetadataFromPrerenderResult` in `app-render.tsx`). Its client only
+* caches a navigation response for that long under
+* `experimental.cachedNavigations` (`fetch-server-response.ts`); otherwise the
+* value only dates prefetches. vinext's client reuses navigation responses for
+* any advertised stale time, so the unclaimed value is only advertised when
+* cached navigations are on.
+*/
+function resolveUnclaimedPrerenderStaleTimeSeconds(isRoutePPREnabled) {
+	if (isRoutePPREnabled !== true) return void 0;
+	if (String(process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS) !== "true") return void 0;
+	const raw = process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME;
+	const seconds = raw === void 0 || raw === "" ? 300 : Number(raw);
+	return Number.isFinite(seconds) && seconds >= 0 ? Math.floor(seconds) : void 0;
+}
 function isRedirectStatus(status) {
 	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
 }
@@ -108,7 +127,7 @@ function buildAppPageCachedResponse(cachedValue, options) {
 		expireSeconds: options.expireSeconds,
 		cacheControlMeta: options.cacheControl
 	});
-	const staleTimeSeconds = resolveClientStaleTimeSeconds(options.cacheControl);
+	const staleTimeSeconds = resolveClientStaleTimeSeconds(options.cacheControl) ?? resolveUnclaimedPrerenderStaleTimeSeconds(options.isRoutePPREnabled);
 	if (options.isRscRequest) {
 		if (!cachedValue.rscData) return null;
 		const rscHeaders = buildAppPageCachedHeaders({
@@ -276,8 +295,10 @@ async function readAppPageCacheResponse(options) {
 					console.error(`[vinext] Failed to keep the previous entry for ${key}:`, storeError);
 				}
 			};
+			const regeneratesDocument = !options.isRscRequest || options.isDynamicRscRequest !== true && isrKey === options.isrRscKey(options.cleanPathname, null);
+			const htmlKey = options.isRscRequest ? regeneratesDocument ? options.isrHtmlKey(options.cleanPathname) : null : isrKey;
 			const regenerate = async () => {
-				const revalidatedPage = await options.renderFreshPageForCache();
+				const revalidatedPage = await options.renderFreshPageForCache({ renderDocument: regeneratesDocument });
 				const cacheControl = resolveRegeneratedAppPageCacheControl({
 					expireSeconds: options.expireSeconds,
 					renderCacheControl: revalidatedPage.cacheControl,
@@ -285,7 +306,8 @@ async function readAppPageCacheResponse(options) {
 				});
 				if (options.isRoutePPREnabled !== true && (revalidatedPage.usedDynamicApi || cacheControl.revalidate === 0)) throw new Error(`Page changed from static to dynamic at runtime ${options.cleanPathname}
 see more here https://nextjs.org/docs/messages/app-static-to-dynamic-error`);
-				if (!hasQueryInvariantRenderProof(revalidatedPage.rscRenderObservation) || !options.isRscRequest && !hasQueryInvariantRenderProof(revalidatedPage.htmlRenderObservation)) {
+				const documentKey = options.isRscRequest && revalidatedPage.html === "" ? null : htmlKey;
+				if (!hasQueryInvariantRenderProof(revalidatedPage.rscRenderObservation) || documentKey !== null && !hasQueryInvariantRenderProof(revalidatedPage.htmlRenderObservation)) {
 					options.isrDebug?.("regen write skipped (searchParams not proven unread)", isrKey);
 					return;
 				}
@@ -304,15 +326,15 @@ see more here https://nextjs.org/docs/messages/app-static-to-dynamic-error`);
 				};
 				const status = revalidatedPage.status ?? 200;
 				if (!await store(rscKey, buildAppPageCacheValue("", revalidatedPage.rscData, status, revalidatedPage.rscRenderObservation, revalidatedPage.headers))) return;
-				if (!options.isRscRequest) {
-					if (!await store(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, status, revalidatedPage.htmlRenderObservation, revalidatedPage.linkHeader ? {
+				if (documentKey !== null) {
+					if (!await store(documentKey, buildAppPageCacheValue(revalidatedPage.html, void 0, status, revalidatedPage.htmlRenderObservation, revalidatedPage.linkHeader ? {
 						...revalidatedPage.headers,
 						link: revalidatedPage.linkHeader
 					} : revalidatedPage.headers))) return;
 				}
 				options.isrDebug?.("regen complete", options.cleanPathname);
 			};
-			options.scheduleBackgroundRegeneration(isrKey, async () => {
+			options.scheduleBackgroundRegeneration(htmlKey ?? isrKey, async () => {
 				try {
 					await regenerate();
 				} catch (error) {

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

@@ -1,13 +1,11 @@
-import { ClassificationReason } from "../build/layout-classification-types.js";
-import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation.js";
-import { AppPageFontPreload, LayoutClassificationOptions } from "./app-page-execution.js";
+import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
+import { AppPageFallbackRouteHead, AppPagePreparedRouteHead } from "./app-page-head.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
@@ -43,8 +41,16 @@ type AppPageDispatchIntercept<TPage = unknown> = {
   interceptLoadings?: readonly unknown[] | null;
   interceptLoadingTreePositions?: readonly number[] | null;
   interceptNotFoundBranchSegments?: readonly string[] | null;
+  interceptNotFounds?: readonly unknown[] | null;
+  interceptNotFoundTreePositions?: readonly number[] | null;
   notFound?: unknown;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[] | null;
+  interceptForbiddenTreePositions?: readonly number[] | null;
+  interceptUnauthorizeds?: readonly unknown[] | null;
+  interceptUnauthorizedTreePositions?: readonly number[] | null;
+  interceptErrors?: readonly unknown[] | null;
+  interceptErrorTreePositions?: readonly number[] | null;
   matchedParams: AppPageParams;
   sourceMatchedParams?: AppPageParams;
   page: TPage;
@@ -67,6 +73,14 @@ type AppPageDispatchInterceptOptions<TPage = unknown> = {
   interceptNotFoundBranchSegments?: readonly string[] | null;
   interceptNotFound?: unknown;
   interceptNotFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[] | null;
+  interceptForbiddenTreePositions?: readonly number[] | null;
+  interceptUnauthorizeds?: readonly unknown[] | null;
+  interceptUnauthorizedTreePositions?: readonly number[] | null;
+  interceptErrors?: readonly unknown[] | null;
+  interceptErrorTreePositions?: readonly number[] | null;
+  interceptNotFounds?: readonly unknown[] | null;
+  interceptNotFoundTreePositions?: readonly number[] | null;
   interceptPage: TPage;
   interceptParams: AppPageParams;
   interceptSlotId?: string | null;
@@ -90,8 +104,6 @@ type AppPageDispatchSlot = {
   slotParamNames?: readonly string[] | null;
 };
 export type AppPageDispatchRoute = {
-  __buildTimeClassifications?: LayoutClassificationOptions["buildTimeClassifications"];
-  __buildTimeReasons?: LayoutClassificationOptions["buildTimeReasons"];
   error?: AppPageModule | null;
   errors?: readonly (AppPageModule | null | undefined)[];
   forbidden?: AppPageModule | null;
@@ -108,6 +120,12 @@ export type AppPageDispatchRoute = {
   params: readonly string[];
   pattern: string;
   routeSegments: readonly string[];
+  segmentForbiddens?: readonly (AppPageModule | null | undefined)[];
+  segmentForbiddenTreePositions?: readonly number[];
+  segmentNotFounds?: readonly (AppPageModule | null | undefined)[];
+  segmentNotFoundTreePositions?: readonly number[];
+  segmentUnauthorizeds?: readonly (AppPageModule | null | undefined)[];
+  segmentUnauthorizedTreePositions?: readonly number[];
   slots?: Readonly<Record<string, AppPageDispatchSlot>>;
   unauthorized?: AppPageModule | null;
   unauthorizedTreePosition?: number | null;
@@ -138,19 +156,22 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
    * `next.config`. Undefined falls back to the React default downstream.
    */
   reactMaxHeadersLength?: number;
-  buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker, options?: {
+  buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, options?: {
     isForceStatic?: boolean;
+    isUncacheableRender?: boolean;
+    /** Layouts the navigating client holds, which the render may leave out. */
+    mountedLayouts?: ReadonlySet<string> | null;
     observeMetadataSearchParamsAccess?: boolean;
     observePageSearchParamsAccess?: boolean;
     serveStreamingMetadata?: boolean;
     placeStreamedMetadataInHead?: boolean;
+    /** Receives the route's head once the render starts resolving it. */
+    onHeadPrepared?: (head: AppPagePreparedRouteHead) => void;
   }) => Promise<AppPageElement>;
-  clientReuseManifest?: ClientReuseManifestParseResult;
   cleanPathname: string;
   displayPathname?: string;
   clearRequestContext: () => void;
   createRscOnErrorHandler: (pathname: string, routePath: string, overrides?: AppRenderErrorContextOverrides) => AppPageBoundaryOnError;
-  debugClassification?: (layoutId: string, reason: ClassificationReason) => void;
   draftModeSecret: string;
   dynamicConfig?: string;
   dynamicStaleTimeSeconds?: number;
@@ -223,17 +244,23 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   skipStaticParamsValidation?: boolean;
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
-  probeLayoutAt: (layoutIndex: number, layoutParamAccess?: AppLayoutParamAccessTracker) => unknown;
+  probeLayoutAt: (layoutIndex: number) => unknown;
   expireSeconds?: number;
   renderErrorBoundaryPage: (error: unknown, errorOrigin?: "rsc" | "ssr") => Promise<Response | null>;
   renderHttpAccessFallbackPage: (statusCode: number, opts: {
     boundaryComponent?: unknown;
     boundaryModule?: AppPageModule | null;
+    /** Boundary whose metadata the head uses, when not `boundaryModule`. */
+    headBoundaryModule?: AppPageModule | null;
+    /** Layouts whose metadata the head uses, when more than `layouts`. */
+    headLayouts?: readonly AppPageModule[];
     intercept?: AppPageDispatchInterceptOptions | null;
     /** The document may be stored, so it must not carry the request's query. */
     isCacheCandidate?: boolean;
     layouts?: readonly AppPageModule[];
     matchedParams: AppPageParams;
+    /** The route's render threw the signal, so the document keeps the route's head. */
+    routeHead?: AppPageFallbackRouteHead;
   }, middlewareContext: AppPageMiddlewareContext | null) => Promise<Response | null>;
   renderToReadableStream: (element: AppPageRenderableElement, options: {
     onError: AppPageBoundaryOnError;
@@ -290,4 +317,5 @@ export declare function shouldReadAppPageCache(options: {
 }): boolean;
 export declare function hasSearchParams(searchParams: URLSearchParams | null | undefined): boolean;
 export declare function dispatchAppPage<TRoute extends AppPageDispatchRoute>(options: DispatchAppPageOptions<TRoute>): Promise<Response>;
-//#endregion
+//#endregion
+export {};