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

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

@@ -1,37 +1,157 @@
 import { normalizePathnameForRouteMatch } from "../routing/utils.js";
-import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
+import { NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
 import { isDangerousScheme } from "../shims/url-safety.js";
-import { buildCacheStateHeaders } from "./cache-headers.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
-import { decideIsr } from "./isr-decision.js";
+import { buildMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { buildPagesCacheValue } from "./isr-cache.js";
+import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { normalizeStaticPathname } from "../routing/route-pattern.js";
+import { buildCacheStateHeaders } from "./cache-headers.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, requestsNoCache } from "./pages-page-response.js";
 import { createPagesGetInitialPropsRouter, hasPagesGetInitialProps, isResponseSent, loadPagesGetInitialProps } from "./pages-get-initial-props.js";
 import { buildNextDataPropsJsonResponse } from "./pages-data-route.js";
 import { isSerializableProps } from "./pages-serializable-props.js";
-import { isBotUserAgent } from "../utils/html-limited-bots.js";
 //#region src/server/pages-page-data.ts
+const ALLOWED_PAGES_REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+/** Headers that are part of a cached Pages representation, never request state. */
+function isCachedPagesRepresentationHeader(name) {
+	const lowerName = name.toLowerCase();
+	return lowerName === "location" || lowerName === "content-type";
+}
+function assertPages404DoesNotReturnNotFound(routePattern, result) {
+	if (routePattern === "/404" && result?.notFound) throw new Error("The /404 page can not return notFound in \"getStaticProps\", please remove it to continue!");
+}
+/**
+* Next.js preserves an omitted/false Pages `revalidate` result as an indefinite
+* cache lifetime. The one-year sentinel is only an HTTP Cache-Control detail;
+* storing it as a revalidation deadline would incorrectly regenerate static
+* pages after one year.
+*
+* Next.js source:
+* - packages/next/src/server/render.tsx (`metadata.cacheControl`)
+* - packages/next/src/server/route-modules/pages/pages-handler.ts
+*/
+function resolvePagesRevalidateSeconds(result, routeUrl = "") {
+	const revalidate = result.revalidate;
+	if (revalidate === true) return 1;
+	if (typeof revalidate === "number") {
+		if (!Number.isInteger(revalidate)) throw new Error(`A page's revalidate option must be seconds expressed as a natural number for ${routeUrl}. Mixed numbers, such as '${revalidate}', cannot be used.`);
+		if (revalidate <= 0) throw new Error(`A page's revalidate option can not be less than or equal to zero for ${routeUrl}.`);
+		return revalidate;
+	}
+	if (revalidate === false || revalidate === void 0) return false;
+	throw new Error(`A page's revalidate option must be seconds expressed as a natural number. Mixed numbers and strings cannot be used. Received '${JSON.stringify(revalidate)}' for ${routeUrl}`);
+}
+function resolvePagesExpireSeconds(result, configuredExpireSeconds) {
+	return result.revalidate === false || result.revalidate === void 0 ? void 0 : configuredExpireSeconds;
+}
+/**
+* Merge gSP/gSSP data into the custom App's raw pageProps value.
+*
+* Next.js deliberately uses Object.assign rather than object spread, so
+* enumerable keys from arrays and primitive wrapper objects are retained.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/render.tsx
+*/
+function mergePagesDataProps(appPageProps, dataProps) {
+	return Object.assign({}, appPageProps, dataProps);
+}
 function buildPagesDataNotFoundResponse(deploymentId) {
 	const headers = { "Content-Type": "application/json" };
 	if (deploymentId) headers[NEXTJS_DEPLOYMENT_ID_HEADER] = deploymentId;
-	return new Response("{}", {
+	return new Response("{\"notFound\":true}", {
 		status: 404,
 		headers
 	});
 }
-function buildPagesNotFoundResult(options) {
+function buildPagesNotFoundResult(options, revalidateSeconds, cacheState, expireSeconds) {
 	if (options.isDataReq) return {
 		kind: "response",
 		response: buildPagesDataNotFoundResponse(options.deploymentId)
 	};
-	return { kind: "notFound" };
+	return {
+		kind: "notFound",
+		revalidateSeconds,
+		expireSeconds,
+		cacheState
+	};
+}
+function applyPagesTerminalMissHeaders(response, revalidateSeconds, isrCachePathname, expireSeconds) {
+	const stem = isrCachePathname.endsWith("/") ? isrCachePathname.slice(0, -1) : isrCachePathname;
+	applyCdnResponseHeaders(response.headers, {
+		cacheControl: buildMissIsrCacheControl(revalidateSeconds, expireSeconds),
+		tags: [encodeCacheTag(`_N_T_${stem || "/"}`)]
+	});
+	for (const [name, value] of Object.entries(buildCacheStateHeaders("MISS"))) response.headers.set(name, value);
+	return response;
+}
+function applyCachedPagesRepresentationHeaders(response, cacheState, entry, options) {
+	const { cacheControl } = decideIsr({
+		cacheState,
+		kind: "pages",
+		revalidateSeconds: entry.cacheControl?.revalidate ?? 60,
+		expireSeconds: entry.cacheControl?.expire === void 0 ? void 0 : options.expireSeconds,
+		cacheControlMeta: entry.cacheControl
+	});
+	applyCdnResponseHeaders(response.headers, { cacheControl });
+	for (const [name, value] of Object.entries(buildCacheStateHeaders(cacheState))) response.headers.set(name, value);
+	return response;
+}
+function buildCachedPagesNotFoundResult(options, entry, cacheState) {
+	const result = buildPagesNotFoundResult(options, entry.cacheControl?.revalidate ?? 60, cacheState, entry.cacheControl?.expire);
+	if (result.kind === "response") return {
+		kind: "response",
+		response: applyCachedPagesRepresentationHeaders(result.response, cacheState, entry, options)
+	};
+	return result;
 }
 function resolvePagesRedirectStatus(redirect) {
 	return redirect.statusCode != null ? redirect.statusCode : redirect.permanent ? 308 : 307;
 }
+/** Validate and normalize the redirect metadata returned by gSP/gSSP. */
+function resolvePagesRedirect(redirect, options) {
+	const errors = [];
+	const hasPermanent = redirect.permanent !== void 0;
+	const hasStatusCode = redirect.statusCode !== void 0;
+	if (hasPermanent && hasStatusCode) errors.push("`permanent` and `statusCode` can not both be provided");
+	else if (hasPermanent && typeof redirect.permanent !== "boolean") errors.push("`permanent` must be `true` or `false`");
+	else if (hasStatusCode && !ALLOWED_PAGES_REDIRECT_STATUS_CODES.has(redirect.statusCode)) errors.push(`\`statusCode\` must undefined or one of ${[...ALLOWED_PAGES_REDIRECT_STATUS_CODES].join(", ")}`);
+	if (typeof redirect.destination !== "string") errors.push(`\`destination\` should be string but received ${typeof redirect.destination}`);
+	if (redirect.basePath !== void 0 && typeof redirect.basePath !== "boolean") errors.push(`\`basePath\` should be undefined or a false, received ${typeof redirect.basePath}`);
+	if (errors.length > 0) throw new Error(`Invalid redirect object returned from ${options.method} for ${options.routeUrl}\n${errors.join(" and ")}\nSee more info here: https://nextjs.org/docs/messages/invalid-redirect-gssp`);
+	return {
+		destination: options.sanitizeDestination(redirect.destination),
+		statusCode: resolvePagesRedirectStatus(redirect),
+		...redirect.basePath === void 0 ? {} : { basePath: redirect.basePath }
+	};
+}
+function resolvePagesRedirectLocation(redirect, configuredBasePath = "") {
+	let destination = redirect.destination;
+	if (configuredBasePath && redirect.basePath !== false && redirect.destination.startsWith("/")) destination = `${configuredBasePath}${redirect.destination}`;
+	if (!destination.startsWith("/")) return destination;
+	const urlParts = destination.split("?");
+	return urlParts[0].replace(/\\/g, "/").replace(/\/\/+/g, "/") + (urlParts[1] ? `?${urlParts.slice(1).join("?")}` : "");
+}
+function buildPagesRedirectProps(redirect, props) {
+	return {
+		...props,
+		pageProps: {
+			...isUnknownRecord(props.pageProps) ? props.pageProps : {},
+			__N_REDIRECT: redirect.destination,
+			__N_REDIRECT_STATUS: redirect.statusCode,
+			...redirect.basePath === void 0 ? {} : { __N_REDIRECT_BASE_PATH: redirect.basePath }
+		}
+	};
+}
 function normalizePagesRenderProps(props) {
+	if (!("pageProps" in props)) return { pageProps: props };
 	return {
 		...props,
 		pageProps: props.pageProps
@@ -77,8 +197,8 @@ async function loadPagesAppInitialRenderProps(options, getSharedReqRes) {
 		response: responsePromise
 	};
 	if (initialProps) {
-		renderProps = normalizePagesRenderProps(initialProps);
-		pageProps = isUnknownRecord(renderProps.pageProps) ? renderProps.pageProps : {};
+		renderProps = initialProps;
+		pageProps = isUnknownRecord(initialProps.pageProps) ? initialProps.pageProps : {};
 	}
 	return {
 		kind: "props",
@@ -107,9 +227,14 @@ async function loadPagesAppInitialRenderProps(options, getSharedReqRes) {
 * redirects (search `__N_REDIRECT`), consumed in
 * `packages/next/src/shared/lib/router/router.ts` (`pageProps.__N_REDIRECT`).
 */
-function buildPagesRedirectResponse(redirect, options, props = { pageProps: {} }) {
-	const destination = options.sanitizeDestination(redirect.destination);
-	if (isDangerousScheme(destination)) {
+function buildPagesRedirectResponse(redirect, options, props = { pageProps: {} }, method = "getStaticProps") {
+	const resolved = resolvePagesRedirect(redirect, {
+		method,
+		routeUrl: options.routeUrl,
+		sanitizeDestination: options.sanitizeDestination
+	});
+	const redirectProps = buildPagesRedirectProps(resolved, props);
+	if (isDangerousScheme(resolved.destination)) {
 		const headers = new Headers({
 			"Cache-Control": "private, no-cache, no-store, max-age=0, must-revalidate",
 			"Content-Type": "text/plain; charset=utf-8"
@@ -123,20 +248,46 @@ function buildPagesRedirectResponse(redirect, options, props = { pageProps: {} }
 	if (options.isDataReq) {
 		const init = { headers: {} };
 		if (options.deploymentId) init.headers[NEXTJS_DEPLOYMENT_ID_HEADER] = options.deploymentId;
-		return buildNextDataPropsJsonResponse({
-			...props,
-			pageProps: {
-				...isUnknownRecord(props.pageProps) ? props.pageProps : {},
-				__N_REDIRECT: destination,
-				__N_REDIRECT_STATUS: resolvePagesRedirectStatus(redirect)
-			}
-		}, options.safeJsonStringify, init);
+		return buildNextDataPropsJsonResponse(redirectProps, options.safeJsonStringify, init);
 	}
-	return new Response(null, {
-		status: resolvePagesRedirectStatus(redirect),
-		headers: { Location: destination }
+	const location = resolvePagesRedirectLocation(resolved, options.basePath);
+	return new Response(location, {
+		status: resolved.statusCode,
+		headers: {
+			Location: location,
+			...resolved.statusCode === 308 ? { Refresh: `0;url=${location}` } : {}
+		}
 	});
 }
+function buildCachedPagesRedirectResponse(cached, options) {
+	const props = normalizePagesRenderProps(cached.props);
+	const pageProps = isUnknownRecord(props.pageProps) ? props.pageProps : {};
+	const destination = pageProps.__N_REDIRECT;
+	const statusCode = pageProps.__N_REDIRECT_STATUS;
+	const redirectBasePath = pageProps.__N_REDIRECT_BASE_PATH;
+	if (typeof destination !== "string") throw new Error("Invalid cached Pages redirect: missing __N_REDIRECT");
+	return buildPagesRedirectResponse({
+		destination,
+		...typeof statusCode === "number" ? { statusCode } : {},
+		...redirectBasePath === void 0 ? {} : { basePath: redirectBasePath }
+	}, options, props);
+}
+function getCachedPagesRedirect(cached) {
+	if (cached?.kind === "REDIRECT") return cached;
+	if (cached?.kind !== "PAGES") return null;
+	const locationHeader = cached.headers ? Object.entries(cached.headers).find(([name]) => name.toLowerCase() === "location")?.[1] : void 0;
+	const destination = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+	if (typeof destination !== "string" || typeof cached.status !== "number" || !ALLOWED_PAGES_REDIRECT_STATUS_CODES.has(cached.status)) return null;
+	const props = normalizePagesRenderProps(cached.pageData);
+	return {
+		kind: "REDIRECT",
+		props: buildPagesRedirectProps({
+			destination,
+			statusCode: cached.status,
+			basePath: false
+		}, props)
+	};
+}
 function getPagesRouteParams(routePattern) {
 	return routePattern.split("/").map((segment) => {
 		const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
@@ -179,12 +330,12 @@ function matchesPagesStaticPath(pathEntry, params, routeParams, routeUrl) {
 		return String(value) === String(actual);
 	});
 }
-function buildPagesCacheResponse(html, cacheState, fontLinkHeader, revalidateSeconds, expireSeconds, cacheControl, status) {
+function buildPagesCacheResponse(html, cacheState, fontLinkHeader, revalidateSeconds, expireSeconds, cacheControl, status, cachedHeaders) {
 	const { cacheControl: cacheControlHeader } = decideIsr({
 		cacheState,
 		kind: "pages",
 		revalidateSeconds: revalidateSeconds ?? 60,
-		expireSeconds,
+		expireSeconds: cacheControl?.expire === void 0 ? void 0 : expireSeconds,
 		cacheControlMeta: cacheControl
 	});
 	const headers = new Headers({
@@ -193,6 +344,13 @@ function buildPagesCacheResponse(html, cacheState, fontLinkHeader, revalidateSec
 	});
 	applyCdnResponseHeaders(headers, { cacheControl: cacheControlHeader });
 	if (fontLinkHeader) headers.set("Link", fontLinkHeader);
+	if (cachedHeaders) for (const [name, value] of Object.entries(cachedHeaders)) {
+		if (!isCachedPagesRepresentationHeader(name.toLowerCase())) continue;
+		if (Array.isArray(value)) {
+			headers.delete(name);
+			for (const item of value) headers.append(name, item);
+		} else headers.set(name, value);
+	}
 	return new Response(html, {
 		status: status ?? 200,
 		headers
@@ -257,6 +415,7 @@ async function resolvePagesPageData(options) {
 	const userFacingParams = options.route.isDynamic ? options.params : null;
 	let isFallback = false;
 	let shouldPersistFallbackData = false;
+	let onDemandPreviousCacheEntry;
 	const previewData = options.isOnDemandRevalidate ? false : options.previewData ?? false;
 	if (typeof options.pageModule.getStaticPaths === "function" && options.route.isDynamic) {
 		const pathsResult = await options.pageModule.getStaticPaths({
@@ -267,11 +426,29 @@ async function resolvePagesPageData(options) {
 		const paths = pathsResult?.paths ?? [];
 		const routeParams = getPagesRouteParams(options.routePattern);
 		const isValidPath = paths.some((pathEntry) => matchesPagesStaticPath(pathEntry, options.params, routeParams, options.routeUrl));
-		if (fallback === false && !isValidPath && previewData === false) return buildPagesNotFoundResult(options);
+		if (fallback === false && !isValidPath && previewData === false) {
+			if (options.isOnDemandRevalidate && !options.revalidateOnlyGenerated) return {
+				kind: "response",
+				response: new Response("This page could not be found", { status: 404 }),
+				onDemandRevalidateSuccess: false
+			};
+			return buildPagesNotFoundResult(options);
+		}
 		const isBotRequest = !!options.userAgent && isBotUserAgent(options.userAgent, options.htmlLimitedBots);
 		if (fallback === true && !isValidPath && !options.isDataReq && !isBotRequest && previewData === false) isFallback = true;
 		shouldPersistFallbackData = fallback === true && !isValidPath && options.isDataReq === true;
 	}
+	if (typeof options.pageModule.getStaticProps === "function" && options.isOnDemandRevalidate && options.revalidateOnlyGenerated) {
+		const pathname = options.isrCachePathname ?? options.routeUrl.split("?")[0];
+		onDemandPreviousCacheEntry = await options.isrGet(options.isrCacheKey("pages", pathname));
+		if (!onDemandPreviousCacheEntry) return {
+			kind: "response",
+			response: new Response("This page could not be found", {
+				status: 404,
+				headers: { [NEXTJS_CACHE_HEADER]: "REVALIDATED" }
+			})
+		};
+	}
 	let pageProps = {};
 	let gsspRes = null;
 	const previewContext = previewData === false ? {} : {
@@ -297,7 +474,7 @@ async function resolvePagesPageData(options) {
 		return null;
 	}
 	if (isFallback) {
-		const pathname = options.routeUrl.split("?")[0];
+		const pathname = options.isrCachePathname ?? options.routeUrl.split("?")[0];
 		if ((await options.isrGet(options.isrCacheKey("pages", pathname)))?.value.value?.kind !== "PAGES") {
 			const appShortCircuit = await loadForegroundAppInitialRenderProps();
 			if (appShortCircuit) return appShortCircuit;
@@ -341,10 +518,7 @@ async function resolvePagesPageData(options) {
 			response: await responsePromise
 		};
 		if (result?.props) {
-			pageProps = {
-				...pageProps,
-				...await Promise.resolve(result.props)
-			};
+			pageProps = mergePagesDataProps(renderProps.pageProps, await Promise.resolve(result.props));
 			renderProps = {
 				...renderProps,
 				pageProps
@@ -352,28 +526,22 @@ async function resolvePagesPageData(options) {
 		}
 		if (result?.redirect) return {
 			kind: "response",
-			response: buildPagesRedirectResponse(result.redirect, options, renderProps)
+			response: buildPagesRedirectResponse(result.redirect, options, renderProps, "getServerSideProps")
 		};
 		if (result?.notFound) return buildPagesNotFoundResult(options);
 		if (result?.props !== void 0 && options.validatePropsSerialization !== false) isSerializableProps(options.routePattern, "getServerSideProps", pageProps);
 		gsspRes = res;
 	}
 	let isrRevalidateSeconds = null;
+	let isrExpireSeconds;
 	if (typeof options.pageModule.getStaticProps === "function") {
-		const pathname = options.routeUrl.split("?")[0];
+		const pathname = options.isrCachePathname ?? options.routeUrl.split("?")[0];
 		const cacheKey = options.isrCacheKey("pages", pathname);
-		const cached = await options.isrGet(cacheKey);
+		const cached = onDemandPreviousCacheEntry !== void 0 ? onDemandPreviousCacheEntry : await options.isrGet(cacheKey);
 		const cachedValue = cached?.value.value;
-		if (!options.isOnDemandRevalidate && cached?.isStale === false && cachedValue?.kind === "PAGES" && !cachedValue.generatedFromDataRequest && cached && !cached.isStale && !options.scriptNonce && !options.isDataReq && previewData === false) {
-			const hitResponse = buildPagesCacheResponse(cachedValue.html, "HIT", options.fontLinkHeader, void 0, options.expireSeconds, cached.value.cacheControl, cachedValue.status);
-			const hitBotResult = applyBotETagAndCheck(hitResponse, cachedValue.html, options);
-			if (hitBotResult) return hitBotResult;
-			return {
-				kind: "response",
-				response: hitResponse
-			};
-		}
-		if (!options.isOnDemandRevalidate && cachedValue?.kind === "PAGES" && !cachedValue.generatedFromDataRequest && cached && cached.isStale && !options.scriptNonce && !options.isDataReq && previewData === false) {
+		const isLegacyCachedNotFound = cachedValue?.kind === "PAGES" && cachedValue.status === 404 && options.routePattern !== "/404" && options.routePattern !== "/_error";
+		const cachedRedirect = getCachedPagesRedirect(cachedValue);
+		const scheduleStaleRegeneration = () => {
 			options.triggerBackgroundRegeneration(cacheKey, async function() {
 				return options.runInFreshUnifiedContext(async () => {
 					options.applyRequestContexts();
@@ -388,18 +556,35 @@ async function resolvePagesPageData(options) {
 						defaultLocale: options.i18n.defaultLocale,
 						revalidateReason: "stale"
 					});
-					if (freshResult?.props) {
-						freshPageProps = {
-							...freshPageProps,
-							...freshResult.props
-						};
-						freshRenderProps = {
-							...freshRenderProps,
-							pageProps: freshPageProps
-						};
+					if (!freshResult) return;
+					assertPages404DoesNotReturnNotFound(options.routePattern, freshResult);
+					const revalidateSeconds = resolvePagesRevalidateSeconds(freshResult, options.routeUrl);
+					const expireSeconds = resolvePagesExpireSeconds(freshResult, options.expireSeconds);
+					if (freshResult.redirect) {
+						const redirect = resolvePagesRedirect(freshResult.redirect, {
+							method: "getStaticProps",
+							routeUrl: options.routeUrl,
+							sanitizeDestination: options.sanitizeDestination
+						});
+						await options.isrSet(cacheKey, {
+							kind: "REDIRECT",
+							props: buildPagesRedirectProps(redirect, freshRenderProps)
+						}, revalidateSeconds, void 0, expireSeconds);
+						return;
+					}
+					if (freshResult.notFound) {
+						await options.isrSet(cacheKey, null, revalidateSeconds, void 0, expireSeconds);
+						return;
 					}
-					const freshRevalidateSeconds = typeof freshResult?.revalidate === "number" && freshResult.revalidate > 0 ? freshResult.revalidate : cached.value.cacheControl?.revalidate;
-					if (freshResult?.props && freshRevalidateSeconds && freshRevalidateSeconds > 0) {
+					if (freshResult.props === void 0) return;
+					const resolvedFreshProps = await Promise.resolve(freshResult.props);
+					freshPageProps = mergePagesDataProps(freshRenderProps.pageProps, resolvedFreshProps);
+					freshRenderProps = {
+						...freshRenderProps,
+						pageProps: freshPageProps
+					};
+					if (options.validatePropsSerialization !== false) isSerializableProps(options.routePattern, "getStaticProps", freshPageProps);
+					if (cachedValue?.kind === "PAGES" && !cachedValue.generatedFromDataRequest) {
 						const freshHtml = await renderPagesIsrHtml({
 							buildId: options.buildId,
 							cachedHtml: cachedValue.html,
@@ -414,15 +599,61 @@ async function resolvePagesPageData(options) {
 							nextData: options.nextData,
 							vinext: options.vinext
 						});
-						await options.isrSet(cacheKey, buildPagesCacheValue(freshHtml, freshRenderProps, options.statusCode), freshRevalidateSeconds, void 0, options.expireSeconds);
+						await options.isrSet(cacheKey, buildPagesCacheValue(freshHtml, freshRenderProps, options.statusCode), revalidateSeconds, void 0, expireSeconds);
+						return;
 					}
+					await options.isrSet(cacheKey, {
+						kind: "PAGES",
+						html: "",
+						pageData: freshRenderProps,
+						generatedFromDataRequest: true,
+						headers: void 0,
+						status: void 0
+					}, revalidateSeconds, void 0, expireSeconds);
 				});
 			}, {
 				routerKind: "Pages Router",
 				routePath: options.routePattern,
 				routeType: "render"
 			});
-			const staleResponse = buildPagesCacheResponse(cachedValue.html, "STALE", options.fontLinkHeader, void 0, options.expireSeconds, cached.value.cacheControl, cachedValue.status);
+		};
+		if (!options.isOnDemandRevalidate && cached && !cached.isStale && !cached.isExpired && previewData === false) {
+			if (cachedValue === null) return buildCachedPagesNotFoundResult(options, cached.value, "HIT");
+			if (isLegacyCachedNotFound) return buildCachedPagesNotFoundResult(options, cached.value, "HIT");
+			if (cachedRedirect) return {
+				kind: "response",
+				response: applyCachedPagesRepresentationHeaders(buildCachedPagesRedirectResponse(cachedRedirect, options), "HIT", cached.value, options)
+			};
+			if (options.isDataReq && cachedValue?.kind === "PAGES") return {
+				kind: "response",
+				response: applyCachedPagesRepresentationHeaders(buildNextDataPropsJsonResponse(normalizePagesRenderProps(cachedValue.pageData), options.safeJsonStringify, options.deploymentId ? { headers: { [NEXTJS_DEPLOYMENT_ID_HEADER]: options.deploymentId } } : void 0), "HIT", cached.value, options)
+			};
+		}
+		if (!options.isOnDemandRevalidate && cached?.isStale === false && !cached.isExpired && cachedValue?.kind === "PAGES" && !cachedValue.generatedFromDataRequest && cached && !cached.isStale && !options.scriptNonce && !options.isDataReq && previewData === false) {
+			const hitResponse = buildPagesCacheResponse(cachedValue.html, "HIT", options.fontLinkHeader, void 0, options.expireSeconds, cached.value.cacheControl, cachedValue.status, cachedValue.headers);
+			const hitBotResult = applyBotETagAndCheck(hitResponse, cachedValue.html, options);
+			if (hitBotResult) return hitBotResult;
+			return {
+				kind: "response",
+				response: hitResponse
+			};
+		}
+		if (!options.isOnDemandRevalidate && cached && cached.isStale && !cached.isExpired && !options.scriptNonce && previewData === false && (cachedValue === null || cachedRedirect !== null || isLegacyCachedNotFound || options.isDataReq)) {
+			scheduleStaleRegeneration();
+			if (cachedValue === null) return buildCachedPagesNotFoundResult(options, cached.value, "STALE");
+			if (isLegacyCachedNotFound) return buildCachedPagesNotFoundResult(options, cached.value, "STALE");
+			if (cachedRedirect) return {
+				kind: "response",
+				response: applyCachedPagesRepresentationHeaders(buildCachedPagesRedirectResponse(cachedRedirect, options), "STALE", cached.value, options)
+			};
+			if (cachedValue?.kind === "PAGES") return {
+				kind: "response",
+				response: applyCachedPagesRepresentationHeaders(buildNextDataPropsJsonResponse(normalizePagesRenderProps(cachedValue.pageData), options.safeJsonStringify, options.deploymentId ? { headers: { [NEXTJS_DEPLOYMENT_ID_HEADER]: options.deploymentId } } : void 0), "STALE", cached.value, options)
+			};
+		}
+		if (!options.isOnDemandRevalidate && cachedValue?.kind === "PAGES" && !cachedValue.generatedFromDataRequest && cached && cached.isStale && !cached.isExpired && !options.scriptNonce && !options.isDataReq && previewData === false) {
+			scheduleStaleRegeneration();
+			const staleResponse = buildPagesCacheResponse(cachedValue.html, "STALE", options.fontLinkHeader, void 0, options.expireSeconds, cached.value.cacheControl, cachedValue.status, cachedValue.headers);
 			const staleBotResult = applyBotETagAndCheck(staleResponse, cachedValue.html, options);
 			if (staleBotResult) return staleBotResult;
 			return {
@@ -430,7 +661,7 @@ async function resolvePagesPageData(options) {
 				response: staleResponse
 			};
 		}
-		const generatedPageData = !options.isOnDemandRevalidate && previewData === false && cached?.isStale === false && cachedValue?.kind === "PAGES" && cachedValue.generatedFromDataRequest && isUnknownRecord(cachedValue.pageData) ? cachedValue.pageData : null;
+		const generatedPageData = !options.isOnDemandRevalidate && previewData === false && cached?.isStale === false && !cached.isExpired && cachedValue?.kind === "PAGES" && cachedValue.generatedFromDataRequest && isUnknownRecord(cachedValue.pageData) ? cachedValue.pageData : null;
 		if (!generatedPageData) {
 			const shortCircuit = await loadForegroundAppInitialRenderProps();
 			if (shortCircuit) return shortCircuit;
@@ -443,30 +674,58 @@ async function resolvePagesPageData(options) {
 			...previewContext,
 			revalidateReason: options.isOnDemandRevalidate ? "on-demand" : options.isBuildTimePrerendering ? "build" : "stale"
 		});
+		assertPages404DoesNotReturnNotFound(options.routePattern, result);
 		if (generatedPageData) {
-			renderProps = generatedPageData;
+			renderProps = normalizePagesRenderProps(generatedPageData);
 			pageProps = isUnknownRecord(renderProps.pageProps) ? renderProps.pageProps : {};
 		}
-		if (result?.props) {
-			pageProps = {
-				...pageProps,
-				...result.props
-			};
+		if (result?.props !== void 0) {
+			pageProps = mergePagesDataProps(renderProps.pageProps, await Promise.resolve(result.props));
 			renderProps = {
 				...renderProps,
 				pageProps
 			};
 		}
-		if (result?.redirect) return {
-			kind: "response",
-			response: buildPagesRedirectResponse(result.redirect, options, renderProps)
-		};
-		if (result?.notFound) return buildPagesNotFoundResult(options);
+		if (result?.redirect) {
+			const response = buildPagesRedirectResponse(result.redirect, options, renderProps);
+			if (previewData === false) {
+				const revalidateSeconds = resolvePagesRevalidateSeconds(result, options.routeUrl);
+				const expireSeconds = resolvePagesExpireSeconds(result, options.expireSeconds);
+				const redirect = resolvePagesRedirect(result.redirect, {
+					method: "getStaticProps",
+					routeUrl: options.routeUrl,
+					sanitizeDestination: options.sanitizeDestination
+				});
+				await options.isrSet(cacheKey, {
+					kind: "REDIRECT",
+					props: buildPagesRedirectProps(redirect, renderProps)
+				}, revalidateSeconds, void 0, expireSeconds);
+				applyPagesTerminalMissHeaders(response, revalidateSeconds, pathname, expireSeconds);
+			}
+			return {
+				kind: "response",
+				response
+			};
+		}
+		if (result?.notFound) {
+			const revalidateSeconds = resolvePagesRevalidateSeconds(result, options.routeUrl);
+			const expireSeconds = resolvePagesExpireSeconds(result, options.expireSeconds);
+			if (previewData === false) await options.isrSet(cacheKey, null, revalidateSeconds, void 0, expireSeconds);
+			const notFoundResult = buildPagesNotFoundResult(options, revalidateSeconds, previewData === false ? "MISS" : void 0, expireSeconds);
+			if (notFoundResult.kind === "response" && previewData === false) applyPagesTerminalMissHeaders(notFoundResult.response, revalidateSeconds, pathname, expireSeconds);
+			return notFoundResult;
+		}
 		if (result?.props !== void 0 && options.validatePropsSerialization !== false) isSerializableProps(options.routePattern, "getStaticProps", pageProps);
-		if (previewData === false && typeof result?.revalidate === "number" && result.revalidate > 0) isrRevalidateSeconds = result.revalidate;
-		else if (previewData === false && cachedValue?.kind === "PAGES" && cachedValue.generatedFromDataRequest) isrRevalidateSeconds = cached?.value.cacheControl?.revalidate ?? 31536e3;
+		if (previewData === false && result) {
+			isrRevalidateSeconds = resolvePagesRevalidateSeconds(result, options.routeUrl);
+			isrExpireSeconds = resolvePagesExpireSeconds(result, options.expireSeconds);
+		} else if (previewData === false && options.isOnDemandRevalidate) isrRevalidateSeconds = false;
+		else if (previewData === false && cachedValue?.kind === "PAGES" && cachedValue.generatedFromDataRequest) {
+			isrRevalidateSeconds = cached?.value.cacheControl?.revalidate ?? false;
+			isrExpireSeconds = cached?.value.cacheControl?.expire;
+		}
 		if (shouldPersistFallbackData && previewData === false) {
-			const revalidateSeconds = isrRevalidateSeconds ?? 31536e3;
+			const revalidateSeconds = isrRevalidateSeconds ?? false;
 			await options.isrSet(cacheKey, {
 				kind: "PAGES",
 				html: "",
@@ -474,7 +733,7 @@ async function resolvePagesPageData(options) {
 				generatedFromDataRequest: true,
 				headers: void 0,
 				status: void 0
-			}, revalidateSeconds, void 0, options.expireSeconds);
+			}, revalidateSeconds, void 0, isrExpireSeconds);
 		}
 	}
 	if (typeof options.pageModule.getServerSideProps !== "function" && typeof options.pageModule.getStaticProps !== "function" && hasPagesGetInitialProps(options.AppComponent)) {
@@ -514,10 +773,11 @@ async function resolvePagesPageData(options) {
 		documentReqRes: sharedReqRes,
 		gsspRes,
 		isrRevalidateSeconds,
+		isrExpireSeconds,
 		pageProps,
 		props: renderProps,
 		isFallback: false
 	};
 }
 //#endregion
-export { getPagesRouteParams, matchesPagesStaticPath, renderPagesIsrHtml, resolvePagesPageData };
+export { assertPages404DoesNotReturnNotFound, buildPagesRedirectProps, getPagesRouteParams, matchesPagesStaticPath, mergePagesDataProps, renderPagesIsrHtml, resolvePagesPageData, resolvePagesRedirect, resolvePagesRedirectLocation, resolvePagesRevalidateSeconds };

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

@@ -89,7 +89,11 @@ type RenderPageOptions = {
   originalUrl?: string;
   renderErrorPageOnMiss?: boolean;
   __isInternalErrorRender?: boolean;
-  __forcedRoute?: PageRoute;
+  __forcedRoute?: PageRoute; /** Source-page cache lifetime forwarded while rendering a notFound error page. */
+  __notFoundRevalidateSeconds?: number | false; /** Source-page expire ceiling forwarded for the outgoing notFound response. */
+  __notFoundExpireSeconds?: number; /** Source-page identity used for the outgoing notFound cache tag. */
+  __notFoundCachePathname?: string; /** Internal recursion guard while a top-level on-demand request owns the batch. */
+  __skipOnDemandCoalesce?: boolean;
   err?: unknown;
 };
 /**