vinext 1.0.0 → 1.0.1

package/dist/server/cacheability-request.js

@@ -348,13 +348,17 @@ async function captureCacheabilityAdmissionBody(body, deadlineAt, limit = CACHEA
 		throw error;
 	}
 }
-function responseWithCachePolicy(response, body, outcome) {
+function responseWithCachePolicy(response, body, outcome, browserCacheControl) {
 	const headers = new Headers(response.headers);
 	if (typeof body === "string") headers.delete("Content-Length");
 	applyCdnResponseHeaders(headers, outcome?.cacheable === true && outcome.cacheControl ? {
 		cacheControl: outcome.cacheControl,
-		tags: outcome.tags
-	} : { cacheControl: NO_STORE_CACHE_CONTROL });
+		tags: outcome.tags,
+		browserCacheControl
+	} : {
+		cacheControl: NO_STORE_CACHE_CONTROL,
+		browserCacheControl
+	});
 	return new Response(body, {
 		headers,
 		status: response.status,
@@ -367,21 +371,15 @@ async function stripSharedHtmlClientTraceMetadata(body, marker) {
 	const { stripClientTraceMetadataBlock } = await import("./client-trace-metadata.js");
 	return stripClientTraceMetadataBlock(html, marker);
 }
-function inferFinalAppPageCacheability(response, state) {
-	if (!state.explicitConfigCachePolicy && !state.frameworkResponseCachePolicy) return null;
-	const cacheControl = readCdnResponseCacheControl(response.headers);
-	if (cacheControl === null || !state.explicitConfigCachePolicy && cacheControl === readCdnResponseCacheControl(state.frameworkResponseCachePolicy)) return null;
-	if (isNonCacheableCacheControl(cacheControl)) return { cacheable: false };
-	return {
-		cacheable: true,
-		cacheControl,
-		...state.cdnCacheTags ? { tags: state.cdnCacheTags } : {}
-	};
-}
-function inferPagesPageCacheability(response, state) {
+/** Only an explicitly authored provider policy may override framework storage. */
+function explicitProviderOutcome(response, state) {
+	const name = readCdnResponsePolicyHeaderName(response.headers);
+	if (!name || name === "cache-control") return null;
+	const value = response.headers.get(name);
+	if (!(state.explicitResponseCachePolicy || state.configCdnCachePolicy?.get(name) === value || state.frameworkResponseCachePolicy && state.frameworkResponseCachePolicy.get(name) !== value) || !value) return null;
 	const cacheControl = readCdnResponseCacheControl(response.headers);
-	if (!cacheControl || isNonCacheableCacheControl(cacheControl)) return { cacheable: false };
-	return {
+	if (!cacheControl) return null;
+	return isNonCacheableCacheControl(cacheControl) ? { cacheable: false } : {
 		cacheable: true,
 		cacheControl,
 		...state.cdnCacheTags ? { tags: state.cdnCacheTags } : {}
@@ -397,18 +395,17 @@ function completedRouteOutcome(response, state, rendererOutcome = state.outcome
 		cacheable: false,
 		reason: varyRejectionReason
 	};
-	if (state.route?.kind === "app-route") {
-		if (response.headers.has("set-cookie")) return {
-			cacheable: false,
-			reason: "response sets a cookie"
-		};
-		return inferPagesPageCacheability(response, state);
-	}
-	if (state.route?.kind === "app-page") return inferFinalAppPageCacheability(response, state) ?? rendererOutcome;
-	if (state.route?.kind !== "pages-page") return rendererOutcome;
-	if (response.headers.has("set-cookie") || hasExplicitNonCacheableResponsePolicy(response.headers)) return { cacheable: false };
-	const responseOutcome = inferPagesPageCacheability(response, state);
-	return responseOutcome.cacheable ? responseOutcome : rendererOutcome ?? responseOutcome;
+	if (response.headers.has("set-cookie")) return {
+		cacheable: false,
+		reason: "response sets a cookie"
+	};
+	if (rendererOutcome?.dynamicUsage) return rendererOutcome;
+	const outcome = explicitProviderOutcome(response, state) ?? rendererOutcome;
+	const tags = outcome?.tags ?? rendererOutcome?.tags ?? state.cdnCacheTags;
+	return outcome && tags && outcome.tags !== tags ? {
+		...outcome,
+		tags
+	} : outcome;
 }
 function staticToDynamicResponse(route) {
 	const headers = new Headers({ "Content-Type": "text/plain; charset=utf-8" });
@@ -427,30 +424,32 @@ function cacheabilityEvaluationFailureResponse(pattern) {
 	});
 }
 function hasStrictFinalResponseVeto(response, state) {
-	if (state.finalResponseVetoReason || response.headers.has("set-cookie")) return true;
-	return hasExplicitNonCacheableResponsePolicy(response.headers, state.frameworkResponseCachePolicy);
+	const providerHeaders = new Headers(response.headers);
+	providerHeaders.delete("Cache-Control");
+	return Boolean(state.finalResponseVetoReason || response.headers.has("set-cookie") || hasExplicitNonCacheableResponsePolicy(providerHeaders, state.frameworkResponseCachePolicy));
 }
 async function finalizeWorkerCacheabilityAdmission(response, state) {
 	if (state.preserveResponseCachePolicy) return response;
+	const browserCacheControl = state.explicitResponseCachePolicy || state.configCdnCachePolicy?.has("cache-control") || state.route?.kind === "pages-api" || state.route?.kind === "pages-page" && state.outcome?.cacheable !== true ? response.headers.get("Cache-Control") ?? void 0 : void 0;
 	const admission = state.admission;
 	if (state.route?.kind === "app-route" || state.route?.kind === "pages-api") {
 		let manifestRoute = null;
-		const responseOutcome = inferPagesPageCacheability(response, state);
+		const responseOutcome = completedRouteOutcome(response, state);
 		const representation = admission?.representation ? resolveCacheabilityRepresentation(admission.representation, state.route.kind) : null;
-		const hasExplicitRuntimePolicy = state.explicitResponseCachePolicy === true || state.explicitConfigCachePolicy === true || state.route.kind === "pages-api" && responseOutcome.cacheable;
-		if (!admission || admission.policy === "deny" || !representation || !admission.requestKey) return responseWithCachePolicy(response, response.body, null);
+		const hasExplicitRuntimePolicy = responseOutcome?.cacheable === true;
+		if (!admission || admission.policy === "deny" || !representation || !admission.requestKey) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
 		if (admission.policy === "manifest" && state.route.kind === "app-route") {
 			const manifest = admission.manifest;
 			manifestRoute = findCacheabilityManifestRoute(manifest, state.route.kind, state.route.pattern);
 		}
 		const isManifestAuthorized = manifestRoute !== null && admission.routePathname !== void 0 && cacheabilityManifestRouteState(manifestRoute, admission.routePathname, representation) !== null;
 		const canUseBoundedRuntimeAdmission = hasExplicitRuntimePolicy && (admission.policy === "runtime" || admission.policy === "manifest" && !isManifestAuthorized);
-		if (!isManifestAuthorized && !canUseBoundedRuntimeAdmission || response.status >= 500 || state.credentialedRequest || state.forcedDynamicReason || hasStrictFinalResponseVeto(response, state) || cacheabilityVaryRejectionReason(response.headers, state) !== null) return responseWithCachePolicy(response, response.body, null);
+		if (!isManifestAuthorized && !canUseBoundedRuntimeAdmission || response.status >= 500 || state.credentialedRequest || state.forcedDynamicReason || hasStrictFinalResponseVeto(response, state) || cacheabilityVaryRejectionReason(response.headers, state) !== null) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
 		const outcome = responseOutcome;
-		if (!outcome.cacheable || !outcome.cacheControl) return responseWithCachePolicy(response, response.body, null);
 		if (state.completedResponseBody) {
+			if (!outcome?.cacheable || !outcome.cacheControl) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
 			if (!state.applyCompletedResponsePolicy) return response;
-			return responseWithCachePolicy(response, response.body, outcome);
+			return responseWithCachePolicy(response, response.body, outcome, browserCacheControl);
 		}
 		let captured;
 		try {
@@ -458,35 +457,36 @@ async function finalizeWorkerCacheabilityAdmission(response, state) {
 		} catch {
 			return cacheabilityEvaluationFailureResponse(state.route.pattern);
 		}
-		if (captured.kind === "fallback") return responseWithCachePolicy(response, captured.body, null);
-		return responseWithCachePolicy(response, captured.body, outcome);
+		if (captured.kind === "fallback") return responseWithCachePolicy(response, captured.body, null, browserCacheControl);
+		return responseWithCachePolicy(response, captured.body, outcome, browserCacheControl);
 	}
-	if (!admission || admission.policy === "deny" || !admission.representation || !admission.requestKey || !state.route || response.status >= 500) return responseWithCachePolicy(response, response.body, null);
+	if (!admission || admission.policy === "deny" || !admission.representation || !admission.requestKey || !state.route || response.status >= 500) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
 	const pageRoute = {
 		kind: state.route.kind,
 		pattern: state.route.pattern
 	};
 	const requestRepresentation = admission.representation;
 	const representation = resolveCacheabilityRepresentation(requestRepresentation, pageRoute.kind);
-	if (!cacheabilityRepresentationMatchesPageRoute(pageRoute.kind, representation)) return responseWithCachePolicy(response, response.body, null);
+	if (!cacheabilityRepresentationMatchesPageRoute(pageRoute.kind, representation)) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
 	let manifestRoute = null;
 	let manifestRouteState = null;
 	if (admission.policy === "manifest") {
 		const manifest = admission.manifest;
 		manifestRoute = findCacheabilityManifestRoute(manifest, pageRoute.kind, pageRoute.pattern);
 		manifestRouteState = admission.routePathname ? cacheabilityManifestPageState(manifest, pageRoute, requestRepresentation, admission.routePathname) : null;
-		if (!manifestRoute || !manifestRouteState) return responseWithCachePolicy(response, response.body, null);
+		if (!manifestRoute || !manifestRouteState) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
 	}
-	if (state.forcedDynamicReason) return responseWithCachePolicy(response, response.body, null);
-	if (hasStrictFinalResponseVeto(response, state)) return responseWithCachePolicy(response, response.body, null);
-	if (cacheabilityVaryRejectionReason(response.headers, state) !== null) return responseWithCachePolicy(response, response.body, null);
+	if (state.forcedDynamicReason) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
+	if (hasStrictFinalResponseVeto(response, state)) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
+	if (cacheabilityVaryRejectionReason(response.headers, state) !== null) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
+	if (state.route.kind === "pages-page" && !state.completion && completedRouteOutcome(response, state)?.cacheable !== true) return responseWithCachePolicy(response, response.body, null, browserCacheControl);
 	let captured;
 	try {
 		captured = await captureCacheabilityAdmissionBody(response.body, state.captureDeadlineAt, CACHEABILITY_ADMISSION_RESPONSE_BODY_LIMIT, state.captureBudget ?? isolateCaptureBudget);
 	} catch {
 		return cacheabilityEvaluationFailureResponse(state.route.pattern);
 	}
-	if (captured.kind === "fallback") return responseWithCachePolicy(response, captured.body, null);
+	if (captured.kind === "fallback") return responseWithCachePolicy(response, captured.body, null, browserCacheControl);
 	const rendererOutcome = state.completion ? await state.completion : state.outcome ?? null;
 	const outcome = completedRouteOutcome(response, state, rendererOutcome);
 	if (outcome?.cacheable !== true || !outcome.cacheControl) {
@@ -494,12 +494,12 @@ async function finalizeWorkerCacheabilityAdmission(response, state) {
 			await captured.body?.cancel().catch(() => {});
 			return staticToDynamicResponse(manifestRoute);
 		}
-		return responseWithCachePolicy(response, captured.body, null);
+		return responseWithCachePolicy(response, captured.body, null, browserCacheControl);
 	}
 	const effectivePolicyHeader = readCdnResponsePolicyHeaderName(response.headers);
 	const replacesRendererPolicy = outcome !== rendererOutcome && effectivePolicyHeader !== null && state.configCdnCachePolicy?.get(effectivePolicyHeader) === response.headers.get(effectivePolicyHeader);
-	if (state.route.kind === "app-page" && !replacesRendererPolicy && rendererOutcome?.searchParamsUnread !== true) return responseWithCachePolicy(response, captured.body, null);
-	return responseWithCachePolicy(response, representation === "html" && state.clientTraceMetadataMarker ? await stripSharedHtmlClientTraceMetadata(captured.body, state.clientTraceMetadataMarker) : captured.body, outcome);
+	if (state.route.kind === "app-page" && !replacesRendererPolicy && rendererOutcome?.searchParamsUnread !== true) return responseWithCachePolicy(response, captured.body, null, browserCacheControl);
+	return responseWithCachePolicy(response, representation === "html" && state.clientTraceMetadataMarker ? await stripSharedHtmlClientTraceMetadata(captured.body, state.clientTraceMetadataMarker) : captured.body, outcome, browserCacheControl);
 }
 async function finalizeWorkerCacheabilityResponse(response, ctx) {
 	const state = readState(ctx);

package/dist/server/config-headers.js

@@ -28,7 +28,7 @@ function markExplicitConfigResponseVeto(matched) {
 			continue;
 		}
 		if (isCdnResponsePolicyHeader(name)) markRouteCacheabilityConfigCdnCachePolicy(name, header.value);
-		if (isCdnResponsePolicyHeader(name) && isNonCacheableCdnResponsePolicy(name, header.value)) markRouteCacheabilityFinalResponseUncacheable(`next.config headers set a non-cacheable ${header.key} policy`);
+		if (name !== "cache-control" && isCdnResponsePolicyHeader(name) && isNonCacheableCdnResponsePolicy(name, header.value)) markRouteCacheabilityFinalResponseUncacheable(`next.config headers set a non-cacheable ${header.key} policy`);
 	}
 }
 function retainLastSingularConfigValues(matched) {

package/dist/server/dev-server.js

@@ -504,13 +504,17 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 				if (typeof pageModule.getStaticPaths === "function" && route.isDynamic) {
 					const pathsResult = await pageModule.getStaticPaths({
 						locales: i18nConfig?.locales ?? [],
-						defaultLocale: currentDefaultLocale ?? ""
+						defaultLocale: i18nConfig?.defaultLocale ?? ""
 					});
 					const fallback = pathsResult?.fallback ?? false;
 					const paths = pathsResult?.paths ?? [];
 					const routePattern = patternToNextFormat(route.pattern);
 					const routeParams = getPagesRouteParams(routePattern);
-					const isValidPath = paths.some((pathEntry) => matchesPagesStaticPath(pathEntry, params, routeParams, url));
+					const isValidPath = paths.some((pathEntry) => matchesPagesStaticPath(pathEntry, params, routeParams, localeStrippedUrl, {
+						locale,
+						locales: i18nConfig?.locales,
+						defaultLocale: i18nConfig?.defaultLocale
+					}));
 					if (fallback === false && !isValidPath && requestPreviewData === false) {
 						if (isDataReq) {
 							const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
@@ -745,6 +749,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 					}
 					if ((statusCode ?? 200) === 200) dataHeaders["x-nextjs-matched-path"] = `${locale ? `/${locale}` : ""}${patternToNextFormat(route.pattern)}`;
 					if (gsspExtraHeaders) for (const [k, v] of Object.entries(gsspExtraHeaders)) dataHeaders[k] = v;
+					dataHeaders["Cache-Control"] = DEV_PAGES_CACHE_CONTROL;
 					applyDevPagesPreviewHeaders(dataHeaders, requestPreview);
 					const dataRoutePattern = patternToNextFormat(route.pattern);
 					if (dataRoutePattern !== "/_error" && dataRoutePattern !== "/500") {
@@ -836,7 +841,10 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 					domainLocales,
 					...serializedPagesNextData
 				})}<\/script>`}\n  ${createInlineScriptTag(`window.__VINEXT_PAGE_PATTERNS__=${safeJsonStringify(pagePatterns)}`, scriptNonce)}\n  ${hydrationScript}`;
-				const extraHeaders = { ...gsspExtraHeaders };
+				const extraHeaders = {
+					...gsspExtraHeaders,
+					"Cache-Control": DEV_PAGES_CACHE_CONTROL
+				};
 				if (typeof pageModule.getStaticProps === "function") {
 					extraHeaders["Cache-Control"] = DEV_PAGES_CACHE_CONTROL;
 					extraHeaders[NEXTJS_CACHE_HEADER] = isFallbackRender ? "MISS" : isOnDemandRevalidate ? "REVALIDATED" : "HIT";

package/dist/server/headers.d.ts

@@ -62,6 +62,8 @@ export declare const VINEXT_RSC_COMPLETION_METADATA_HEADER = "X-Vinext-Rsc-Compl
 export declare const VINEXT_RENDERED_PATH_AND_SEARCH_HEADER = "X-Vinext-Rendered-Path-And-Search";
 /** Prerender-only JSON side channel carrying request cacheLife metadata. */
 export declare const VINEXT_PRERENDER_CACHE_LIFE_HEADER = "x-vinext-prerender-cache-life";
+/** Prerender-only Pages marker: "0" confirms the page render used the requested URL. */
+export declare const VINEXT_PRERENDER_REWRITTEN_HEADER = "x-vinext-prerender-rewritten";
 /** Marks a local prerender-server 500 that originated from a thrown render error. */
 export declare const VINEXT_PRERENDER_RENDER_ERROR_HEADER = "x-vinext-prerender-render-error";
 /** Internal marker persisted only inside metadata-route APP_ROUTE cache values. */

package/dist/server/headers.js

@@ -62,6 +62,8 @@ const VINEXT_RSC_COMPLETION_METADATA_HEADER = "X-Vinext-Rsc-Completion-Metadata"
 const VINEXT_RENDERED_PATH_AND_SEARCH_HEADER = "X-Vinext-Rendered-Path-And-Search";
 /** Prerender-only JSON side channel carrying request cacheLife metadata. */
 const VINEXT_PRERENDER_CACHE_LIFE_HEADER = "x-vinext-prerender-cache-life";
+/** Prerender-only Pages marker: "0" confirms the page render used the requested URL. */
+const VINEXT_PRERENDER_REWRITTEN_HEADER = "x-vinext-prerender-rewritten";
 /** Marks a local prerender-server 500 that originated from a thrown render error. */
 const VINEXT_PRERENDER_RENDER_ERROR_HEADER = "x-vinext-prerender-render-error";
 /** Internal marker persisted only inside metadata-route APP_ROUTE cache values. */
@@ -161,9 +163,11 @@ const VINEXT_INTERNAL_HEADERS = [
 	VINEXT_CACHEABILITY_PROBE_HEADER.toLowerCase(),
 	VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER.toLowerCase(),
 	VINEXT_EXPECTED_WORKER_VERSION_HEADER.toLowerCase(),
+	VINEXT_MW_CTX_HEADER,
 	VINEXT_PRERENDER_ROUTE_PARAMS_HEADER,
 	VINEXT_PRERENDER_SPECULATIVE_HEADER,
 	VINEXT_PRERENDER_CACHE_LIFE_HEADER,
+	VINEXT_PRERENDER_REWRITTEN_HEADER,
 	VINEXT_REVALIDATE_HOST_HEADER,
 	VINEXT_REVALIDATED_CACHE_TAG_HEADER,
 	VINEXT_TRACE_ERROR_HEADER.toLowerCase(),
@@ -171,4 +175,4 @@ const VINEXT_INTERNAL_HEADERS = [
 	VINEXT_TRACE_ROUTE_HEADER.toLowerCase()
 ];
 //#endregion
-export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_CACHE_TAGS_HEADER, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_EXPECTED_WORKER_VERSION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_READINESS_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_PRERENDER_STATIC_PARAMS_PATH, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_REVALIDATE_HOST_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER, VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER, isVinextRscVaryField };
+export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_CACHE_TAGS_HEADER, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_EXPECTED_WORKER_VERSION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_READINESS_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_REWRITTEN_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_PRERENDER_STATIC_PARAMS_PATH, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_REVALIDATE_HOST_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER, VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER, isVinextRscVaryField };

package/dist/server/http-error-responses.js

@@ -77,6 +77,7 @@ function notFoundStaticAssetResponse(headers) {
 	responseHeaders.delete("content-length");
 	responseHeaders.delete("transfer-encoding");
 	responseHeaders.set("Content-Type", "text/plain; charset=utf-8");
+	responseHeaders.set("Cache-Control", "private, no-cache, no-store, max-age=0, must-revalidate");
 	return new Response("Not Found", {
 		status: 404,
 		headers: responseHeaders

package/dist/server/isr-cache.d.ts

@@ -102,6 +102,8 @@ export declare function buildAppPageCacheValue(html: string, rscData?: ArrayBuff
  * Long pathnames are hashed to stay within KV key-length limits (512 bytes).
  */
 export declare function isrCacheKey(router: string, pathname: string, buildId?: string): string;
+/** Build and request time share the same locale-stripped Pages pathname identity. */
+export declare function pagesIsrCacheKey(pathname: string, buildId?: string, i18nCacheVariant?: string | null): string;
 /**
  * Compute an App Router ISR key for one cache artifact.
  *

package/dist/server/isr-cache.js

@@ -1,4 +1,5 @@
 import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER } from "../utils/protocol-headers.js";
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
@@ -164,6 +165,10 @@ function buildCacheKey(prefix, pathname, suffix) {
 function isrCacheKey(router, pathname, buildId) {
 	return buildCacheKey(buildId ? `${router}:${buildId}` : router, pathname);
 }
+/** Build and request time share the same locale-stripped Pages pathname identity. */
+function pagesIsrCacheKey(pathname, buildId, i18nCacheVariant) {
+	return isrCacheKey("pages:v2", normalizeCachePathname(normalizePathnameForRouteMatch(pathname)) + (i18nCacheVariant ? `::i18n=${encodeURIComponent(i18nCacheVariant)}` : ""), buildId);
+}
 /**
 * Compute an App Router ISR key for one cache artifact.
 *
@@ -206,4 +211,4 @@ function appIsrRouteKey(pathname) {
 	return appIsrCacheKey(pathname, pathname !== "/" && pathname.endsWith("/") ? "route:trailing-slash" : "route");
 }
 //#endregion
-export { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, appIsrCacheKey, appIsrHtmlKey, appIsrRouteKey, appIsrRscKey, buildAppPageCacheValue, buildPagesCacheValue, coalesceOnDemandRevalidation, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, isrCacheControl, isrCacheKey, isrGet, isrSet, isrSetPrerenderedAppPage, normalizeMountedSlotsHeader, resolveRouteExpireSeconds, triggerBackgroundRegeneration };
+export { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, appIsrCacheKey, appIsrHtmlKey, appIsrRouteKey, appIsrRscKey, buildAppPageCacheValue, buildPagesCacheValue, coalesceOnDemandRevalidation, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, isrCacheControl, isrCacheKey, isrGet, isrSet, isrSetPrerenderedAppPage, normalizeMountedSlotsHeader, pagesIsrCacheKey, resolveRouteExpireSeconds, triggerBackgroundRegeneration };

package/dist/server/metadata-route-response.js

@@ -4,23 +4,28 @@ import { decodeMatchedParams } from "../routing/utils.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { VINEXT_METADATA_ROUTE_CACHE_HEADER } from "./headers.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { beginRouteCacheability, markRouteCacheabilityExplicitResponsePolicy } from "../shims/cacheability-classification.js";
-import { hasCdnResponsePolicy, hasExplicitNonCacheableResponsePolicy } from "./cache-control.js";
+import { beginRouteCacheability, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
+import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy } from "./cache-control.js";
+import { buildAppRouteMissIsrCacheControl } from "./isr-decision.js";
 import { isrCacheControl } from "./isr-cache.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
-import { _consumeRequestScopedCacheLife, cacheLifeProfiles } from "../shims/cache-request-state.js";
+import { isRenderDynamicLatched } from "../shims/internal/headers-state.js";
+import { getActiveDraftModeState, getHeadersContext, hasDraftModeCookieHeader, replaceHeadersContext } from "../shims/headers.js";
+import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { isValidMetadataImageId, manifestToJson, matchMetadataRoutePattern, robotsToText, sitemapToXml } from "./metadata-routes.js";
 import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { canonicalizeAppPageParams } from "./app-page-segment-state.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
-import { isMetadataResponseCacheable } from "./metadata-route-cache-policy.js";
+import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
+import { completeAppRouteHandlerResponse } from "./app-route-handler-execution.js";
 //#region src/server/metadata-route-response.ts
 function isOuterMetadataCacheEnabled() {
 	return process.env.NODE_ENV !== "development";
 }
 const routeFunctionCache = /* @__PURE__ */ new WeakMap();
+const userMetadataResponses = /* @__PURE__ */ new WeakSet();
 const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
 const CACHE_HEADERS = {
 	noCache: "no-cache, no-store",
@@ -53,17 +58,19 @@ function metadataRouteCacheHeader(route) {
 	if (route.isDynamic && isImageMetadataRoute(route) && process.env.NODE_ENV === "development") return CACHE_HEADERS.noCache;
 	return CACHE_HEADERS.revalidate;
 }
-function withMetadataRouteCacheHeader(response, route) {
-	if (hasCdnResponsePolicy(response.headers) && !hasExplicitNonCacheableResponsePolicy(response.headers)) markRouteCacheabilityExplicitResponsePolicy();
-	const headers = new Headers(response.headers);
-	if (!headers.has("Cache-Control")) headers.set("Cache-Control", metadataRouteCacheHeader(route));
-	return new Response(response.body, {
-		headers,
-		status: response.status,
-		statusText: response.statusText
-	});
-}
 function beginMetadataRouteCacheability(route) {
+	const dynamic = route.module?.dynamic;
+	if (dynamic === "force-static" || dynamic === "error") {
+		const current = getHeadersContext();
+		const staticContext = createStaticGenerationHeadersContext({
+			dynamicConfig: dynamic,
+			routeKind: "route",
+			routePattern: route.servedUrl,
+			draftModeEnabled: getActiveDraftModeState() ?? void 0,
+			draftModeSecret: current?.draftModeSecret
+		});
+		replaceHeadersContext(staticContext);
+	}
 	beginRouteCacheability("app-route", route.patternParts ? `/${route.patternParts.join("/")}` : route.servedUrl);
 }
 function getMetadataRouteFunctions(route) {
@@ -137,29 +144,68 @@ function markMetadataRouteCacheValue(value) {
 function buildMetadataRouteTags(route, cleanPathname, collectedTags) {
 	return buildPageCacheTags(cleanPathname, collectedTags, route.routeSegments ?? [], "route");
 }
-function captureRenderedMetadataRoute(response) {
-	const cacheLife = _consumeRequestScopedCacheLife();
+async function captureRenderedMetadataRoute(response, route, cleanPathname) {
+	const isUserResponse = userMetadataResponses.has(response);
+	let completed = false;
+	if (isOuterMetadataCacheEnabled()) {
+		const result = await completeAppRouteHandlerResponse(response);
+		response = result.response;
+		completed = result.completed;
+		if (completed) markRouteCacheabilityResponseBodyComplete();
+	}
+	const browserCacheControl = response.headers.get("Cache-Control") ?? void 0;
+	const hasUserPolicy = isUserResponse && hasCdnResponsePolicy(response.headers);
+	if (hasUserPolicy) markRouteCacheabilityExplicitResponsePolicy();
+	const observedCacheLife = _consumeRequestScopedCacheLife();
 	const collectedTags = getCollectedFetchTags();
+	const revalidate = typeof route.module?.revalidate === "number" ? route.module.revalidate : Infinity;
+	const frameworkRevalidate = Math.min(observedCacheLife?.revalidate ?? Infinity, revalidate);
+	const cacheLife = {
+		...observedCacheLife,
+		revalidate: frameworkRevalidate
+	};
+	const cacheable = (response.status < 400 || response.status === 404) && completed && !isRenderDynamicLatched() && !getActiveDraftModeState() && !hasDraftModeCookieHeader() && route.module?.dynamic !== "force-dynamic" && frameworkRevalidate > 0 && !response.headers.has("set-cookie");
+	const cacheControl = cacheable ? buildAppRouteMissIsrCacheControl(frameworkRevalidate, cacheLife?.expire) : NEVER_CACHE_CONTROL;
+	if (isUserResponse && !hasUserPolicy) {
+		response = new Response(response.body, {
+			headers: new Headers(response.headers),
+			status: response.status,
+			statusText: response.statusText
+		});
+		applyCdnResponseHeaders(response.headers, { cacheControl: isOuterMetadataCacheEnabled() ? cacheControl : metadataRouteCacheHeader(route) });
+	}
+	recordRouteCacheability(cacheable ? {
+		cacheable: true,
+		cacheControl,
+		tags: buildMetadataRouteTags(route, cleanPathname, collectedTags)
+	} : {
+		cacheable: false,
+		dynamicUsage: true
+	});
 	if (process.env.VINEXT_PRERENDER === "1") {
-		applyPrerenderCacheLifeHeader(response.headers, cacheLife);
+		applyPrerenderCacheLifeHeader(response.headers, {
+			...cacheLife,
+			revalidate: cacheable ? frameworkRevalidate : 0
+		});
 		applyPrerenderCacheTagsHeader(response.headers, collectedTags);
 	}
 	return {
+		browserCacheControl,
 		cacheLife,
+		cacheable,
 		collectedTags,
 		response
 	};
 }
 async function writeRenderedMetadataRoute(options, route, routeKey, rendered, previousEntry) {
-	if (!options.isrSet || !rendered.response.ok || !isMetadataResponseCacheable(rendered.response)) return;
+	if (!options.isrSet || !rendered.cacheable) return;
 	const previousCacheControl = previousEntry?.value.cacheControl;
-	const defaultCacheLife = cacheLifeProfiles.default;
-	const revalidate = rendered.cacheLife?.revalidate ?? previousCacheControl?.revalidate ?? defaultCacheLife.revalidate ?? 900;
-	const expire = rendered.cacheLife?.expire ?? previousCacheControl?.expire ?? defaultCacheLife.expire;
+	const revalidate = rendered.cacheLife?.revalidate ?? previousCacheControl?.revalidate ?? (typeof route.module?.revalidate === "number" ? route.module.revalidate : false);
+	const expire = rendered.cacheLife?.expire ?? previousCacheControl?.expire;
 	const stale = resolveClientStaleTimeSeconds(rendered.cacheLife) ?? previousCacheControl?.stale;
-	const value = markMetadataRouteCacheValue(await buildAppRouteCacheValue(rendered.response));
+	const value = markMetadataRouteCacheValue(await buildAppRouteCacheValue(rendered.response, rendered.browserCacheControl));
 	await options.isrSet(routeKey, value, {
-		cacheControl: isrCacheControl(revalidate, {
+		cacheControl: isrCacheControl(revalidate === Infinity ? false : revalidate, {
 			...typeof expire === "number" ? { expireSeconds: expire } : {},
 			...typeof stale === "number" ? { staleSeconds: stale } : {}
 		}),
@@ -171,16 +217,21 @@ async function runMetadataRouteRegeneration(options, route, render, routeKey, pr
 	try {
 		await runWithRequestContext(requestContext, async () => {
 			ensureFetchPatch();
+			beginMetadataRouteCacheability(route);
 			setCurrentFetchSoftTags(buildMetadataRouteTags(route, options.cleanPathname, []));
 			const rendered = await render();
-			if (rendered) await writeRenderedMetadataRoute(options, route, routeKey, rendered, previousEntry);
+			if (rendered) try {
+				await writeRenderedMetadataRoute(options, route, routeKey, rendered, previousEntry);
+			} finally {
+				rendered.response.body?.cancel().catch(() => {});
+			}
 		});
 	} finally {
 		await closeAfterResponse(requestContext);
 	}
 }
-async function readMatchedPrerenderedMetadataRouteResponse(options, route, functions, render) {
-	if (!isOuterMetadataCacheEnabled() || !options.isrGet || !options.isrRouteKey) return {
+async function readMatchedPrerenderedMetadataRouteResponse(options, route, render) {
+	if (!isOuterMetadataCacheEnabled() || !options.isrGet || !options.isrRouteKey || getActiveDraftModeState() || hasDraftModeCookieHeader() || route.module?.dynamic === "force-dynamic" || route.module?.revalidate === 0) return {
 		cachedEntry: null,
 		response: null
 	};
@@ -214,7 +265,7 @@ async function readMatchedPrerenderedMetadataRouteResponse(options, route, funct
 			revalidateSeconds
 		})
 	};
-	if (isUseCacheFunction(functions.defaultExport) && options.isrSet && options.scheduleBackgroundRegeneration) {
+	if (options.isrSet && options.scheduleBackgroundRegeneration) {
 		const executionContext = getRequestExecutionContext();
 		options.scheduleBackgroundRegeneration(routeKey, () => runMetadataRouteRegeneration(options, route, render, routeKey, cached, executionContext), {
 			routerKind: "App Router",
@@ -330,7 +381,10 @@ async function handleGeneratedSitemap(route, cleanPathname, functions) {
 	const matchedId = findGeneratedSitemapId(await functions.generateSitemaps({}), rawId);
 	if (!matchedId) return notFoundResponse();
 	const result = await functions.defaultExport({ id: makeThenableMetadataRouteId(matchedId) });
-	if (result instanceof Response) return withMetadataRouteCacheHeader(result, route);
+	if (result instanceof Response) {
+		userMetadataResponses.add(result);
+		return result;
+	}
 	if (!isSitemapEntries(result)) throw new TypeError("Metadata sitemap routes must return an array.");
 	return markFullyBufferedBody(new Response(sitemapToXml(result), { headers: {
 		"Content-Type": route.contentType,
@@ -367,7 +421,10 @@ async function callDynamicMetadataRoute(route, match, makeThenableParams, functi
 			id: makeThenableMetadataRouteId(matchedImageId)
 		});
 	} else result = await functions.defaultExport({ params: paramsThenable });
-	if (result instanceof Response) return withMetadataRouteCacheHeader(result, route);
+	if (result instanceof Response) {
+		userMetadataResponses.add(result);
+		return result;
+	}
 	let body;
 	if (route.type === "sitemap") {
 		if (!isSitemapEntries(result)) throw new TypeError("Metadata sitemap routes must return an array.");
@@ -410,8 +467,8 @@ function isMetadataRouteRequestPath(metadataRoutes, cleanPathname) {
 	}
 	return false;
 }
-async function writeMetadataRouteMiss(options, route, functions, rendered, cachedEntry) {
-	if (process.env.VINEXT_PRERENDER === "1" || !isOuterMetadataCacheEnabled() || !rendered.response.ok || !isMetadataResponseCacheable(rendered.response) || !isUseCacheFunction(functions.defaultExport) || !options.isrRouteKey || !options.isrSet) return;
+async function writeMetadataRouteMiss(options, route, rendered, cachedEntry) {
+	if (process.env.VINEXT_PRERENDER === "1" || !isOuterMetadataCacheEnabled() || !rendered.cacheable || !options.isrRouteKey || !options.isrSet) return;
 	try {
 		await writeRenderedMetadataRoute(options, route, options.isrRouteKey(options.cleanPathname), {
 			...rendered,
@@ -433,13 +490,13 @@ async function handleMetadataRouteRequest(options) {
 					const render = async () => {
 						setCurrentFetchSoftTags(buildMetadataRouteTags(route, options.cleanPathname, []));
 						const response = await handleGeneratedSitemap(route, options.cleanPathname, functions);
-						return response ? captureRenderedMetadataRoute(response) : null;
+						return response ? captureRenderedMetadataRoute(response, route, options.cleanPathname) : null;
 					};
-					const cached = await readMatchedPrerenderedMetadataRouteResponse(options, route, functions, render);
+					const cached = await readMatchedPrerenderedMetadataRouteResponse(options, route, render);
 					if (cached.response) return cached.response;
 					const rendered = await render();
 					if (rendered) {
-						await writeMetadataRouteMiss(options, route, functions, rendered, cached.cachedEntry);
+						await writeMetadataRouteMiss(options, route, rendered, cached.cachedEntry);
 						return rendered.response;
 					}
 				}
@@ -471,12 +528,12 @@ async function handleMetadataRouteRequest(options) {
 		}
 		const render = async () => {
 			setCurrentFetchSoftTags(buildMetadataRouteTags(route, options.cleanPathname, []));
-			return captureRenderedMetadataRoute(route.isDynamic ? await callDynamicMetadataRoute(route, match, options.makeThenableParams, functions) : serveStaticMetadataRoute(route));
+			return captureRenderedMetadataRoute(route.isDynamic ? await callDynamicMetadataRoute(route, match, options.makeThenableParams, functions) : serveStaticMetadataRoute(route), route, options.cleanPathname);
 		};
-		const cached = await readMatchedPrerenderedMetadataRouteResponse(options, route, functions, render);
+		const cached = await readMatchedPrerenderedMetadataRouteResponse(options, route, render);
 		if (cached.response) return cached.response;
 		const rendered = await render();
-		await writeMetadataRouteMiss(options, route, functions, rendered, cached.cachedEntry);
+		await writeMetadataRouteMiss(options, route, rendered, cached.cachedEntry);
 		return rendered.response;
 	}
 	return null;

package/dist/server/pages-api-route.js

@@ -3,6 +3,8 @@ import "./server-globals.js";
 import { NextRequest } from "../shims/server.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
 import { cloneRequestWithUrl } from "./request-pipeline.js";
+import { markRouteCacheabilityExplicitResponsePolicy } from "../shims/cacheability-classification.js";
+import { hasCdnResponsePolicy } from "./cache-control.js";
 import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { tracePagesApiHandler } from "./pages-execution-tracing.js";
 import { resolveBodyParserConfig } from "./pages-body-parser-config.js";
@@ -29,8 +31,12 @@ function isNodeApiRouteModule(module) {
 	return typeof module.default === "function" && !isEdgeApiRuntime(resolveModuleRuntime(module));
 }
 async function handlePagesApiRoute(options) {
-	if (options.ctx) return runWithExecutionContext(options.ctx, () => _handlePagesApiRoute(options));
-	return _handlePagesApiRoute(options);
+	const run = async () => {
+		const response = await _handlePagesApiRoute(options);
+		if (hasCdnResponsePolicy(response.headers)) markRouteCacheabilityExplicitResponsePolicy();
+		return response;
+	};
+	return options.ctx ? runWithExecutionContext(options.ctx, run) : run();
 }
 async function _handlePagesApiRoute(options) {
 	if (!options.match) return new Response("404 - API route not found", { status: 404 });

package/dist/server/pages-asset-tags.d.ts

@@ -9,6 +9,7 @@
  * unit-testable and lives in a normal typed module rather than a codegen
  * template string.
  */
+export declare function getSharedChunkFiles(manifest: Record<string, string[]>): string[];
 /**
  * Resolve the effective SSR manifest: prefer the caller-supplied object and
  * fall back to the registered client build metadata.