vinext 1.3.1 → 1.4.1

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;
@@ -205,7 +200,6 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   hasGenerateStaticParams: boolean;
   /** Whether any segment of the route exports `generateStaticParams`. */
   hasAnyGenerateStaticParams: boolean;
-  hasCustomGlobalError?: boolean;
   hasPageDefaultExport: boolean;
   hasPageModule: boolean;
   handlerStart: number;
@@ -249,7 +243,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: {