vinext 1.3.1 → 1.4.0

package/dist/server/app-mounted-layouts.js

@@ -0,0 +1,67 @@
+import { fnv1a64 } from "../utils/hash.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+//#region src/server/app-mounted-layouts.ts
+/**
+* A client navigation names the layouts it already holds, so a render that's
+* never stored can leave them out, as Next.js leaves out the segments above
+* where a navigation diverges from its router state tree.
+*
+* Each entry hashes a layout's segment identity, which binds the layout to its
+* route prefix and that prefix's params, so a layout whose params changed never
+* matches.
+*/
+const MAX_MOUNTED_LAYOUTS = 64;
+const MOUNTED_LAYOUT_HASH = /^[0-9a-f]{16}$/;
+function hashMountedLayoutIdentity(identity) {
+	return fnv1a64(identity);
+}
+function serializeMountedLayouts(identities) {
+	if (identities.length === 0) return null;
+	return identities.slice(0, MAX_MOUNTED_LAYOUTS).map(hashMountedLayoutIdentity).join(",");
+}
+function parseMountedLayoutsHeader(value) {
+	if (!value) return null;
+	const hashes = /* @__PURE__ */ new Set();
+	for (const entry of value.split(",", 65)) {
+		const hash = entry.trim();
+		if (!MOUNTED_LAYOUT_HASH.test(hash)) return null;
+		hashes.add(hash);
+	}
+	if (hashes.size === 0 || hashes.size > MAX_MOUNTED_LAYOUTS) return null;
+	return hashes;
+}
+/**
+* The header for the outermost layouts a client state holds. Only that prefix
+* can be left out of a render, as a layout below one that re-renders renders
+* inside it.
+*/
+function createMountedLayoutsHeader(elements, layoutIds) {
+	const identities = AppElementsWire.readMetadata(elements).bfcacheSegmentIdentities;
+	const held = [];
+	for (const layoutId of layoutIds) {
+		const identity = identities[layoutId];
+		if (identity === void 0 || !Object.hasOwn(elements, layoutId)) break;
+		held.push(identity);
+	}
+	return serializeMountedLayouts(held);
+}
+/**
+* Whether a client state still holds, unchanged, every layout a payload left
+* out. A navigation that started from another state, or a payload stored for
+* another client, can name layouts this one doesn't hold.
+*/
+function holdsSkippedLayouts(current, next) {
+	const nextMetadata = AppElementsWire.readMetadata(next);
+	if (nextMetadata.skippedLayoutIds.length === 0) return true;
+	const currentIdentities = AppElementsWire.readMetadata(current.elements).bfcacheSegmentIdentities;
+	const currentLayoutIds = new Set(current.layoutIds);
+	for (const layoutId of nextMetadata.skippedLayoutIds) {
+		if (!currentLayoutIds.has(layoutId) || !Object.hasOwn(current.elements, layoutId)) return false;
+		const identity = nextMetadata.bfcacheSegmentIdentities[layoutId];
+		if (identity === void 0 || identity !== currentIdentities[layoutId]) return false;
+	}
+	return true;
+}
+//#endregion
+export { createMountedLayoutsHeader, hashMountedLayoutIdentity, holdsSkippedLayouts, parseMountedLayoutsHeader };

package/dist/server/app-optimistic-routing.d.ts

@@ -1,7 +1,7 @@
 import { BrowserRouteManifest, BrowserRouteManifestRoute } from "../routing/browser-route-manifest.js";
-import { OptimisticRouteTrieMatch } from "../routing/optimistic-route-trie.js";
 import { AppElements } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { OptimisticRouteTrieMatch } from "../routing/optimistic-route-trie.js";
 //#region src/server/app-optimistic-routing.d.ts
 type OptimisticRouteMatch = OptimisticRouteTrieMatch<BrowserRouteManifestRoute>;
 export type OptimisticRouteTemplate = {
@@ -90,5 +90,23 @@ export declare function resolveOptimisticNavigationPayload(options: {
   routeManifest: BrowserRouteManifest;
   templates: ReadonlyMap<string, OptimisticRouteTemplate>;
 }): OptimisticNavigationPayload | null;
+export type LearnedOptimisticRouteTemplate = {
+  key: string;
+  template: OptimisticRouteTemplate;
+};
+/**
+ * Optimistic route templates and the prefetch sources they were learned from.
+ * `clear()` retires every template, so none can outlive the prefetch payload
+ * it was derived from, and drops any result a learning started before the
+ * clear resolves to. Sources that are still cached are learned again on the
+ * next optimistic navigation.
+ */
+export declare function createOptimisticRouteTemplateStore(): {
+  templates: ReadonlyMap<string, OptimisticRouteTemplate>;
+  clear(): void;
+  hasSource(sourceKey: string): boolean;
+  learn(sourceKey: string, learnTemplate: () => Promise<LearnedOptimisticRouteTemplate | null>): Promise<void>;
+  pendingLearning(): Promise<void>[];
+};
 //#endregion
 export {};

package/dist/server/app-optimistic-routing.js

@@ -3,10 +3,10 @@ import { stripBasePath } from "../utils/base-path.js";
 import { decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { extractRawRoutePatternParams, matchRoutePattern } from "../routing/route-pattern.js";
 import { buildOptimisticRouteTrie, matchOptimisticRouteTrie } from "../routing/optimistic-route-trie.js";
+import { stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { createNestedBfcacheSlotSegmentId, deriveBfcacheSegmentIdentity, isNestedBfcacheSlotSegmentId } from "./bfcache-identity.js";
-import { stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { canonicalizeAppPageParams, resolveAppPagePatternStateKey, resolveAppPageSemanticSegmentStateKey } from "./app-page-segment-state.js";
 import { Suspense, createElement, isValidElement } from "react";
 //#region src/server/app-optimistic-routing.ts
@@ -310,5 +310,45 @@ function resolveOptimisticNavigationPayload(options) {
 		urlParts: urlParts.normalized
 	};
 }
+/**
+* Optimistic route templates and the prefetch sources they were learned from.
+* `clear()` retires every template, so none can outlive the prefetch payload
+* it was derived from, and drops any result a learning started before the
+* clear resolves to. Sources that are still cached are learned again on the
+* next optimistic navigation.
+*/
+function createOptimisticRouteTemplateStore() {
+	const templates = /* @__PURE__ */ new Map();
+	const learnedSources = /* @__PURE__ */ new Set();
+	const learning = /* @__PURE__ */ new Map();
+	let generation = 0;
+	return {
+		templates,
+		clear() {
+			generation += 1;
+			templates.clear();
+			learnedSources.clear();
+			learning.clear();
+		},
+		hasSource(sourceKey) {
+			return learnedSources.has(sourceKey) || learning.has(sourceKey);
+		},
+		learn(sourceKey, learnTemplate) {
+			const learnedGeneration = generation;
+			const promise = learnTemplate().then((learned) => {
+				if (learned === null || learnedGeneration !== generation) return;
+				templates.set(learned.key, learned.template);
+				learnedSources.add(sourceKey);
+			}).finally(() => {
+				if (learning.get(sourceKey) === promise) learning.delete(sourceKey);
+			});
+			learning.set(sourceKey, promise);
+			return promise;
+		},
+		pendingLearning() {
+			return [...learning.values()];
+		}
+	};
+}
 //#endregion
-export { canCommitOptimisticRouteTemplate, createOptimisticRouteElements, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, keepOptimisticStreamingMetadata, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationParamsForHref, resolveOptimisticNavigationPayload };
+export { canCommitOptimisticRouteTemplate, createOptimisticRouteElements, createOptimisticRouteTemplate, createOptimisticRouteTemplateStore, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, keepOptimisticStreamingMetadata, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationParamsForHref, resolveOptimisticNavigationPayload };

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

@@ -2,26 +2,26 @@ import { stripBasePath } from "../utils/base-path.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
 import { isRenderDynamicLatched, isStaticGenerationAccessError } from "../shims/internal/headers-state.js";
+import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
+import { stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { createArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { ErrorBoundary, GlobalErrorBoundary, SerializedErrorBoundary } from "../shims/error-boundary.js";
+import { buildClientHookErrorMessage } from "../shims/client-hook-error.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { withUseCacheLayoutMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { MetadataHead, ViewportHead } from "../shims/metadata.js";
-import { stripRscSuffix } from "./app-rsc-cache-busting.js";
-import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
 import { buildRscRedirectFlightStream } from "./app-rsc-redirect-flight.js";
 import { bufferAppPageBinaryStream, buildAppPageSpecialErrorResponse, resolveAppPageSpecialError } from "./app-page-execution.js";
-import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
-import { createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage } from "./app-page-route-wiring.js";
-import { buildClientHookErrorMessage } from "../shims/client-hook-error.js";
 import { createAppPageMetadataSearchParamsObserver } from "./app-page-search-params-observation.js";
-import { hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, slotInterceptKeepsSourceHead } from "./app-page-head.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, resolveInterceptLayoutsBesidePage, slotInterceptKeepsSourceHead } from "./app-page-head.js";
 import { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryModule, wrapAppPageBoundaryElement } from "./app-page-boundary.js";
 import { createRouteNotFoundHeadPlanOptions, recoverAppPageRouteHead, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport } from "./app-page-http-access-fallback-metadata.js";
 import "./app-rsc-route-matching.js";
+import { createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage } from "./app-page-route-wiring.js";
 import { resolveSlotParamOverrides } from "./app-page-element-builder.js";
 import { createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlResponse } from "./app-page-stream.js";
 import { Fragment, Suspense, createElement } from "react";
@@ -301,6 +301,7 @@ async function renderAppPageHttpAccessFallback(options) {
 				head: {
 					layoutModules: intercept?.interceptLayouts ?? [],
 					layoutParams: (intercept?.interceptLayoutSegments ?? []).map((layoutSegments) => resolveAppPageBranchParams(intercept?.interceptBranchSegments ?? layoutSegments, layoutSegments.length, effectiveParams, layoutSegments)),
+					layoutsBesidePage: resolveInterceptLayoutsBesidePage(intercept?.interceptLayoutSegments, intercept?.interceptBranchSegments),
 					pageModule: intercept?.interceptPage ?? null,
 					params: effectiveParams,
 					routeSegments: intercept?.interceptSourcePageSegments ?? segments

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

@@ -1,10 +1,10 @@
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
+import { isAppPageRouteGroupSegment } from "./app-page-segment-state.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { resolveAppPageSegmentParams } from "./app-page-params.js";
-import { isAppPageRouteGroupSegment } from "./app-page-segment-state.js";
 //#region src/server/app-page-boundary.ts
 function resolveAppPageHttpAccessBoundaryComponent(options) {
 	return options.getDefaultExport(resolveAppPageHttpAccessBoundaryModule({

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

@@ -2,6 +2,7 @@ import { RenderObservation } from "./cache-proof.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 import { AppPageCacheSetter } from "./isr-cache.js";
+import { CdnAppPageDocument } from "../shims/cdn-cache.js";
 import { AppPageRscRenderStatus } from "./app-page-rsc-render-status.js";
 //#region src/server/app-page-cache-finalizer.d.ts
 type AppPageDebugLogger = (event: string, detail: string) => void;
@@ -30,6 +31,8 @@ type FinalizeAppPageCacheabilityEvaluationOptions = {
   /** An RSC render's status, from its document's shell. */
   resolveRscRenderStatus?: () => Promise<AppPageRscRenderStatus>;
   revalidateSeconds: number | null;
+  /** Hands the CDN adapter the page's document to store beside the response. */
+  captureAdmittedDocument?: (document: CdnAppPageDocument | null) => void;
 };
 type FinalizeAppPageHtmlCacheResponseOptions = {
   bypassInterceptionContextCache?: boolean;
@@ -66,15 +69,20 @@ type FinalizeAppPageHtmlCacheResponseOptions = {
 };
 type ScheduleAppPageRscCacheWriteOptions = {
   bypassInterceptionContextCache?: boolean;
+  /** Hands the CDN adapter the page's document to store beside the response. */
+  captureAdmittedDocument?: (document: CdnAppPageDocument | null) => void;
   capturedRscDataPromise: Promise<ArrayBuffer> | null;
   cleanPathname: string;
   consumeDynamicUsage: () => boolean;
   consumeRenderObservationState?: () => AppPageRenderObservationState;
+  /** Observes the document the render's status resolution rendered, if any. */
+  createHtmlRenderObservation?: BuildAppPageCacheRenderObservation;
   createRscRenderObservation: BuildAppPageCacheRenderObservation;
   dynamicUsedDuringBuild: boolean;
   getPageTags: () => string[];
   getRequestCacheLife?: () => AppPageRequestCacheLife | null;
   isrDebug?: AppPageDebugLogger;
+  isrHtmlKey?: (pathname: string) => string;
   isrRscKey: AppPageRscCacheKeyBuilder;
   isrSet: AppPageCacheSetter;
   interceptionContext?: string | null;
@@ -82,7 +90,10 @@ type ScheduleAppPageRscCacheWriteOptions = {
   mountedSlotsHeader?: string | null;
   omitPendingDynamicCacheState?: boolean;
   renderMode?: AppRscRenderMode;
-  /** The render's status, from its document's shell. Without it the render is a 200. */
+  /**
+   * The render's status, from its document's shell, and the page's document
+   * when it rendered one to store. Without it the render is a 200.
+   */
   resolveRscRenderStatus?: () => Promise<AppPageRscRenderStatus>;
   preserveClientResponseHeaders?: boolean;
   expireSeconds?: number;

package/dist/server/app-page-cache-finalizer.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.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,12 +6,12 @@ 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 { 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 { 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
@@ -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,14 +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 { AppPageFallbackRouteHead, AppPagePreparedRouteHead } from "./app-page-head.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";
@@ -107,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;
@@ -161,9 +156,11 @@ 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;
@@ -171,12 +168,10 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
     /** 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;
@@ -249,7 +244,7 @@ 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: {