vinext 1.3.1 → 1.4.1

package/dist/server/pages-media-type.d.ts

@@ -9,6 +9,26 @@ export declare class PagesBodyParseError extends Error {
   readonly statusCode: number;
   constructor(message: string, statusCode: number);
 }
-export declare function getMediaType(contentType: string | null | undefined): string;
 export declare function isJsonMediaType(mediaType: string): boolean;
+/** A `TextDecoder`-shaped decoder for one request body. */
+export type PagesBodyDecoder = {
+  decode(input?: Uint8Array, options?: {
+    stream?: boolean;
+  }): string;
+};
+/**
+ * Resolve the media type and body decoder for a Pages API request, matching
+ * Next.js `parseBody()`: a malformed Content-Type is treated as `text/plain`,
+ * the body is decoded with its `charset` (UTF-8 by default), and a charset that
+ * can't be decoded is rejected with `400 Invalid body`.
+ *
+ * Next.js decodes through raw-body with iconv-lite 0.4, which vinext bundles
+ * at the same version. It is loaded only for non-UTF-8 charsets: `TextDecoder`
+ * decodes UTF-8 identically, BOM stripping included, and keeps iconv-lite's
+ * encoding tables out of the startup path.
+ */
+export declare function createPagesBodyDecoder(contentType: string | null | undefined): Promise<{
+  mediaType: string;
+  decoder: PagesBodyDecoder;
+}>;
 //#endregion

package/dist/server/pages-media-type.js

@@ -1,3 +1,5 @@
+import { __toESM } from "../_virtual/_rolldown/runtime.js";
+import { Buffer } from "node:buffer";
 //#region src/server/pages-media-type.ts
 /**
 * Shared media-type helpers and body-parse error for Pages API routes.
@@ -13,12 +15,74 @@ var PagesBodyParseError = class extends Error {
 		this.name = "PagesBodyParseError";
 	}
 };
-function getMediaType(contentType) {
-	const [type] = (contentType ?? "text/plain").split(";");
-	return type?.trim().toLowerCase() || "text/plain";
-}
 function isJsonMediaType(mediaType) {
 	return mediaType === "application/json" || mediaType === "application/ld+json";
 }
+const TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+const PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
+const QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
+function parseContentType(header) {
+	let index = header.indexOf(";");
+	const type = (index === -1 ? header : header.slice(0, index)).trim();
+	if (!TYPE_REGEXP.test(type)) return null;
+	let charset;
+	if (index !== -1) {
+		const paramRegexp = new RegExp(PARAM_REGEXP);
+		paramRegexp.lastIndex = index;
+		let match;
+		while (match = paramRegexp.exec(header)) {
+			if (match.index !== index) return null;
+			index += match[0].length;
+			if (match[1].toLowerCase() !== "charset") continue;
+			const value = match[2];
+			charset = value.startsWith("\"") ? value.slice(1, -1).replace(QESC_REGEXP, "$1") : value;
+		}
+		if (index !== header.length) return null;
+	}
+	return {
+		mediaType: type.toLowerCase(),
+		charset
+	};
+}
+function iconvBodyDecoder(decoder) {
+	return { decode(input, options) {
+		let text = input ? decoder.write(Buffer.from(input.buffer, input.byteOffset, input.byteLength)) : "";
+		if (!options?.stream) text += decoder.end() || "";
+		return text;
+	} };
+}
+/**
+* Resolve the media type and body decoder for a Pages API request, matching
+* Next.js `parseBody()`: a malformed Content-Type is treated as `text/plain`,
+* the body is decoded with its `charset` (UTF-8 by default), and a charset that
+* can't be decoded is rejected with `400 Invalid body`.
+*
+* Next.js decodes through raw-body with iconv-lite 0.4, which vinext bundles
+* at the same version. It is loaded only for non-UTF-8 charsets: `TextDecoder`
+* decodes UTF-8 identically, BOM stripping included, and keeps iconv-lite's
+* encoding tables out of the startup path.
+*/
+async function createPagesBodyDecoder(contentType) {
+	const parsed = contentType && parseContentType(contentType) || {
+		mediaType: "text/plain",
+		charset: void 0
+	};
+	const charset = parsed.charset || "utf-8";
+	if (charset.toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "") === "utf8") return {
+		mediaType: parsed.mediaType,
+		decoder: new TextDecoder()
+	};
+	const iconv = (await import("../deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/lib/index.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))).default;
+	let decoder;
+	try {
+		decoder = iconv.getDecoder(charset);
+	} catch {
+		throw new PagesBodyParseError("Invalid body", 400);
+	}
+	return {
+		mediaType: parsed.mediaType,
+		decoder: iconvBodyDecoder(decoder)
+	};
+}
 //#endregion
-export { PagesBodyParseError, getMediaType, isJsonMediaType };
+export { PagesBodyParseError, createPagesBodyDecoder, isJsonMediaType };

package/dist/server/pages-node-compat.d.ts

@@ -7,7 +7,7 @@ export type PagesRequestQuery = Record<string, string | string[]>;
 export type PagesReqResRequest = Readable & {
   method: string;
   url: string;
-  headers: Record<string, string>;
+  headers: Record<string, string | string[] | undefined>;
   query: PagesRequestQuery;
   body: unknown;
   cookies: Record<string, string>;

package/dist/server/pages-node-compat.js

@@ -2,11 +2,11 @@ import { parseCookieHeader } from "../utils/parse-cookie.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT } from "./pages-body-parser-config.js";
-import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
+import { PagesBodyParseError, createPagesBodyDecoder, isJsonMediaType } from "./pages-media-type.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { clearPagesPreviewData, getPagesPreviewState, setPagesDraftMode, setPagesPreviewData } from "./pages-preview.js";
 import { decode } from "node:querystring";
-import { Readable, Writable } from "node:stream";
+import { Readable, Stream, Writable } from "node:stream";
 //#region src/server/pages-node-compat.ts
 const MAX_PAGES_API_BODY_SIZE = DEFAULT_PAGES_API_BODY_SIZE_LIMIT;
 const NO_BODY_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
@@ -26,11 +26,17 @@ function validateAppendedHeader(name, value) {
 		if (INVALID_HEADER_VALUE_CHAR_PATTERN.test(String(item))) throw createNodeTypeError("ERR_INVALID_CHAR", `Invalid character in header content ["${name}"]`);
 	}
 }
-async function readPagesRequestBodyWithLimit(request, maxBytes) {
-	if (!request.body) return "";
-	return readStreamAsTextWithLimit(request.body, maxBytes, () => {
+/** The decoded body, or undefined when the request carried no body bytes. */
+async function readPagesRequestBodyWithLimit(request, maxBytes, decoder) {
+	if (!request.body) return;
+	let byteLength = 0;
+	const text = await readStreamAsTextWithLimit(request.body, maxBytes, () => {
 		throw new PagesBodyParseError("Request body too large", 413);
-	});
+	}, { decode(input, options) {
+		byteLength += input?.byteLength ?? 0;
+		return decoder.decode(input, options);
+	} });
+	return byteLength > 0 ? text : void 0;
 }
 /**
 * Read and parse a Pages Router API request body for the Workers/prod path.
@@ -43,16 +49,16 @@ async function readPagesRequestBodyWithLimit(request, maxBytes) {
 * @see https://nextjs.org/docs/pages/building-your-application/routing/api-routes#custom-config
 */
 async function parsePagesApiBody(request, maxBytes = MAX_PAGES_API_BODY_SIZE) {
+	const { mediaType, decoder } = await createPagesBodyDecoder(request.headers.get("content-type"));
 	if (Number.parseInt(request.headers.get("content-length") || "0", 10) > maxBytes) throw new PagesBodyParseError("Request body too large", 413);
-	let rawBody = "";
+	let rawBody;
 	try {
-		rawBody = await readPagesRequestBodyWithLimit(request, maxBytes);
+		rawBody = await readPagesRequestBodyWithLimit(request, maxBytes, decoder);
 	} catch (err) {
 		if (err instanceof PagesBodyParseError) throw err;
 		throw new PagesBodyParseError("Request body too large", 413);
 	}
-	const mediaType = getMediaType(request.headers.get("content-type"));
-	if (!rawBody) return isJsonMediaType(mediaType) ? {} : mediaType === "application/x-www-form-urlencoded" ? decode(rawBody) : void 0;
+	if (!rawBody) return isJsonMediaType(mediaType) ? {} : mediaType === "application/x-www-form-urlencoded" ? decode("") : rawBody;
 	if (isJsonMediaType(mediaType)) try {
 		return JSON.parse(rawBody);
 	} catch {
@@ -61,24 +67,34 @@ async function parsePagesApiBody(request, maxBytes = MAX_PAGES_API_BODY_SIZE) {
 	if (mediaType === "application/x-www-form-urlencoded") return decode(rawBody);
 	return rawBody;
 }
-async function* requestBodyChunks(request) {
-	if (!request.body || request.bodyUsed) return;
-	const reader = request.body.getReader();
-	try {
-		for (;;) {
-			const { value, done } = await reader.read();
-			if (done) return;
-			yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-		}
-	} finally {
-		try {
-			await reader.cancel();
-		} catch {}
-		reader.releaseLock();
-	}
-}
 function createRequestReadable(request) {
-	return Readable.from(requestBodyChunks(request), { objectMode: false });
+	const body = request.bodyUsed ? null : request.body;
+	let reader;
+	return new Readable({
+		read() {
+			if (!body) {
+				this.push(null);
+				return;
+			}
+			reader ??= body.getReader();
+			reader.read().then(({ value, done }) => {
+				if (this.destroyed) return;
+				if (done) {
+					this.push(null);
+					return;
+				}
+				this.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+			}, (error) => this.destroy(error));
+		},
+		destroy(error, callback) {
+			const cancelled = reader ? reader.cancel(error ?? void 0) : body?.cancel(error ?? void 0);
+			if (!cancelled) {
+				callback(error);
+				return;
+			}
+			cancelled.then(() => callback(error), () => callback(error));
+		}
+	});
 }
 function parsePagesRequestCookies(cookieHeader) {
 	return parseCookieHeader(Array.isArray(cookieHeader) ? cookieHeader.join("; ") : cookieHeader);
@@ -189,6 +205,15 @@ var PagesResponseStream = class extends Writable {
 		this.end(JSON.stringify(data));
 	}
 	send(data) {
+		if (NO_BODY_RESPONSE_STATUSES.has(this.resStatusCode)) {
+			this.end();
+			return;
+		}
+		if (data instanceof Stream) {
+			if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "application/octet-stream";
+			data.pipe(this);
+			return;
+		}
 		if (Buffer.isBuffer(data)) {
 			if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "application/octet-stream";
 			this.resHeaders["content-length"] = String(data.length);
@@ -342,6 +367,8 @@ function isVinextStreamedApiResponse(response) {
 function createPagesReqRes(options) {
 	const headersObj = {};
 	for (const [key, value] of options.request.headers) headersObj[key.toLowerCase()] = value;
+	const setCookies = options.request.headers.getSetCookie();
+	if (setCookies.length > 1) headersObj["set-cookie"] = setCookies;
 	const req = Object.assign(createRequestReadable(options.request), {
 		method: options.request.method,
 		url: options.url,

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

@@ -13,7 +13,7 @@ import { normalizeStaticPathname } from "../routing/route-pattern.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
 import { pagesPathCacheTag } from "./pages-cache-tag.js";
 import { isPageNotModified } from "./http-conditional.js";
-import { generatePagesETag, isPagesStreamingBot, rendersPagesNotModified } from "./pages-page-response.js";
+import { applyPagesPrerenderRevalidateHeader, generatePagesETag, isPagesStreamingBot, rendersPagesNotModified } from "./pages-page-response.js";
 import { createPagesGetInitialPropsRouter, hasPagesGetInitialProps, isResponseSent, loadPagesGetInitialProps } from "./pages-get-initial-props.js";
 import { isSerializableProps } from "./pages-serializable-props.js";
 import { tracePagesData, tracePagesDocument } from "./pages-execution-tracing.js";
@@ -130,6 +130,7 @@ function applyPagesTerminalMissHeaders(response, revalidateSeconds, isrCachePath
 		tags: [pagesPathCacheTag(isrCachePathname)]
 	});
 	for (const [name, value] of Object.entries(buildCacheStateHeaders("MISS"))) response.headers.set(name, value);
+	applyPagesPrerenderRevalidateHeader(response.headers, revalidateSeconds);
 	return response;
 }
 function applyCachedPagesRepresentationHeaders(response, cacheState, entry, options) {

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

@@ -8,13 +8,14 @@ import { getRequestExecutionContext } from "../shims/request-context.js";
 import { extractLocaleFromUrl, resolvePagesI18nRequest } from "./pages-i18n.js";
 import { buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, normalizePagesDataRequest, parseNextDataPathname } from "./pages-data-route.js";
 import { reportRequestError } from "./instrumentation.js";
+import { logRequestError } from "./request-error-log.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { beginRouteCacheability, isRouteCacheabilityIdentityProbe, isRouteCacheabilityProbe, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityFinalResponseUncacheable, recordRouteCacheability } from "../shims/cacheability-classification.js";
 import { BROWSER_REVALIDATE_CACHE_CONTROL, NEVER_CACHE_CONTROL, STATIC_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy, hasExplicitNonCacheableResponsePolicy, isCdnResponsePolicyHeader, shouldUseNextDeployCacheControl } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
-import { coalesceOnDemandRevalidation, isrGet, isrSet, pagesIsrCacheKey, triggerBackgroundRegeneration } from "./isr-cache.js";
-import { ensureFetchPatch } from "../shims/fetch-cache.js";
+import { coalesceOnDemandResponse, isrGet, isrSet, pagesIsrCacheKey, triggerBackgroundRegeneration } from "./isr-cache.js";
+import { ensureFetchPatch, setCurrentFetchDraftMode } from "../shims/fetch-cache.js";
 import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
@@ -22,7 +23,7 @@ import { buildPagesReadinessNextData } from "./pages-readiness.js";
 import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
 import { pagesPathCacheTag } from "./pages-cache-tag.js";
-import { renderPagesPageResponse } from "./pages-page-response.js";
+import { applyPagesPrerenderRevalidateHeader, renderPagesPageResponse } from "./pages-page-response.js";
 import { hasPagesGetInitialProps } from "./pages-get-initial-props.js";
 import { traceFindPageComponents, tracePagesDocumentStream } from "./pages-execution-tracing.js";
 import { mergePagesNotFoundSourceHeaders, resolvePagesPageData, resolvePagesStatusPageRenderPath, setPagesResponseHeader } from "./pages-page-data.js";
@@ -244,10 +245,12 @@ function createPagesPageHandler(opts) {
 			hasRewrites
 		});
 		const isCacheabilityProbe = isRouteCacheabilityProbe();
-		if (!isRouteMissErrorRender && options?.__forcedRoute === void 0) {
+		const isTopLevelPageRoute = !isRouteMissErrorRender && options?.__forcedRoute === void 0;
+		const isInitialPropsRender = isTopLevelPageRoute && !isStaticPropsRoute && pagesReadiness.gssp !== true && (pagesReadiness.gip === true || pagesReadiness.appGip === true);
+		if (isTopLevelPageRoute) {
 			beginRouteCacheability("pages-page", route.pattern);
 			if (isRouteCacheabilityIdentityProbe()) return new Response(null, { status: 204 });
-			if (pagesReadiness.gssp !== true && pagesReadiness.gip !== true && !(pagesReadiness.appGip === true && !isStaticPropsRoute) && !isStaticPropsRoute) recordRouteCacheability({
+			if (pagesReadiness.gssp !== true && !isInitialPropsRender && !isStaticPropsRoute) recordRouteCacheability({
 				cacheable: true,
 				cacheControl: STATIC_CACHE_CONTROL
 			});
@@ -258,23 +261,10 @@ function createPagesPageHandler(opts) {
 		const isStaticPropsRender = isStaticPropsRoute && typeof pageModule.getServerSideProps !== "function";
 		if (!options?.__skipOnDemandCoalesce && !options?.__forcedRoute && !cacheIdentityDiverges && isStaticPropsRoute && isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate"))) {
 			const cacheKey = pageIsrCacheKey("pages", routeUrl.split("?")[0]);
-			const snapshot = await coalesceOnDemandRevalidation(cacheKey, async () => {
-				const response = await renderPage(request, url, manifest, middlewareHeaders, {
-					...options,
-					__skipOnDemandCoalesce: true
-				}, initialResponseHeaders);
-				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
-			});
+			return coalesceOnDemandResponse(cacheKey, request.method, () => renderPage(request, url, manifest, middlewareHeaders, {
+				...options,
+				__skipOnDemandCoalesce: true
+			}, initialResponseHeaders));
 		}
 		const routePattern = patternToNextFormat(route.pattern);
 		const renderStatusCode = renderStatusCodeOverride ?? (routePattern === "/404" ? 404 : void 0);
@@ -283,7 +273,10 @@ function createPagesPageHandler(opts) {
 		const renderRouteUrl = isStaticPropsRender && isStatusPageIdentity ? resolvePagesStatusPageRenderPath(statusPagePathname, vinextConfig.trailingSlash, originalRequestUrl.pathname) : isStaticPropsRender ? routeUrl.split("?")[0] : routeUrl;
 		const routerAsPathSource = isStaticPropsRender ? renderRouteUrl : renderAsPath ?? renderRouteUrl;
 		const routerAsPath = i18nConfig ? extractLocaleFromUrl(routerAsPathSource, i18nConfig, locale).url : routerAsPathSource;
-		const uCtx = createRequestContext({ executionContext: getRequestExecutionContext() });
+		const uCtx = createRequestContext({
+			executionContext: getRequestExecutionContext(),
+			isOnDemandRevalidate: isOnDemandRevalidateRequest(request.headers.get(PRERENDER_REVALIDATE_HEADER))
+		});
 		let pageReqRes = null;
 		const pageResponseSent = () => pageReqRes?.res.headersSent === true;
 		const sendsEarly = isStaticPropsRoute && !isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate"));
@@ -292,7 +285,7 @@ function createPagesPageHandler(opts) {
 			resolveSentResponse = resolve;
 		});
 		const reportSsrError = async (e) => {
-			console.error("[vinext] SSR error:", e);
+			logRequestError("[vinext] SSR error:", e);
 			await reportRequestError(e, {
 				path: url,
 				method: request.method,
@@ -322,6 +315,7 @@ function createPagesPageHandler(opts) {
 					shouldClear: false
 				};
 				const previewData = preview.data;
+				setCurrentFetchDraftMode(previewData !== false);
 				const pagesNextData = {
 					...pagesReadiness,
 					...previewData === false ? {} : { isPreview: true }
@@ -444,6 +438,7 @@ function createPagesPageHandler(opts) {
 						clientTraceMetadata: shouldEmitPagesClientTraceMetadata(pageModule, AppComponent) ? vinextConfig.clientTraceMetadata : void 0,
 						documentReqRes: render.documentReqRes,
 						gsspRes: render.gsspRes,
+						isInitialPropsRender,
 						isrCacheKey: pageIsrCacheKey,
 						isrCachePathname,
 						expireSeconds: render.expireSeconds,
@@ -594,6 +589,7 @@ function createPagesPageHandler(opts) {
 					notFoundResponse = stripPagesNotFoundFramingHeaders(notFoundResponse);
 					if (isOnDemandRevalidate) notFoundResponse = withPagesCacheState(notFoundResponse, "REVALIDATED", isrCachePathname);
 					else if (pageDataResult.cacheState) notFoundResponse = withPagesCacheState(notFoundResponse, pageDataResult.cacheState);
+					if (pageDataResult.revalidateSeconds !== void 0) applyPagesPrerenderRevalidateHeader(notFoundResponse.headers, pageDataResult.revalidateSeconds);
 					return finalizePagesPreviewResponse(withBrowserPolicy(notFoundResponse), preview);
 				}
 				if (pageDataResult.kind === "response") {
@@ -623,6 +619,7 @@ function createPagesPageHandler(opts) {
 				});
 				if (isDataReq) {
 					const headers = new Headers();
+					let resHasCacheControl = false;
 					if (gsspRes && typeof gsspRes.getHeaders === "function") {
 						const gsspHeaders = gsspRes.getHeaders();
 						for (const k of Object.keys(gsspHeaders)) {
@@ -631,10 +628,15 @@ function createPagesPageHandler(opts) {
 							if (k.toLowerCase() === "set-cookie" && Array.isArray(v)) for (const cookie of v) headers.append(k, String(cookie));
 							else headers.set(k, Array.isArray(v) ? v.join(", ") : String(v));
 						}
+						resHasCacheControl = headers.has("Cache-Control");
+					} else if (isInitialPropsRender && documentReqRes) {
+						const resHeaders = documentReqRes.res.getHeaders();
+						for (const [name, value] of Object.entries(resHeaders)) if (isCdnResponsePolicyHeader(name)) setPagesResponseHeader(headers, name, value);
+						resHasCacheControl = Boolean(resHeaders["cache-control"]);
 					}
 					if (hasCdnResponsePolicy(headers)) markRouteCacheabilityExplicitResponsePolicy();
-					if (gsspRes) {
-						if (!headers.has("Cache-Control")) headers.set("Cache-Control", NEVER_CACHE_CONTROL);
+					if (gsspRes || isInitialPropsRender) {
+						if (!resHasCacheControl) headers.set("Cache-Control", NEVER_CACHE_CONTROL);
 					} else if (isStaticPropsRoute) {
 						if (isrRevalidateSeconds !== null) applyCdnResponseHeaders(headers, {
 							cacheControl: buildMissIsrCacheControl(isrRevalidateSeconds, vinextConfig.expireTime),

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

@@ -17,6 +17,13 @@ export declare function generatePagesETag(payload: string): string;
  * A page whose status carries no body has nothing to store.
  */
 export declare function rendersPagesNotModified(status: number): boolean;
+/**
+ * Hand the revalidate getStaticProps returned to build/prerender.ts, which
+ * records it in vinext-prerender.json like Next.js's `initialRevalidateSeconds`.
+ * The CDN adapter may rewrite Cache-Control, so the build cannot read it there.
+ * Only build-time renders carry this header.
+ */
+export declare function applyPagesPrerenderRevalidateHeader(headers: Headers, revalidateSeconds: number | false): void;
 type PagesFontPreload = {
   href: string;
   type: string;
@@ -79,6 +86,8 @@ type RenderPagesPageResponseOptions = {
   setDocumentInitialHead?: ((head: ReactNode[]) => void) | undefined;
   documentReqRes?: PagesDocumentReqRes | null;
   gsspRes: PagesGsspResponse | null;
+  /** A page or custom `_app` getInitialProps render; rendered per request like gSSP. */
+  isInitialPropsRender?: boolean;
   isrCacheKey: (router: string, pathname: string) => string;
   /** Filesystem-route identity used for ISR persistence and cache tags. */
   isrCachePathname?: string;

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

@@ -1,7 +1,8 @@
 import { isBotUserAgent } from "../utils/html-limited-bots.js";
-import { NEXTJS_CACHE_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER } from "./headers.js";
+import { NEXTJS_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER } from "./headers.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
+import { logRequestError } from "./request-error-log.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { markRouteCacheabilityExplicitResponsePolicy } from "../shims/cacheability-classification.js";
 import { BROWSER_REVALIDATE_CACHE_CONTROL, NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy, shouldUseNextDeployCacheControl } from "./cache-control.js";
@@ -17,6 +18,7 @@ import { spliceDocumentHeadClose, spliceDocumentHeadOpen, spliceDocumentScripts,
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
 import { pagesPathCacheTag } from "./pages-cache-tag.js";
+import { applyPrerenderCacheLifeHeader } from "./prerender-cache-life-header.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { loadUserDocumentInitialProps, runDocumentRenderPage } from "./pages-document-initial-props.js";
 import { callDocumentGetInitialProps } from "./document-initial-head.js";
@@ -42,6 +44,17 @@ function generatePagesETag(payload) {
 function rendersPagesNotModified(status) {
 	return status === 204 || status === 205 || status === 304 || getCdnCacheAdapter().deferNotModifiedResponse?.() !== true;
 }
+/**
+* Hand the revalidate getStaticProps returned to build/prerender.ts, which
+* records it in vinext-prerender.json like Next.js's `initialRevalidateSeconds`.
+* The CDN adapter may rewrite Cache-Control, so the build cannot read it there.
+* Only build-time renders carry this header.
+*/
+function applyPagesPrerenderRevalidateHeader(headers, revalidateSeconds) {
+	if (typeof process === "undefined" || process.env?.VINEXT_PRERENDER !== "1") return;
+	headers.delete(VINEXT_PRERENDER_CACHE_LIFE_HEADER);
+	if (typeof revalidateSeconds === "number") applyPrerenderCacheLifeHeader(headers, { revalidate: revalidateSeconds });
+}
 function buildPagesFontHeadHtml(fontLinks, fontPreloads, fontStyles, scriptNonce) {
 	let html = "";
 	const nonceAttr = createNonceAttribute(scriptNonce);
@@ -121,7 +134,7 @@ async function buildPagesCompositeStream(bodyStream, shellPrefix, shellSuffix) {
 	} });
 }
 async function reportPagesIsrCacheWriteError(error, cacheKey, routePattern) {
-	console.error(`[vinext] Pages ISR cache write failed for ${cacheKey}:`, error);
+	logRequestError(`[vinext] Pages ISR cache write failed for ${cacheKey}:`, error);
 	try {
 		await reportRequestError(error, {
 			path: cacheKey,
@@ -284,12 +297,13 @@ async function renderPagesPageResponse(options) {
 			cacheControl: buildMissIsrCacheControl(options.isrRevalidateSeconds, options.expireSeconds),
 			tags: [pathTag]
 		});
+		applyPagesPrerenderRevalidateHeader(responseHeaders, options.isrRevalidateSeconds);
 		if (options.isOnDemandRevalidate) {
 			responseHeaders.set(NEXTJS_CACHE_HEADER, "REVALIDATED");
 			responseHeaders.set(VINEXT_REVALIDATED_CACHE_TAG_HEADER, encodeURIComponent(pathTag));
 		} 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);
+	else if ((options.gsspRes || options.isInitialPropsRender || options.isFallback) && !userSetCacheControl) responseHeaders.set("Cache-Control", NEVER_CACHE_CONTROL);
 	if (options.fontLinkHeader) responseHeaders.set("Link", options.fontLinkHeader);
 	if (options.userAgent && isPagesStreamingBot(options.userAgent)) {
 		const fullHtml = await readStreamAsText(compositeStream);
@@ -314,4 +328,4 @@ async function renderPagesPageResponse(options) {
 	}), { __vinextStreamedHtmlResponse: true });
 }
 //#endregion
-export { buildPagesNextDataScript, generatePagesETag, isPagesStreamingBot, renderPagesPageResponse, rendersPagesNotModified };
+export { applyPagesPrerenderRevalidateHeader, buildPagesNextDataScript, generatePagesETag, isPagesStreamingBot, renderPagesPageResponse, rendersPagesNotModified };

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

@@ -84,6 +84,14 @@ export type PagesPipelineDeps = {
   dataNotFoundResponse?: Response | null;
   renderPage?: ((request: Request, resolvedUrl: string, options?: PagesRenderOptions, stagedHeaders?: Headers) => Promise<Response>) | null;
   handleApi?: ((request: Request, apiUrl: string, ctx: unknown, stagedHeaders: Headers) => Promise<Response>) | null;
+  /**
+   * `handleApi` installs the staged headers on the handler's `res` before user
+   * code runs, as Next.js does, so its response already reflects any header the
+   * handler replaced and only middleware's status is applied here.
+   * Workers leaves this unset: its response stage strips the inherited cookies
+   * so they are not stored, and this merge adds them back.
+   */
+  handleApiAppliesStagedHeaders?: boolean;
   /**
    * Optional override for proxying external rewrite destinations.
    * When supplied, the pipeline calls this instead of proxyExternalRequest(currentRequest, url).

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

@@ -14,8 +14,8 @@ import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
 import { markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { mergeRewriteQuery } from "../utils/query.js";
-import { withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
 import { setFrameworkRequestRoute } from "./request-tracing.js";
+import { withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
 import { applyConfigHeadersToHeaderRecord } from "./config-headers.js";
 import { finalizeMissingStaticAssetResponse, mergeHeaders } from "./worker-utils.js";
 //#region src/server/pages-request-pipeline.ts
@@ -310,7 +310,7 @@ async function runPagesRequest(request, deps) {
 				apiRequest = cloneRequestWithUrl(request, apiRequestUrl.toString());
 			}
 			const response = await deps.handleApi(apiRequest, apiLookupUrl, deps.ctx ?? null, headersFromRecord(middlewareHeaders));
-			const merged = mergeHeaders(response, middlewareHeaders, middlewareStatus);
+			const merged = mergeHeaders(response, deps.handleApiAppliesStagedHeaders ? {} : middlewareHeaders, middlewareStatus);
 			if (merged !== response) merged.__vinextStreamedApiResponse = response.__vinextStreamedApiResponse;
 			return {
 				type: "response",