vinext 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/server/pages-page-handler.js

@@ -1,19 +1,21 @@
-import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { closeAfterResponse, closeAfterResponseWithBody, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
+import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
+import { NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_CACHE_HEADER } from "./headers.js";
 import { reportRequestError } from "./instrumentation.js";
 import { BROWSER_REVALIDATE_CACHE_CONTROL, NEVER_CACHE_CONTROL, applyCdnResponseHeaders, shouldUseNextDeployCacheControl } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
-import { PRERENDER_REVALIDATE_HEADER, isOnDemandRevalidateRequest, isrCacheKey, isrGet, isrSet, triggerBackgroundRegeneration } from "./isr-cache.js";
+import { coalesceOnDemandRevalidation, isOnDemandRevalidateRequest, isrCacheKey, isrGet, isrSet, triggerBackgroundRegeneration } from "./isr-cache.js";
+import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { ensureFetchPatch } from "../shims/fetch-cache.js";
-import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { extractLocaleFromUrl, resolvePagesI18nRequest } from "./pages-i18n.js";
 import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
 import { buildPagesReadinessNextData } from "./pages-readiness.js";
 import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
+import { setCacheStateHeaders } from "./cache-headers.js";
 import { renderPagesPageResponse } from "./pages-page-response.js";
 import { hasPagesGetInitialProps } from "./pages-get-initial-props.js";
 import { buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, normalizePagesDataRequest, parseNextDataPathname } from "./pages-data-route.js";
@@ -25,7 +27,12 @@ import { createPagesReqRes } from "./pages-node-compat.js";
 function finalizePagesPreviewResponse(response, preview) {
 	if (preview.data === false && !preview.shouldClear) return response;
 	const headers = new Headers(response.headers);
-	if (preview.data !== false) headers.set("Cache-Control", PAGES_PREVIEW_CACHE_CONTROL);
+	if (preview.data !== false) {
+		headers.set("Cache-Control", PAGES_PREVIEW_CACHE_CONTROL);
+		headers.delete("CDN-Cache-Control");
+		headers.delete("Cloudflare-CDN-Cache-Control");
+		headers.delete("Cache-Tag");
+	}
 	if (preview.shouldClear) appendPagesPreviewClearCookies(headers);
 	return new Response(response.body, {
 		headers,
@@ -33,6 +40,41 @@ function finalizePagesPreviewResponse(response, preview) {
 		statusText: response.statusText
 	});
 }
+function withPagesCacheState(response, state) {
+	const headers = new Headers(response.headers);
+	if (state === "REVALIDATED") {
+		headers.set(NEXTJS_CACHE_HEADER, state);
+		headers.delete(VINEXT_CACHE_HEADER);
+	} else setCacheStateHeaders(headers, state);
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+function applyPagesErrorCachePolicy(response, revalidateSeconds, expireSeconds, cacheTagPathname) {
+	const headers = new Headers(response.headers);
+	const browserPolicy = headers.get("Cache-Control");
+	const sharedPolicies = [headers.get("CDN-Cache-Control"), headers.get("Cloudflare-CDN-Cache-Control")];
+	const hasCacheableSharedPolicy = sharedPolicies.some((value) => value && /(?:^|,)\s*s-maxage\s*=/i.test(value));
+	if (sharedPolicies.some((value) => value && /(?:private|no-store|no-cache)/i.test(value)) || !hasCacheableSharedPolicy && browserPolicy && /(?:private|no-store|no-cache)/i.test(browserPolicy)) return response;
+	headers.delete("CDN-Cache-Control");
+	headers.delete("Cloudflare-CDN-Cache-Control");
+	headers.delete("Cache-Tag");
+	if (revalidateSeconds === void 0) applyCdnResponseHeaders(headers, { cacheControl: NEVER_CACHE_CONTROL });
+	else {
+		const stem = cacheTagPathname.endsWith("/") ? cacheTagPathname.slice(0, -1) : cacheTagPathname;
+		applyCdnResponseHeaders(headers, {
+			cacheControl: buildMissIsrCacheControl(revalidateSeconds, expireSeconds),
+			tags: [encodeCacheTag(`_N_T_${stem || "/"}`)]
+		});
+	}
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
 function shouldEmitPagesClientTraceMetadata(pageModule, appComponent) {
 	if (typeof pageModule.getServerSideProps === "function") return true;
 	if (typeof pageModule.getStaticProps === "function") return false;
@@ -122,6 +164,7 @@ function createPagesPageHandler(opts) {
 			route: options.__forcedRoute,
 			params: {}
 		} : matchRoute(routeUrl, pageRoutes);
+		let isRouteMissErrorRender = false;
 		let renderStatusCodeOverride = statusCode;
 		let renderAsPath = asPath;
 		if (!match) {
@@ -133,6 +176,7 @@ function createPagesPageHandler(opts) {
 					route: notFoundRoute,
 					params: {}
 				};
+				isRouteMissErrorRender = true;
 				renderStatusCodeOverride = 404;
 				renderAsPath = routeUrl;
 			} else return buildDefaultPagesNotFoundResponse();
@@ -141,16 +185,43 @@ function createPagesPageHandler(opts) {
 		const pageModule = route.module;
 		const isStaticPropsRoute = typeof pageModule.getStaticProps === "function";
 		const isStaticPropsRender = isStaticPropsRoute && typeof pageModule.getServerSideProps !== "function";
+		if (!options?.__skipOnDemandCoalesce && !options?.__forcedRoute && isStaticPropsRoute && isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate"))) {
+			const snapshot = await coalesceOnDemandRevalidation(pageIsrCacheKey("pages", routeUrl.split("?")[0]), async () => {
+				const response = await renderPage(request, url, manifest, middlewareHeaders, {
+					...options,
+					__skipOnDemandCoalesce: true
+				});
+				return {
+					body: request.method === "HEAD" || response.status === 204 || response.status === 304 ? null : new Uint8Array(await response.arrayBuffer()),
+					headers: [...response.headers.entries()],
+					status: response.status,
+					statusText: response.statusText
+				};
+			});
+			return new Response(snapshot.body?.slice() ?? null, {
+				headers: snapshot.headers,
+				status: snapshot.status,
+				statusText: snapshot.statusText
+			});
+		}
 		const renderRouteUrl = isStaticPropsRender ? routeUrl.split("?")[0] : routeUrl;
 		const routerAsPathSource = isStaticPropsRender ? renderRouteUrl : renderAsPath ?? renderRouteUrl;
 		const routerAsPath = i18nConfig ? extractLocaleFromUrl(routerAsPathSource, i18nConfig, locale).url : routerAsPathSource;
-		return runWithRequestContext(createRequestContext({ executionContext: getRequestExecutionContext() }), async () => {
+		const uCtx = createRequestContext({ executionContext: getRequestExecutionContext() });
+		return closeAfterResponseWithBody(await runWithRequestContext(uCtx, async () => {
 			ensureFetchPatch();
 			try {
 				const routePattern = patternToNextFormat(route.pattern);
 				const renderStatusCode = renderStatusCodeOverride ?? (routePattern === "/404" ? 404 : void 0);
+				const isrCachePathname = isStaticPropsRender && (routePattern === "/404" || routePattern === "/500" || routePattern === "/_error") ? routePattern : renderRouteUrl.split("?")[0];
+				const isNotFoundErrorRender = routePattern === "/404" || routePattern === "/_error" && renderStatusCode === 404;
+				const isStatusErrorRender = isNotFoundErrorRender || routePattern === "/500" || routePattern === "/_error" && renderStatusCode === 500;
+				const errorPageRevalidateSeconds = isNotFoundErrorRender ? options?.__notFoundRevalidateSeconds : void 0;
+				const errorPageExpireSeconds = isNotFoundErrorRender ? options?.__notFoundExpireSeconds : void 0;
+				const errorResponseCachePathname = options?.__notFoundCachePathname ?? isrCachePathname;
 				const query = mergeRouteParamsIntoQuery(parseQueryString(renderRouteUrl), params);
 				const isOnDemandRevalidate = isOnDemandRevalidateRequest(request.headers.get(PRERENDER_REVALIDATE_HEADER));
+				const revalidateOnlyGenerated = isOnDemandRevalidate && request.headers.has("x-prerender-revalidate-if-generated");
 				const preview = isStaticPropsRoute || typeof pageModule.getServerSideProps === "function" ? getPagesPreviewState(request.headers.get("cookie"), { isOnDemandRevalidate }) : {
 					data: false,
 					shouldClear: false
@@ -211,11 +282,12 @@ function createPagesPageHandler(opts) {
 					}
 				};
 				const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareHeaders);
+				const shouldApplyErrorResponsePolicy = previewData === false && !scriptNonce && isStatusErrorRender && (isStaticPropsRoute || isRouteMissErrorRender || options?.__forcedRoute !== void 0);
 				let fontLinkHeader = "";
 				let allFontPreloads = [];
 				try {
 					allFontPreloads = getFontPreloads();
-					if (allFontPreloads.length > 0) fontLinkHeader = allFontPreloads.map((p) => "<" + appendAssetDeploymentIdQuery(p.href) + ">; rel=preload; as=font; type=" + p.type + "; crossorigin").join(", ");
+					if (allFontPreloads.length > 0) fontLinkHeader = allFontPreloads.map((p) => "<" + p.href + ">; rel=preload; as=font; type=" + p.type + "; crossorigin").join(", ");
 				} catch {}
 				const pagesResolvedUrl = (new URL(routeUrl, originalRequestUrl).pathname || "/") + originalRequestUrl.search;
 				const createPageReqRes = () => {
@@ -232,6 +304,7 @@ function createPagesPageHandler(opts) {
 					isDataReq,
 					err: err instanceof Error ? err : void 0,
 					applyRequestContexts: applySSRContext,
+					basePath: vinextConfig.basePath,
 					buildId,
 					deploymentId: process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID,
 					htmlLimitedBots: vinextConfig.htmlLimitedBots,
@@ -253,6 +326,7 @@ function createPagesPageHandler(opts) {
 					isBuildTimePrerendering: typeof process !== "undefined" && process.env && process.env.VINEXT_PRERENDER === "1",
 					validatePropsSerialization: process.env.NODE_ENV !== "production" || process.env.VINEXT_PRERENDER === "1",
 					isOnDemandRevalidate,
+					revalidateOnlyGenerated,
 					previewData,
 					pageModule,
 					AppComponent,
@@ -265,10 +339,16 @@ function createPagesPageHandler(opts) {
 					route: { isDynamic: route.isDynamic },
 					routePattern,
 					routeUrl: renderRouteUrl,
+					isrCachePathname,
 					runInFreshUnifiedContext(callback) {
-						return runWithRequestContext(createRequestContext({ executionContext: null }), async () => {
+						const revalCtx = createRequestContext({ executionContext: null });
+						return runWithRequestContext(revalCtx, async () => {
 							ensureFetchPatch();
-							return callback();
+							try {
+								return await callback();
+							} finally {
+								await closeAfterResponse(revalCtx);
+							}
 						});
 					},
 					safeJsonStringify,
@@ -284,15 +364,26 @@ function createPagesPageHandler(opts) {
 				});
 				if (pageDataResult.kind === "notFound") {
 					const notFoundRoute = findNotFoundRoute();
-					if (notFoundRoute && routePattern !== "/404" && routePattern !== "/_error") return finalizePagesPreviewResponse(await renderPage(request, url, manifest, middlewareHeaders, {
+					let notFoundResponse;
+					if (notFoundRoute && routePattern !== "/404" && routePattern !== "/_error") notFoundResponse = await renderPage(request, url, manifest, middlewareHeaders, {
 						statusCode: 404,
 						asPath: routerAsPath,
 						renderErrorPageOnMiss: false,
-						__forcedRoute: notFoundRoute
-					}), preview);
-					return finalizePagesPreviewResponse(buildDefaultPagesNotFoundResponse(), preview);
+						__forcedRoute: notFoundRoute,
+						__notFoundRevalidateSeconds: pageDataResult.revalidateSeconds,
+						__notFoundExpireSeconds: pageDataResult.expireSeconds,
+						__notFoundCachePathname: isrCachePathname
+					});
+					else notFoundResponse = buildDefaultPagesNotFoundResponse();
+					if (isOnDemandRevalidate) notFoundResponse = withPagesCacheState(notFoundResponse, "REVALIDATED");
+					else if (pageDataResult.cacheState) notFoundResponse = withPagesCacheState(notFoundResponse, pageDataResult.cacheState);
+					return finalizePagesPreviewResponse(notFoundResponse, preview);
+				}
+				if (pageDataResult.kind === "response") {
+					let response = isOnDemandRevalidate && pageDataResult.onDemandRevalidateSuccess !== false ? withPagesCacheState(pageDataResult.response, "REVALIDATED") : pageDataResult.response;
+					if (shouldApplyErrorResponsePolicy) response = applyPagesErrorCachePolicy(response, errorPageRevalidateSeconds, errorPageExpireSeconds, errorResponseCachePathname);
+					return finalizePagesPreviewResponse(response, preview);
 				}
-				if (pageDataResult.kind === "response") return finalizePagesPreviewResponse(pageDataResult.response, preview);
 				let pageProps = pageDataResult.pageProps;
 				let renderProps = pageDataResult.props;
 				if (previewData !== false) renderProps = {
@@ -312,6 +403,7 @@ function createPagesPageHandler(opts) {
 				const gsspRes = pageDataResult.gsspRes;
 				const documentReqRes = serializedPagesNextData.autoExport === true ? null : pageDataResult.documentReqRes ?? createPageReqRes();
 				const isrRevalidateSeconds = pageDataResult.isrRevalidateSeconds;
+				const isrExpireSeconds = pageDataResult.isrExpireSeconds;
 				const isFallbackRender = pageDataResult.isFallback === true;
 				if (isFallbackRender) applySSRContext({
 					query: {},
@@ -337,7 +429,7 @@ function createPagesPageHandler(opts) {
 						}
 						if (!hasUserCacheControl) init.headers["Cache-Control"] = NEVER_CACHE_CONTROL;
 					} else if (isStaticPropsRoute) {
-						if (isrRevalidateSeconds) {
+						if (isrRevalidateSeconds !== null) {
 							const headers = new Headers(init.headers);
 							applyCdnResponseHeaders(headers, { cacheControl: buildMissIsrCacheControl(isrRevalidateSeconds, vinextConfig.expireTime) });
 							for (const [key, value] of headers) init.headers[key] = value;
@@ -352,7 +444,7 @@ function createPagesPageHandler(opts) {
 				const pageModuleIds = [];
 				if (appAssetPath) pageModuleIds.push(appAssetPath);
 				if (route.filePath) pageModuleIds.push(route.filePath);
-				return finalizePagesPreviewResponse(await renderPagesPageResponse({
+				let pageResponse = await renderPagesPageResponse({
 					assetTags: collectAssetTags({
 						manifest,
 						moduleIds: pageModuleIds,
@@ -386,8 +478,10 @@ function createPagesPageHandler(opts) {
 					documentReqRes,
 					gsspRes,
 					isrCacheKey: pageIsrCacheKey,
-					expireSeconds: vinextConfig.expireTime,
+					isrCachePathname,
+					expireSeconds: isrExpireSeconds,
 					isrRevalidateSeconds,
+					isOnDemandRevalidate,
 					isStaticPropsRoute,
 					isrSet,
 					i18n: buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales),
@@ -411,7 +505,9 @@ function createPagesPageHandler(opts) {
 					userAgent: request.headers.get("user-agent") ?? void 0,
 					ifNoneMatch: request.headers.get("if-none-match") ?? void 0,
 					requestCacheControl: request.headers.get("cache-control") ?? void 0
-				}), preview);
+				});
+				if (shouldApplyErrorResponsePolicy) pageResponse = applyPagesErrorCachePolicy(pageResponse, errorPageRevalidateSeconds, errorPageExpireSeconds, errorResponseCachePathname);
+				return finalizePagesPreviewResponse(pageResponse, preview);
 			} catch (e) {
 				console.error("[vinext] SSR error:", e);
 				reportRequestError(e instanceof Error ? e : new Error(String(e)), {
@@ -445,7 +541,7 @@ function createPagesPageHandler(opts) {
 				}
 				return new Response("Internal Server Error", { status: 500 });
 			}
-		});
+		}), uCtx);
 	}
 	return renderPage;
 }

package/dist/server/pages-page-response.d.ts

@@ -88,11 +88,13 @@ type RenderPagesPageResponseOptions = {
   setDocumentInitialHead?: ((head: ReactNode[]) => void) | undefined;
   documentReqRes?: PagesDocumentReqRes | null;
   gsspRes: PagesGsspResponse | null;
-  isrCacheKey: (router: string, pathname: string) => string;
+  isrCacheKey: (router: string, pathname: string) => string; /** Filesystem-route identity used for ISR persistence and cache tags. */
+  isrCachePathname?: string;
   expireSeconds?: number;
-  isrRevalidateSeconds: number | null;
+  isrRevalidateSeconds: number | false | null; /** Synchronous `res.revalidate()` render; cache persistence must finish before returning. */
+  isOnDemandRevalidate?: boolean;
   isStaticPropsRoute?: boolean;
-  isrSet: (key: string, data: CachedPagesValue, revalidateSeconds: number, tags?: string[], expireSeconds?: number) => Promise<void>;
+  isrSet: (key: string, data: CachedPagesValue, revalidateSeconds: number | false, tags?: string[], expireSeconds?: number) => Promise<void>;
   i18n: PagesI18nRenderContext;
   /**
    * True when rendering a `getStaticPaths` fallback shell for a path that

package/dist/server/pages-page-response.js

@@ -1,6 +1,6 @@
 import { getRequestExecutionContext } from "../shims/request-context.js";
+import { NEXTJS_CACHE_HEADER } from "./headers.js";
 import { reportRequestError } from "./instrumentation.js";
-import { setCacheStateHeaders } from "./cache-headers.js";
 import { BROWSER_REVALIDATE_CACHE_CONTROL, NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, shouldUseNextDeployCacheControl } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
 import { fnv1a52 } from "../utils/hash.js";
@@ -9,29 +9,19 @@ import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createNonceAttribute, escapeHtmlAttr } from "./html.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
+import { setCacheStateHeaders } from "./cache-headers.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { loadUserDocumentInitialProps, runDocumentRenderPage } from "./pages-document-initial-props.js";
 import { callDocumentGetInitialProps } from "./document-initial-head.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import React from "react";
 //#region src/server/pages-page-response.ts
 /**
-* Crawlers that cannot handle streamed HTML: they read metadata only from
-* the first network chunk, so streaming would give them an incomplete <head>.
-* Pattern sourced from Next.js html-bots.ts (updated to match the canary).
-*/
-const HTML_LIMITED_BOT_UA_RE = /[\w-]+-Google|Google-[\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight/i;
-/**
-* Googlebot (the main search crawler) executes JavaScript via a headless
-* browser, so it too cannot safely handle mid-stream HTML mutations.
-* Matches "Googlebot" but NOT suffixed variants like "Googlebot-Image".
-*/
-const HEADLESS_BROWSER_BOT_UA_RE = /Googlebot(?!-)|Googlebot$/i;
-/**
 * Returns true when the User-Agent belongs to a bot or crawler that cannot
 * reliably consume a streamed HTML response.
 */
 function isPagesStreamingBot(userAgent) {
-	return HEADLESS_BROWSER_BOT_UA_RE.test(userAgent) || HTML_LIMITED_BOT_UA_RE.test(userAgent);
+	return isBotUserAgent(userAgent);
 }
 function generatePagesETag(payload) {
 	return "\"" + fnv1a52(payload).toString(36) + payload.length.toString(36) + "\"";
@@ -64,7 +54,7 @@ function buildPagesFontHeadHtml(fontLinks, fontPreloads, fontStyles, scriptNonce
 	let html = "";
 	const nonceAttr = createNonceAttribute(scriptNonce);
 	for (const link of fontLinks) html += `<link rel="stylesheet"${nonceAttr} href="${escapeHtmlAttr(appendAssetDeploymentIdQuery(link))}" />\n  `;
-	for (const preload of fontPreloads) html += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(appendAssetDeploymentIdQuery(preload.href))}" as="font" type="${escapeHtmlAttr(preload.type)}" crossorigin />\n  `;
+	for (const preload of fontPreloads) html += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(preload.href)}" as="font" type="${escapeHtmlAttr(preload.type)}" crossorigin />\n  `;
 	if (fontStyles.length > 0) html += `<style data-vinext-fonts${nonceAttr}>${fontStyles.join("\n")}</style>\n  `;
 	return html;
 }
@@ -142,14 +132,18 @@ async function reportPagesIsrCacheWriteError(error, cacheKey, routePattern) {
 		});
 	} catch {}
 }
-function schedulePagesIsrCacheWrite(options) {
-	const cacheWritePromise = readStreamAsText(options.stream).then((bodyHtml) => options.setCache(options.cacheKey, {
+async function writePagesIsrCache(options) {
+	const bodyHtml = await readStreamAsText(options.stream);
+	await options.setCache(options.cacheKey, {
 		kind: "PAGES",
 		html: options.shellPrefix + bodyHtml + options.shellSuffix,
 		pageData: options.pageData,
 		headers: void 0,
 		status: options.status
-	}, options.revalidateSeconds, void 0, options.expireSeconds)).catch((error) => reportPagesIsrCacheWriteError(error, options.cacheKey, options.routePattern));
+	}, options.revalidateSeconds, void 0, options.expireSeconds);
+}
+function schedulePagesIsrCacheWrite(options) {
+	const cacheWritePromise = writePagesIsrCache(options).catch((error) => reportPagesIsrCacheWriteError(error, options.cacheKey, options.routePattern));
 	getRequestExecutionContext()?.waitUntil(cacheWritePromise);
 }
 function applyGsspHeaders(headers, gsspRes, statusCode) {
@@ -235,15 +229,15 @@ async function renderPagesPageResponse(options) {
 	const responseHeaders = new Headers({ "Content-Type": "text/html; charset=utf-8" });
 	const finalStatus = applyGsspHeaders(responseHeaders, options.gsspRes ?? options.documentReqRes?.res ?? null, options.statusCode);
 	let responseBodyStream = bodyStream;
-	if (!options.scriptNonce && options.isrRevalidateSeconds !== null && options.isrRevalidateSeconds > 0) {
+	if (!options.scriptNonce && options.isrRevalidateSeconds !== null && (options.isrRevalidateSeconds === false || options.isrRevalidateSeconds > 0)) {
 		const cacheBodyStreamPair = bodyStream.tee();
 		responseBodyStream = cacheBodyStreamPair[0];
 		const cacheBodyStream = cacheBodyStreamPair[1];
-		const isrPathname = options.routeUrl.split("?")[0];
-		schedulePagesIsrCacheWrite({
+		const isrPathname = options.isrCachePathname ?? options.routeUrl.split("?")[0];
+		const cacheWriteOptions = {
 			cacheKey: options.isrCacheKey("pages", isrPathname),
 			expireSeconds: options.expireSeconds,
-			pageData: options.pageProps,
+			pageData: options.props ?? { pageProps: options.pageProps },
 			revalidateSeconds: options.isrRevalidateSeconds,
 			routePattern: options.routePattern,
 			setCache: options.isrSet,
@@ -251,19 +245,22 @@ async function renderPagesPageResponse(options) {
 			shellSuffix,
 			status: finalStatus,
 			stream: cacheBodyStream
-		});
+		};
+		if (options.isOnDemandRevalidate) await writePagesIsrCache(cacheWriteOptions);
+		else schedulePagesIsrCacheWrite(cacheWriteOptions);
 	}
 	const compositeStream = await buildPagesCompositeStream(responseBodyStream, shellPrefix, shellSuffix);
 	const userSetCacheControl = responseHeaders.has("Cache-Control");
 	if (options.scriptNonce) responseHeaders.set("Cache-Control", NO_STORE_CACHE_CONTROL);
-	else if (options.isrRevalidateSeconds) {
-		const isrPathname = options.routeUrl.split("?")[0];
+	else if (options.isrRevalidateSeconds !== null) {
+		const isrPathname = options.isrCachePathname ?? options.routeUrl.split("?")[0];
 		const stem = isrPathname.endsWith("/") ? isrPathname.slice(0, -1) : isrPathname;
 		applyCdnResponseHeaders(responseHeaders, {
 			cacheControl: buildMissIsrCacheControl(options.isrRevalidateSeconds, options.expireSeconds),
 			tags: [encodeCacheTag(`_N_T_${stem || "/"}`)]
 		});
-		setCacheStateHeaders(responseHeaders, "MISS");
+		if (options.isOnDemandRevalidate) responseHeaders.set(NEXTJS_CACHE_HEADER, "REVALIDATED");
+		else setCacheStateHeaders(responseHeaders, "MISS");
 	} else if (options.isStaticPropsRoute && shouldUseNextDeployCacheControl()) responseHeaders.set("Cache-Control", BROWSER_REVALIDATE_CACHE_CONTROL);
 	else if (options.gsspRes && !userSetCacheControl) responseHeaders.set("Cache-Control", NEVER_CACHE_CONTROL);
 	if (options.fontLinkHeader) responseHeaders.set("Link", options.fontLinkHeader);

package/dist/server/pages-request-pipeline.d.ts

@@ -45,6 +45,13 @@ type PagesPipelineDeps = {
   ctx?: unknown;
   rawSearch?: string;
   configMatchPathname?: string;
+  /**
+   * Validate an on-demand revalidation credential using the runtime's
+   * authoritative build secret. Production adapters must inject the verifier
+   * exported by the generated server entry so this early middleware decision
+   * uses the same baked secret as the eventual page renderer.
+   */
+  authorizeOnDemandRevalidate?: (headerValue: string | null) => boolean;
   matchPageRoute?: ((pathname: string, request: Request) => PageRouteMatch | null) | null;
   runMiddleware?: ((request: Request, ctx: unknown, opts: {
     isDataRequest: boolean;

package/dist/server/pages-request-pipeline.js

@@ -1,9 +1,11 @@
 import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
+import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { applyMiddlewareRequestHeaders, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
+import { isOnDemandRevalidateRequest } from "./isr-cache.js";
 import { mergeRewriteQuery } from "../utils/query.js";
 import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
 import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
@@ -56,6 +58,8 @@ async function runPagesRequest(request, deps) {
 	const url = new URL(request.url);
 	let pathname = url.pathname;
 	const search = url.search;
+	const revalidateHeader = request.headers.get(PRERENDER_REVALIDATE_HEADER);
+	const isOnDemandRevalidate = deps.authorizeOnDemandRevalidate ? deps.authorizeOnDemandRevalidate(revalidateHeader) : isOnDemandRevalidateRequest(revalidateHeader);
 	const requestConfigPathname = deps.configMatchPathname ?? pathname;
 	const basePathState = {
 		basePath,
@@ -98,7 +102,7 @@ async function runPagesRequest(request, deps) {
 		};
 		return served ? { type: "handled" } : null;
 	};
-	if (typeof deps.runMiddleware === "function") {
+	if (!isOnDemandRevalidate && typeof deps.runMiddleware === "function") {
 		const result = await deps.runMiddleware(request, deps.ctx ?? null, { isDataRequest });
 		if (result.waitUntilPromises && result.waitUntilPromises.length > 0) {
 			const ctx = deps.ctx;

package/dist/server/pages-revalidate.d.ts

@@ -10,6 +10,6 @@ type RevalidateOptions = {
    */
   unstable_onlyGenerated?: boolean;
 };
-declare function performOnDemandRevalidate(source: IncomingMessage | Headers, urlPath: string, opts?: RevalidateOptions): Promise<void>;
+declare function performOnDemandRevalidate(source: IncomingMessage | Headers, urlPath: string, opts?: RevalidateOptions, trustedOrigin?: string, allowedRevalidateHeaderKeys?: readonly string[], dev?: boolean): Promise<void>;
 //#endregion
 export { RevalidateOptions, performOnDemandRevalidate };

package/dist/server/pages-revalidate.js

@@ -1,19 +1,65 @@
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import "./headers.js";
-import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, getRevalidateSecret } from "./isr-cache.js";
+import { getRevalidateSecret, isOnDemandRevalidateRequest } from "./isr-cache.js";
+import { normalizeDomainHostname } from "../utils/domain-locale.js";
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 //#region src/server/pages-revalidate.ts
-async function performOnDemandRevalidate(source, urlPath, opts = {}) {
+async function performOnDemandRevalidate(source, urlPath, opts = {}, trustedOrigin, allowedRevalidateHeaderKeys = [], dev = false) {
 	if (typeof urlPath !== "string" || !urlPath.startsWith("/")) throw new Error(`Invalid urlPath provided to revalidate(), must be a path e.g. /blog/post-1, received ${urlPath}`);
-	const proto = resolveRequestProtocol(source);
-	const host = resolveRequestHost(source, "localhost");
-	const target = new URL(urlPath, `${proto}://${host}`);
+	if (isSourceRevalidationRequest(source)) throw new Error(`Cannot revalidate ${urlPath} from an internal revalidation request`);
+	const executionContext = getRequestExecutionContext();
+	const dispatchRevalidate = executionContext?.dispatchPagesRevalidate;
+	const target = createRevalidateTarget(source, urlPath, trustedOrigin);
 	const headers = { [PRERENDER_REVALIDATE_HEADER]: getRevalidateSecret() };
+	if (trustedOrigin && !dispatchRevalidate) {
+		const logicalHostname = normalizeDomainHostname(resolveRequestHost(source, "localhost"));
+		if (logicalHostname) headers[VINEXT_REVALIDATE_HOST_HEADER] = logicalHostname;
+	}
 	if (opts.unstable_onlyGenerated) headers[PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER] = "1";
-	const res = await fetch(target, {
+	const allowedHeaders = new Set(allowedRevalidateHeaderKeys.map((key) => key.toLowerCase()));
+	if (dev) allowedHeaders.add("cookie");
+	for (const key of allowedHeaders) {
+		const value = readSourceHeader(source, key);
+		if (value !== void 0) headers[key] = value;
+	}
+	if (dispatchRevalidate && executionContext.isInternalPagesRevalidation) throw new Error(`Cannot revalidate ${urlPath} from an internal revalidation request`);
+	const res = await fetchRevalidateTarget(target, headers, dispatchRevalidate);
+	if (!((res.headers.get("x-vercel-cache") ?? res.headers.get("x-nextjs-cache"))?.toUpperCase() === "REVALIDATED" || res.status === 200 || res.status === 404 && opts.unstable_onlyGenerated === true)) throw new Error(`Failed to revalidate ${urlPath}: ${res.status}`);
+}
+function readSourceHeader(source, key) {
+	if (isWebHeaders(source)) return source.get(key) ?? void 0;
+	const value = source.headers[key];
+	return Array.isArray(value) ? value.join(", ") : value;
+}
+function isSourceRevalidationRequest(source) {
+	return isOnDemandRevalidateRequest(isWebHeaders(source) ? source.get(PRERENDER_REVALIDATE_HEADER) : source.headers[PRERENDER_REVALIDATE_HEADER]);
+}
+function isWebHeaders(source) {
+	return typeof source.get === "function";
+}
+async function fetchRevalidateTarget(initialTarget, headers, dispatchRevalidate) {
+	const request = new Request(initialTarget, {
 		method: "HEAD",
-		headers
+		headers,
+		redirect: "manual"
 	});
-	if (!(res.headers.get("x-nextjs-cache")?.toUpperCase() === "REVALIDATED" || res.status === 200 || res.status === 404 && opts.unstable_onlyGenerated === true)) throw new Error(`Failed to revalidate ${urlPath}: ${res.status}`);
+	return dispatchRevalidate ? await dispatchRevalidate(request) : await fetch(request);
+}
+function createRevalidateTarget(source, urlPath, trustedOrigin) {
+	const origin = resolveRevalidateOrigin(source, trustedOrigin);
+	const target = new URL(`${origin}${urlPath}`);
+	if (target.origin !== origin) throw new Error(`Invalid urlPath provided to revalidate(), resolved outside application origin`);
+	return target;
+}
+function resolveRevalidateOrigin(source, trustedOrigin) {
+	if (trustedOrigin) return normalizeRevalidateOrigin(trustedOrigin);
+	return normalizeRevalidateOrigin(`${resolveRequestProtocol(source)}://${resolveRequestHost(source, "localhost")}`);
+}
+function normalizeRevalidateOrigin(origin) {
+	const parsed = new URL(origin);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`Invalid revalidate origin protocol: ${parsed.protocol}`);
+	return parsed.origin;
 }
 //#endregion
 export { performOnDemandRevalidate };

package/dist/server/pages-router-entry.d.ts

@@ -22,6 +22,7 @@ type PagesWorkerEnv = {
 type PagesWorkerExecutionContext = {
   waitUntil?(promise: Promise<unknown>): void;
   passThroughOnException?(): void;
+  cache?: unknown;
 };
 declare const _default: {
   fetch(request: Request, env?: PagesWorkerEnv, ctx?: PagesWorkerExecutionContext): Promise<Response>;

package/dist/server/pages-router-entry.js

@@ -1,5 +1,6 @@
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import { notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders } from "./request-pipeline.js";
@@ -7,6 +8,7 @@ import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js"
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { finalizeMissingStaticAssetResponse } from "./worker-utils.js";
 import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
+import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
 import * as pagesEntry from "virtual:vinext-server-entry";
@@ -25,7 +27,7 @@ import * as pagesEntry from "virtual:vinext-server-entry";
 *   import handler from "vinext/server/pages-router-entry";
 *   return handler.fetch(request, env, ctx);
 */
-const { handleApiRoute, hasMiddleware, matchPageRoute, normalizeDataRequest, renderPage, runMiddleware, vinextConfig } = pagesEntry;
+const { authorizeOnDemandRevalidate, handleApiRoute, hasMiddleware, matchPageRoute, normalizeDataRequest, renderPage, runMiddleware, vinextConfig } = pagesEntry;
 const basePath = vinextConfig?.basePath ?? "";
 const assetPathPrefix = assetPrefixPathname(vinextConfig?.assetPrefix ?? "");
 const trailingSlash = vinextConfig?.trailingSlash ?? false;
@@ -47,7 +49,8 @@ const imageConfig = vinextConfig?.images ? {
 var pages_router_entry_default = { async fetch(request, env, ctx) {
 	return handleRequest(request, env, ctx);
 } };
-async function handleRequest(request, env, ctx) {
+async function handleRequest(request, env, platformCtx) {
+	const ctx = createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx));
 	registerConfiguredCacheAdapters(env);
 	registerConfiguredImageOptimizer(env);
 	try {
@@ -59,7 +62,9 @@ async function handleRequest(request, env, ctx) {
 			return new Response("Bad Request", { status: 400 });
 		}
 		const missingBuildAsset = isNextStaticPath(pathname, basePath, assetPathPrefix);
-		request = cloneRequestWithHeaders(request, filterInternalHeaders(request.headers));
+		const filteredHeaders = ctx.isInternalPagesRevalidation ? new Headers(request.headers) : filterInternalHeaders(request.headers);
+		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
+		request = cloneRequestWithHeaders(request, filteredHeaders);
 		const hadBasePath = !basePath || hasBasePath(pathname, basePath);
 		{
 			const stripped = stripBasePath(pathname, basePath);
@@ -93,10 +98,11 @@ async function handleRequest(request, env, ctx) {
 			isDataRequest: isDataReq,
 			hasMiddleware,
 			ctx,
+			authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
 			matchPageRoute: typeof matchPageRoute === "function" ? matchPageRoute : null,
 			runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
 			renderPage: typeof renderPage === "function" ? (req, resolvedUrl, options, stagedHeaders) => renderPage(req, resolvedUrl, null, ctx, stagedHeaders, options) : null,
-			handleApi: typeof handleApiRoute === "function" ? (req, apiUrl) => handleApiRoute(req, apiUrl, ctx) : null,
+			handleApi: typeof handleApiRoute === "function" ? (req, apiUrl) => handleApiRoute(req, apiUrl, ctx, new URL(req.url).origin) : null,
 			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase) => {
 				if (!env?.ASSETS) return false;
 				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(env.ASSETS.fetch(assetRequest)));

package/dist/server/prod-server.d.ts

@@ -1,3 +1,4 @@
+import { NextI18nConfig } from "../config/next-config.js";
 import { negotiateEncoding } from "./accept-encoding.js";
 import { StaticFileCache } from "./static-file-cache.js";
 import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
@@ -103,7 +104,7 @@ declare function tryServeStatic(req: IncomingMessage, res: ServerResponse, clien
  * When `urlOverride` is provided, it is used as the path + query string
  * instead of `req.url`.
  */
-declare function nodeToWebRequest(req: IncomingMessage, urlOverride?: string, prerenderSecret?: string): Request;
+declare function nodeToWebRequest(req: IncomingMessage, urlOverride?: string, prerenderSecret?: string, i18nConfig?: NextI18nConfig | null, authorizeOnDemandRevalidate?: (headerValue: string | null) => boolean): Request;
 /**
  * Stream a Web Response back to a Node.js ServerResponse.
  * Supports streaming compression for SSR responses.