vinext 1.0.0 → 1.1.0

package/dist/server/cacheability-request.js

@@ -1,6 +1,6 @@
 import "../utils/protocol-headers.js";
 import { isVinextRscVaryField } from "./app-rsc-vary.js";
-import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER } from "./headers.js";
+import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER } from "./headers.js";
 import { isNonCacheableCacheControl } from "../shims/cdn-cache.js";
 import { CACHEABILITY_REQUEST_STATE, recordConfigCdnCachePolicyHeader } from "../shims/cacheability-classification.js";
 import { NO_STORE_CACHE_CONTROL, applyCdnResponseBuildIdentityHeaders, applyCdnResponseHeaders, hasExplicitNonCacheableResponsePolicy, isCdnResponsePolicyHeader, readCdnResponseCacheControl, readCdnResponsePolicyHeaderName } from "./cache-control.js";
@@ -348,17 +348,25 @@ async function captureCacheabilityAdmissionBody(body, deadlineAt, limit = CACHEA
 		throw error;
 	}
 }
-function responseWithCachePolicy(response, body, outcome) {
+function responseWithCachePolicy(response, body, outcome, browserCacheControl, completedStatus) {
 	const headers = new Headers(response.headers);
 	if (typeof body === "string") headers.delete("Content-Length");
+	for (const [name, value] of Object.entries(completedStatus?.headers ?? {})) if (!headers.has(name)) headers.set(name, value);
 	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
+	});
+	const status = completedStatus?.status ?? response.status;
+	const completed = completedStatus?.status;
+	if (completed === 401 || completed === 403 || completed === 404) headers.set(VINEXT_SPECIAL_ERROR_STATUS_HEADER, String(completed));
 	return new Response(body, {
 		headers,
-		status: response.status,
-		statusText: response.statusText
+		status,
+		statusText: status === response.status ? response.statusText : ""
 	});
 }
 async function stripSharedHtmlClientTraceMetadata(body, marker) {
@@ -367,21 +375,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 +399,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 +428,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 +461,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 +498,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, rendererOutcome ?? void 0);
 }
 async function finalizeWorkerCacheabilityResponse(response, ctx) {
 	const state = readState(ctx);

package/dist/server/config-headers.js

@@ -1,4 +1,5 @@
 import { matchHeaders } from "../config/config-matchers.js";
+import "./headers.js";
 import { markRouteCacheabilityConfigCdnCachePolicy, markRouteCacheabilityDynamic, markRouteCacheabilityFinalResponseUncacheable } from "../shims/cacheability-classification.js";
 import { isCdnResponsePolicyHeader, isNonCacheableCdnResponsePolicy } from "./cache-control.js";
 import { mergeVaryHeader } from "./middleware-response-headers.js";
@@ -28,7 +29,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) {
@@ -77,6 +78,7 @@ function applyConfigHeadersToResponse(responseHeaders, options) {
 	if (options.recordCacheability !== false) markExplicitConfigResponseVeto(matched);
 	for (const header of matched) {
 		const lowerName = header.key.toLowerCase();
+		if (lowerName === "x-vinext-special-error-status") continue;
 		if (lowerName === "link") {
 			if (options.middlewareHeaders?.get(lowerName)) continue;
 			const postConfigLink = options.appendToPostConfigLink ? responseHeaders.get(lowerName) : null;

package/dist/server/dev-server.js

@@ -21,6 +21,7 @@ import { createInlineScriptTag, createNonceAttribute, safeJsonStringify } from "
 import { applyDocumentAssetProps, extractDocumentAssetProps, markDocumentAssetPropsProtectedTags, stripDocumentAssetPropsProtectionMarkers } from "./pages-document-asset-props.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
 import { getScriptNonceFromNodeHeaderSources } from "./csp.js";
+import { stripViteModuleQuery } from "../utils/path.js";
 import { logRequest, now } from "./request-log.js";
 import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
 import { buildPagesReadinessNextData } from "./pages-readiness.js";
@@ -148,6 +149,15 @@ function stripDevPagesNotFoundFramingHeaders(res) {
 	res.removeHeader("Transfer-Encoding");
 }
 /**
+* Vite's `transformIndexHtml` treats its URL as the HTML document's path, so
+* the request query carries no meaning there. Since Vite 8.3.3 it also maps
+* `/?q` onto the project root directory and then watches the filesystem root
+* for each inline `<style>` proxy module, so pass the bare path.
+*/
+function toHtmlTransformPath(url) {
+	return stripViteModuleQuery(url);
+}
+/**
 * Stream a Pages Router page response using progressive SSR.
 *
 * Sends the HTML shell (head, layout, Suspense fallbacks) immediately
@@ -244,7 +254,7 @@ async function streamPageToResponseImpl(routePattern, res, element, options) {
 </body>
 </html>`;
 	}
-	let transformedShell = await server.transformIndexHtml(url, shellTemplate);
+	let transformedShell = await server.transformIndexHtml(toHtmlTransformPath(url), shellTemplate);
 	transformedShell = stripDocumentAssetPropsProtectionMarkers(applyDocumentAssetProps(transformedShell, documentAssetProps, {
 		configuredCrossOrigin: crossOrigin,
 		protectedAssetMarker,
@@ -504,13 +514,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 +759,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 +851,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";
@@ -1122,7 +1140,7 @@ async function renderErrorPage(server, runner, req, res, url, pagesDir, statusCo
   ${protectedErrorScripts}
 </body>
 </html>`;
-				const transformedHtml = stripDocumentAssetPropsProtectionMarkers(applyDocumentAssetProps(await server.transformIndexHtml(url, html), {}, {
+				const transformedHtml = stripDocumentAssetPropsProtectionMarkers(applyDocumentAssetProps(await server.transformIndexHtml(toHtmlTransformPath(url), html), {}, {
 					configuredCrossOrigin: context.crossOrigin,
 					protectedAssetMarker
 				}), protectedAssetMarker);

package/dist/server/headers.d.ts

@@ -58,12 +58,28 @@ export declare const VINEXT_PARAMS_HEADER = "X-Vinext-Params";
 export declare const VINEXT_DYNAMIC_STALE_TIME_HEADER = "X-Vinext-Dynamic-Stale-Time";
 /** Marks an RSC body carrying completion metadata after the Flight payload. */
 export declare const VINEXT_RSC_COMPLETION_METADATA_HEADER = "X-Vinext-Rsc-Completion-Metadata";
+/**
+ * Carries the stored status of an App page RSC response whose 401, 403 or 404
+ * is its page's notFound(), forbidden() or unauthorized(). Middleware and
+ * config headers can't set it, and the request stage strips it.
+ */
+export declare const VINEXT_SPECIAL_ERROR_STATUS_HEADER = "x-vinext-special-error-status";
 /** URL-encoded rendered path and search after middleware/config rewrites. */
 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";
+/**
+ * Prerender-only marker: the response's 401, 403, 404 or redirect is its page's
+ * notFound(), forbidden(), unauthorized() or redirect(), which escaped the shell.
+ * Its value is the JSON of the headers to store: a redirect's own location, or
+ * `{}`. Only the prerender server sets it, from the special error the page
+ * recorded on its ctx, and it drops one that the response carries.
+ */
+export declare const VINEXT_PRERENDER_SPECIAL_ERROR_HEADER = "x-vinext-prerender-special-error";
 /** Internal marker persisted only inside metadata-route APP_ROUTE cache values. */
 export declare const VINEXT_METADATA_ROUTE_CACHE_HEADER = "x-vinext-metadata-route-cache";
 /** Disabled-by-default client hint describing already-held App Router payload entries. */

package/dist/server/headers.js

@@ -58,12 +58,28 @@ const VINEXT_PARAMS_HEADER = "X-Vinext-Params";
 const VINEXT_DYNAMIC_STALE_TIME_HEADER = "X-Vinext-Dynamic-Stale-Time";
 /** Marks an RSC body carrying completion metadata after the Flight payload. */
 const VINEXT_RSC_COMPLETION_METADATA_HEADER = "X-Vinext-Rsc-Completion-Metadata";
+/**
+* Carries the stored status of an App page RSC response whose 401, 403 or 404
+* is its page's notFound(), forbidden() or unauthorized(). Middleware and
+* config headers can't set it, and the request stage strips it.
+*/
+const VINEXT_SPECIAL_ERROR_STATUS_HEADER = "x-vinext-special-error-status";
 /** URL-encoded rendered path and search after middleware/config rewrites. */
 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";
+/**
+* Prerender-only marker: the response's 401, 403, 404 or redirect is its page's
+* notFound(), forbidden(), unauthorized() or redirect(), which escaped the shell.
+* Its value is the JSON of the headers to store: a redirect's own location, or
+* `{}`. Only the prerender server sets it, from the special error the page
+* recorded on its ctx, and it drops one that the response carries.
+*/
+const VINEXT_PRERENDER_SPECIAL_ERROR_HEADER = "x-vinext-prerender-special-error";
 /** Internal marker persisted only inside metadata-route APP_ROUTE cache values. */
 const VINEXT_METADATA_ROUTE_CACHE_HEADER = "x-vinext-metadata-route-cache";
 /** Disabled-by-default client hint describing already-held App Router payload entries. */
@@ -161,9 +177,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 +189,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_SPECIAL_ERROR_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_SPECIAL_ERROR_STATUS_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/image-optimization.d.ts

@@ -117,6 +117,22 @@ export declare const IMAGE_CONTENT_SECURITY_POLICY = "script-src 'none'; frame-s
  * Returns false for SVG (unless dangerouslyAllowSVG is true), HTML, or any non-image type.
  */
 export declare function isSafeImageContentType(contentType: string | null, dangerouslyAllowSVG?: boolean): boolean;
+/**
+ * Cache state for a successful image response, sent as both `X-Nextjs-Cache`
+ * and `X-Vinext-Cache`.
+ *
+ * Next.js keeps optimized images in an image cache and labels each 200 with
+ * where the bytes came from: `MISS` when the optimizer ran for this request,
+ * `HIT` or `STALE` when the cache served them. vinext has no image cache on any
+ * runtime, so every successful response is transformed (or passed through) from
+ * the source for the request that receives it. Next.js behaves the same way
+ * when its image cache is disabled (`images.maximumDiskCacheSize: 0`): every
+ * 200 is a `MISS`. `HIT` and `STALE` need a cache of optimized images.
+ *
+ * Next.js sets the header after its ETag check, so a 304 and error responses
+ * go out without it. Only full image responses carry either header here too.
+ */
+export declare const IMAGE_RESPONSE_CACHE_STATE = "MISS";
 /**
  * Handlers for image optimization I/O operations.
  * Workers provide these callbacks to adapt their specific bindings.

package/dist/server/image-optimization.js

@@ -1,4 +1,5 @@
 import { badRequestResponse } from "./http-error-responses.js";
+import { setCacheStateHeaders } from "./cache-headers.js";
 //#region src/server/image-optimization.ts
 /**
 * Image optimization request handler.
@@ -182,11 +183,32 @@ function setImageSecurityHeaders(headers, config) {
 	headers.set("X-Content-Type-Options", "nosniff");
 	headers.set("Content-Disposition", config?.contentDispositionType === "attachment" ? "attachment" : "inline");
 }
-function createPassthroughImageResponse(source, config) {
-	const headers = new Headers(source.headers);
+/**
+* Cache state for a successful image response, sent as both `X-Nextjs-Cache`
+* and `X-Vinext-Cache`.
+*
+* Next.js keeps optimized images in an image cache and labels each 200 with
+* where the bytes came from: `MISS` when the optimizer ran for this request,
+* `HIT` or `STALE` when the cache served them. vinext has no image cache on any
+* runtime, so every successful response is transformed (or passed through) from
+* the source for the request that receives it. Next.js behaves the same way
+* when its image cache is disabled (`images.maximumDiskCacheSize: 0`): every
+* 200 is a `MISS`. `HIT` and `STALE` need a cache of optimized images.
+*
+* Next.js sets the header after its ETag check, so a 304 and error responses
+* go out without it. Only full image responses carry either header here too.
+*/
+const IMAGE_RESPONSE_CACHE_STATE = "MISS";
+/** Headers shared by every successful image response, transformed or not. */
+function setImageResponseHeaders(headers, config) {
 	headers.set("Cache-Control", IMAGE_CACHE_CONTROL);
 	headers.set("Vary", "Accept");
 	setImageSecurityHeaders(headers, config);
+	setCacheStateHeaders(headers, IMAGE_RESPONSE_CACHE_STATE);
+}
+function createPassthroughImageResponse(source, config) {
+	const headers = new Headers(source.headers);
+	setImageResponseHeaders(headers, config);
 	return new Response(source.body, {
 		status: 200,
 		headers
@@ -216,9 +238,7 @@ async function handleImageOptimization(request, handlers, allowedWidths, imageCo
 			quality
 		});
 		const headers = new Headers(transformed.headers);
-		headers.set("Cache-Control", IMAGE_CACHE_CONTROL);
-		headers.set("Vary", "Accept");
-		setImageSecurityHeaders(headers, imageConfig);
+		setImageResponseHeaders(headers, imageConfig);
 		if (!isSafeImageContentType(headers.get("Content-Type"), imageConfig?.dangerouslyAllowSVG)) headers.set("Content-Type", format);
 		return new Response(transformed.body, {
 			status: 200,
@@ -287,4 +307,4 @@ function handleConfiguredImageOptimization(request, fetchAsset, allowedWidths, i
 	}, allowedWidths, imageConfig);
 }
 //#endregion
-export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, VINEXT_IMAGE_OPTIMIZATION_PATH, getImageOptimizer, handleConfiguredImageOptimization, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams, resolveDevImageRedirect, setImageOptimizer };
+export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, IMAGE_RESPONSE_CACHE_STATE, VINEXT_IMAGE_OPTIMIZATION_PATH, getImageOptimizer, handleConfiguredImageOptimization, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams, resolveDevImageRedirect, setImageOptimizer };

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,11 +1,12 @@
 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 { isInterceptionMatchedUrlPath } from "./normalize-path.js";
 import { reportRequestError } from "./instrumentation.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION, getRscRenderModeCacheVariant } from "./app-rsc-render-mode.js";
-import { normalizeAppPageInterceptionProofPathname } from "./app-page-render-identity.js";
 import { getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret } from "./revalidation-request.js";
 //#region src/server/isr-cache.ts
 /**
@@ -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.
 *
@@ -178,7 +183,7 @@ function appIsrHtmlKey(pathname) {
 	return appIsrCacheKey(pathname, "html");
 }
 function normalizeInterceptionContextForCacheKey(interceptionContext) {
-	return normalizeAppPageInterceptionProofPathname(interceptionContext);
+	return isInterceptionMatchedUrlPath(interceptionContext) ? interceptionContext : null;
 }
 /**
 * Build the ISR cache key for an RSC payload.
@@ -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 };