vinext 1.0.0-beta.7 → 1.0.0-beta.9

package/dist/server/app-route-handler-execution.js

@@ -1,15 +1,77 @@
-import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
+import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, hasExplicitNonCacheableResponsePolicy } from "./cache-control.js";
 import { isrCacheControl } from "./isr-cache.js";
 import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
 import { copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
+import { CACHEABILITY_POLICY_HEADERS, getRouteCacheabilityCaptureOptions, getRouteCacheabilityDynamicReason, isRouteCacheabilityEvaluation, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete } from "../shims/cacheability-classification.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
-import { runWithRootParamsUsage } from "../shims/root-params.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import { runWithRootParamsUsage } from "../shims/root-params.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
-import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
+import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldCompleteAppRouteHandlerResponse, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
+import { CACHEABILITY_ADMISSION_RESPONSE_BODY_LIMIT } from "./cacheability-limits.js";
 //#region src/server/app-route-handler-execution.ts
+function hasExplicitCacheableResponsePolicy(headers) {
+	return !hasExplicitNonCacheableResponsePolicy(headers) && CACHEABILITY_POLICY_HEADERS.some((name) => headers.has(name));
+}
+async function completeAppRouteHandlerResponse(response) {
+	const { captureCacheabilityAdmissionBody } = await import("./cacheability-request.js");
+	const captureOptions = getRouteCacheabilityCaptureOptions();
+	const captured = await captureCacheabilityAdmissionBody(response.body, captureOptions?.captureDeadlineAt ?? Date.now() + 2e4, CACHEABILITY_ADMISSION_RESPONSE_BODY_LIMIT, captureOptions?.captureBudget);
+	const completed = new Response(captured.body, {
+		headers: response.headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+	copyLinkHeaderProvenance(response.headers, completed.headers);
+	return {
+		completed: captured.kind === "captured",
+		response: completed
+	};
+}
+function deferAppRouteHandlerCleanup(response, cleanup) {
+	if (!response.body) {
+		cleanup();
+		return response;
+	}
+	const reader = response.body.getReader();
+	let cleaned = false;
+	const cleanOnce = async () => {
+		if (cleaned) return;
+		cleaned = true;
+		reader.releaseLock();
+		await cleanup();
+	};
+	const body = new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await reader.read();
+				if (result.done) {
+					await cleanOnce();
+					controller.close();
+				} else controller.enqueue(result.value);
+			} catch (error) {
+				await cleanOnce();
+				controller.error(error);
+			}
+		},
+		async cancel(reason) {
+			try {
+				await reader.cancel(reason);
+			} finally {
+				await cleanOnce();
+			}
+		}
+	}, { highWaterMark: 0 });
+	const deferred = new Response(body, {
+		headers: response.headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+	copyLinkHeaderProvenance(response.headers, deferred.headers);
+	return deferred;
+}
 function applyDraftModeCachePolicy(response, isDraftMode) {
 	if (!isDraftMode) return response;
 	const headers = new Headers(response.headers);
@@ -54,13 +116,16 @@ async function runAppRouteHandler(options) {
 		kind: "route-handler",
 		routePattern: options.routePattern ?? new URL(options.request.url).pathname
 	}, () => options.handlerFn(trackedRequest.request, { params: options.params }));
+	const dynamicUsedInContext = options.consumeDynamicUsage();
 	return {
-		dynamicUsedInHandler: options.consumeDynamicUsage(),
+		didAccessDynamicRequest: () => trackedRequest.didAccessDynamicRequest(),
+		dynamicUsedInHandler: trackedRequest.didAccessDynamicRequest() || dynamicUsedInContext,
 		response
 	};
 }
 async function executeAppRouteHandler(options) {
 	const previousHeadersPhase = options.setHeadersAccessPhase("route-handler");
+	let cleanupDeferredToBody = false;
 	const middlewareMergeOptions = { appendResponseLink: options.handler.runtime === "edge" || options.handler.runtime === "experimental-edge" };
 	try {
 		let handlerResult;
@@ -72,19 +137,44 @@ async function executeAppRouteHandler(options) {
 		} finally {
 			await _drainPendingRevalidations();
 		}
-		const { dynamicUsedInHandler, response } = handlerResult;
+		let { dynamicUsedInHandler, response } = handlerResult;
 		assertSupportedAppRouteHandlerResponse(response);
-		const handlerSetCacheControl = response.headers.has("cache-control");
+		const handlerSetCachePolicy = CACHEABILITY_POLICY_HEADERS.some((name) => response.headers.has(name));
+		const hasExplicitCacheablePolicy = hasExplicitCacheableResponsePolicy(response.headers);
+		if (hasExplicitCacheablePolicy) markRouteCacheabilityExplicitResponsePolicy();
+		const draftModeBeforeCompletion = options.getActiveDraftModeState?.() ?? options.isDraftMode === true;
+		const handlerDraftCookieBeforeCompletion = options.getDraftModeCookieHeader() ?? options.initialDraftModeCookie;
+		if (shouldCompleteAppRouteHandlerResponse({
+			dynamicConfig: options.handler.dynamic,
+			dynamicUsedInHandler,
+			hasExplicitCacheablePolicy,
+			handlerSetCachePolicy,
+			isAutoHead: options.isAutoHead,
+			isDraftMode: draftModeBeforeCompletion || handlerDraftCookieBeforeCompletion != null,
+			isProduction: options.isProduction,
+			method: options.method,
+			revalidateSeconds: options.revalidateSeconds,
+			requiresCompletedResponseAdmission: isRouteCacheabilityEvaluation()
+		})) {
+			const completed = await completeAppRouteHandlerResponse(response);
+			response = completed.response;
+			cleanupDeferredToBody = !completed.completed;
+			if (completed.completed) markRouteCacheabilityResponseBodyComplete();
+			const dynamicUsedDuringCompletion = options.consumeDynamicUsage();
+			dynamicUsedInHandler = handlerResult.didAccessDynamicRequest() || dynamicUsedDuringCompletion || dynamicUsedInHandler;
+		}
+		const requestCacheabilityVeto = getRouteCacheabilityDynamicReason();
+		const responseMustStayPrivate = Boolean(options.handler.dynamic === "force-dynamic" || dynamicUsedInHandler || requestCacheabilityVeto || cleanupDeferredToBody);
 		if (dynamicUsedInHandler) markKnownDynamicAppRoute(options.routePattern);
 		const pendingCookies = options.getAndClearPendingCookies();
-		const handlerDraftCookie = options.getDraftModeCookieHeader();
+		const handlerDraftCookie = options.getDraftModeCookieHeader() ?? handlerDraftCookieBeforeCompletion;
 		const draftCookie = handlerDraftCookie ?? options.initialDraftModeCookie;
 		const shouldApplyDraftPolicy = (options.getActiveDraftModeState?.() ?? options.isDraftMode === true) || draftCookie != null;
 		if (handlerDraftCookie != null) markKnownDynamicAppRoute(options.routePattern);
 		const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
 		if (shouldApplyAppRouteHandlerRevalidateHeader({
-			dynamicUsedInHandler,
-			handlerSetCacheControl,
+			dynamicUsedInHandler: responseMustStayPrivate,
+			handlerSetCachePolicy,
 			isAutoHead: options.isAutoHead,
 			isDraftMode: shouldApplyDraftPolicy,
 			method: options.method,
@@ -96,8 +186,8 @@ async function executeAppRouteHandler(options) {
 		}
 		if (shouldWriteAppRouteHandlerCache({
 			dynamicConfig: options.handler.dynamic,
-			dynamicUsedInHandler,
-			handlerSetCacheControl,
+			dynamicUsedInHandler: responseMustStayPrivate,
+			handlerSetCachePolicy,
 			isAutoHead: options.isAutoHead,
 			isDraftMode: shouldApplyDraftPolicy,
 			isProduction: options.isProduction,
@@ -123,12 +213,35 @@ async function executeAppRouteHandler(options) {
 			})();
 			options.executionContext?.waitUntil(routeWritePromise);
 		}
-		options.clearRequestContext();
-		return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(response, {
+		let finalized = applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(response, {
 			pendingCookies,
 			draftCookie,
 			isHead: options.isAutoHead
 		}), options.middlewareContext, middlewareMergeOptions), shouldApplyDraftPolicy);
+		const preserveHandlerPolicy = isRouteCacheabilityEvaluation() ? hasExplicitCacheablePolicy : handlerSetCachePolicy;
+		if (responseMustStayPrivate && !preserveHandlerPolicy) {
+			const headers = new Headers(finalized.headers);
+			applyCdnResponseHeaders(headers, { cacheControl: NEVER_CACHE_CONTROL });
+			finalized = new Response(finalized.body, {
+				headers,
+				status: finalized.status,
+				statusText: finalized.statusText
+			});
+			copyLinkHeaderProvenance(response.headers, finalized.headers);
+		}
+		if (!cleanupDeferredToBody) {
+			options.clearRequestContext();
+			return finalized;
+		}
+		return deferAppRouteHandlerCleanup(finalized, async () => {
+			try {
+				await _drainPendingRevalidations();
+				options.consumeDynamicUsage();
+			} finally {
+				options.clearRequestContext();
+				options.setHeadersAccessPhase(previousHeadersPhase);
+			}
+		});
 	} catch (error) {
 		const pendingCookies = options.getAndClearPendingCookies();
 		const handlerDraftCookie = options.getDraftModeCookieHeader();
@@ -160,7 +273,7 @@ async function executeAppRouteHandler(options) {
 		});
 		return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(new Response(null, { status: 500 }), options.middlewareContext, middlewareMergeOptions), shouldApplyDraftPolicy);
 	} finally {
-		options.setHeadersAccessPhase(previousHeadersPhase);
+		if (!cleanupDeferredToBody) options.setHeadersAccessPhase(previousHeadersPhase);
 	}
 }
 //#endregion

package/dist/server/app-route-handler-policy.d.ts

@@ -4,6 +4,7 @@ import { RouteHandlerHttpMethod, RouteHandlerModule } from "./app-route-handler-
 type AppRouteHandlerModule = {
   dynamic?: string;
   fetchCache?: unknown;
+  generateStaticParams?: unknown;
   revalidate?: unknown;
   runtime?: string;
 } & RouteHandlerModule;
@@ -28,12 +29,14 @@ type AppRouteHandlerCacheReadOptions = {
 type AppRouteHandlerResponseCacheOptions = {
   dynamicConfig?: string;
   dynamicUsedInHandler: boolean;
-  handlerSetCacheControl: boolean;
+  hasExplicitCacheablePolicy?: boolean;
+  handlerSetCachePolicy: boolean;
   isAutoHead: boolean;
   isDraftMode?: boolean;
   isProduction: boolean;
   method: string;
   revalidateSeconds: number | null;
+  requiresCompletedResponseAdmission?: boolean;
 };
 type AppRouteHandlerSpecialError = {
   kind: "redirect";
@@ -46,12 +49,21 @@ type AppRouteHandlerSpecialError = {
 type AppRouteHandlerSpecialErrorOptions = {
   isAction: boolean;
 };
-declare function getAppRouteHandlerRevalidateSeconds(handler: Pick<AppRouteHandlerModule, "revalidate">): number | null;
+declare function getAppRouteHandlerRevalidateSeconds(handler: Pick<AppRouteHandlerModule, "dynamic" | "generateStaticParams" | "revalidate">): number | null;
 declare function hasAppRouteHandlerDefaultExport(handler: RouteHandlerModule): boolean;
+/** Match Next.js methods that force an App Route out of static generation. */
+declare function hasNonStaticAppRouteHandlerMethods(handler: RouteHandlerModule): boolean;
 declare function resolveAppRouteHandlerMethod(handler: AppRouteHandlerModule, method: string): ResolvedAppRouteHandlerMethod;
 declare function shouldReadAppRouteHandlerCache(options: AppRouteHandlerCacheReadOptions): boolean;
 declare function shouldApplyAppRouteHandlerRevalidateHeader(options: Omit<AppRouteHandlerResponseCacheOptions, "dynamicConfig" | "isProduction">): boolean;
+/**
+ * Next.js consumes the full body before completing static generation for an
+ * App Route. Keep that completion boundary for every response that can still
+ * receive a public framework cache policy, including
+ * `revalidate = false` (represented by Infinity).
+ */
+declare function shouldCompleteAppRouteHandlerResponse(options: AppRouteHandlerResponseCacheOptions): boolean;
 declare function shouldWriteAppRouteHandlerCache(options: AppRouteHandlerResponseCacheOptions): boolean;
 declare function resolveAppRouteHandlerSpecialError(error: unknown, requestUrl: string, options?: AppRouteHandlerSpecialErrorOptions): AppRouteHandlerSpecialError | null;
 //#endregion
-export { AppRouteHandlerModule, getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };
+export { AppRouteHandlerModule, getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldCompleteAppRouteHandlerResponse, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };

package/dist/server/app-route-handler-policy.js

@@ -5,12 +5,18 @@ import { buildRouteHandlerAllowHeader, collectRouteHandlerMethods } from "./app-
 function getAppRouteHandlerRevalidateSeconds(handler) {
 	const { revalidate } = handler;
 	if (revalidate === false) return Infinity;
-	if (typeof revalidate !== "number" || !Number.isFinite(revalidate) || revalidate < 0) return null;
-	return revalidate;
+	if (typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate >= 0) return revalidate;
+	if (revalidate !== void 0) return null;
+	if (handler.dynamic === "force-static" || handler.dynamic === "error" || typeof handler.generateStaticParams === "function") return Infinity;
+	return null;
 }
 function hasAppRouteHandlerDefaultExport(handler) {
 	return typeof handler.default === "function";
 }
+/** Match Next.js methods that force an App Route out of static generation. */
+function hasNonStaticAppRouteHandlerMethods(handler) {
+	return Boolean(handler.POST || handler.PUT || handler.DELETE || handler.PATCH || handler.OPTIONS);
+}
 function resolveAppRouteHandlerMethod(handler, method) {
 	const exportedMethods = collectRouteHandlerMethods(handler);
 	const allowHeaderForOptions = buildRouteHandlerAllowHeader(exportedMethods);
@@ -33,7 +39,16 @@ function shouldReadAppRouteHandlerCache(options) {
 	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity && options.dynamicConfig !== "force-dynamic" && !options.isDraftMode && !options.isKnownDynamic && (options.method === "GET" || options.isAutoHead) && typeof options.handlerFn === "function";
 }
 function shouldApplyAppRouteHandlerRevalidateHeader(options) {
-	return options.revalidateSeconds !== null && !options.isDraftMode && !options.dynamicUsedInHandler && (options.method === "GET" || options.isAutoHead) && !options.handlerSetCacheControl;
+	return options.revalidateSeconds !== null && !options.isDraftMode && !options.dynamicUsedInHandler && (options.method === "GET" || options.isAutoHead) && !options.handlerSetCachePolicy;
+}
+/**
+* Next.js consumes the full body before completing static generation for an
+* App Route. Keep that completion boundary for every response that can still
+* receive a public framework cache policy, including
+* `revalidate = false` (represented by Infinity).
+*/
+function shouldCompleteAppRouteHandlerResponse(options) {
+	return options.isProduction && (options.revalidateSeconds !== null && options.revalidateSeconds > 0 || options.requiresCompletedResponseAdmission === true || options.hasExplicitCacheablePolicy === true) && options.dynamicConfig !== "force-dynamic" && !options.isDraftMode && !options.dynamicUsedInHandler && (options.method === "GET" || options.isAutoHead);
 }
 function shouldWriteAppRouteHandlerCache(options) {
 	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.revalidateSeconds !== Infinity && options.dynamicConfig !== "force-dynamic" && !options.isDraftMode && shouldApplyAppRouteHandlerRevalidateHeader(options);
@@ -55,4 +70,4 @@ function resolveAppRouteHandlerSpecialError(error, requestUrl, options) {
 	return null;
 }
 //#endregion
-export { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };
+export { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, isPossibleAppRouteActionRequest, resolveAppRouteHandlerMethod, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldCompleteAppRouteHandlerResponse, shouldReadAppRouteHandlerCache, shouldWriteAppRouteHandlerCache };

package/dist/server/app-route-tree-prefetch.js

@@ -1,6 +1,6 @@
-import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
+import { NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_RSC_VARY_HEADER } from "./headers.js";
 import { getDeploymentId } from "../utils/deployment-id.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 //#region src/server/app-route-tree-prefetch.ts
 const PARENT_INLINED_INTO_SELF = 32;
 const INLINED_INTO_CHILD = 64;

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

@@ -1,27 +1,65 @@
-import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import "./server-globals.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { applyCdnResponseIdentityHeaders, validateCdnRequest } from "./cache-control.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { createStaticAssetRequest, finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
-import rscHandler, { __assetPrefix, __basePath, __imageAllowedWidths, __imageConfig } from "virtual:vinext-rsc-entry";
+import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
+import rscHandler, { __assetPrefix, __basePath, __cacheabilityManifest, __imageAllowedWidths, __imageConfig, __prerenderSecret } from "virtual:vinext-rsc-entry";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
 //#region src/server/app-router-entry.ts
 const __workerBasePath = typeof __basePath === "string" ? __basePath : "";
 const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "string" ? __assetPrefix : "");
+function isPotentialCompletedAdmissionRequest(request) {
+	if (request.method !== "GET" && request.method !== "HEAD") return false;
+	if (request.headers.has("next-action") || request.headers.has("x-rsc-action")) return false;
+	return true;
+}
 var app_router_entry_default = { async fetch(request, env, ctx) {
-	return handleRequest(request, env, ctx);
+	return applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request);
 } };
 async function handleRequest(request, env, platformCtx) {
-	const ctx = platformCtx?.trustedRevalidateOrigin ? platformCtx : createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx));
+	const requestCtx = platformCtx?.trustedRevalidateOrigin ? platformCtx : createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx));
 	registerConfiguredCacheAdapters(env);
+	const cdnCacheAdapter = getCdnCacheAdapter();
+	let ctx = createWorkerPrerenderDiscoveryContext(requestCtx, request, __prerenderSecret);
+	const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
+	if (readinessResponse) return await validateCdnRequest(request) ?? readinessResponse;
+	let finalizeCacheabilityResponse;
+	if (request.headers.has("X-Vinext-Cacheability-Probe")) {
+		const cacheability = await import("./cacheability-request.js");
+		const probeContext = cacheability.createWorkerCacheabilityContext(ctx, request, __prerenderSecret, cdnCacheAdapter.responseVary);
+		if (probeContext !== ctx) {
+			ctx = probeContext;
+			finalizeCacheabilityResponse = cacheability.finalizeWorkerCacheabilityResponse;
+			const probeUrl = new URL(request.url);
+			if (probeUrl.searchParams.has("__vinext_cacheability_probe")) {
+				probeUrl.searchParams.delete(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM);
+				request = new Request(probeUrl, request);
+			}
+		}
+	}
+	const requiresCompletedResponseAdmission = cdnCacheAdapter.requiresCompletedResponseAdmission === true;
+	if (!finalizeCacheabilityResponse && (__cacheabilityManifest || requiresCompletedResponseAdmission) && isPotentialCompletedAdmissionRequest(request)) {
+		const cacheability = await import("./cacheability-request.js");
+		const admissionContext = cacheability.createWorkerCacheabilityAdmissionContext(ctx, request, __cacheabilityManifest, process.env.__VINEXT_BUILD_ID, requiresCompletedResponseAdmission, cdnCacheAdapter.responseVary);
+		if (admissionContext !== ctx) {
+			ctx = admissionContext;
+			finalizeCacheabilityResponse = cacheability.finalizeWorkerCacheabilityResponse;
+		}
+	}
 	registerConfiguredImageOptimizer(env);
+	const cdnValidationResponse = await validateCdnRequest(request);
+	if (cdnValidationResponse) return cdnValidationResponse;
 	const url = new URL(request.url);
 	if (isImageOptimizationPath(url.pathname) && env?.ASSETS && getImageOptimizer()) {
 		const assetFetcher = env.ASSETS;
@@ -37,6 +75,7 @@ async function handleRequest(request, env, platformCtx) {
 	{
 		const trustedPrerenderRouteParams = ctx.hostRuntime === "node" ? readTrustedPrerenderRouteParams(request) : null;
 		const filteredHeaders = ctx.isInternalPagesRevalidation ? new Headers(request.headers) : filterInternalHeaders(request.headers);
+		filteredHeaders.delete(VINEXT_PRERENDER_SECRET_HEADER);
 		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
 		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(trustedPrerenderRouteParams);
 		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
@@ -51,10 +90,15 @@ async function handleRequest(request, env, platformCtx) {
 			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(createStaticAssetRequest(path, request))) });
 			if (assetResponse) response = assetResponse;
 		}
-		return finalizeMissingStaticAssetResponse(response, missingBuildAsset);
+		response = finalizeMissingStaticAssetResponse(response, missingBuildAsset);
+		return finalizeCacheabilityResponse ? finalizeCacheabilityResponse(response, ctx) : response;
+	}
+	if (result === null || result === void 0) {
+		const response = missingBuildAsset ? notFoundStaticAssetResponse() : notFoundResponse();
+		return finalizeCacheabilityResponse ? finalizeCacheabilityResponse(response, ctx) : response;
 	}
-	if (result === null || result === void 0) return missingBuildAsset ? notFoundStaticAssetResponse() : notFoundResponse();
-	return new Response(String(result), { status: 200 });
+	const response = new Response(String(result), { status: 200 });
+	return finalizeCacheabilityResponse ? finalizeCacheabilityResponse(response, ctx) : response;
 }
 //#endregion
 export { app_router_entry_default as default };

package/dist/server/app-rsc-cache-busting.d.ts

@@ -1,4 +1,4 @@
-import { VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
+import { VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER } from "./headers.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppRscStateFingerprintInput } from "./app-rsc-state-fingerprint.js";
 //#region src/server/app-rsc-cache-busting.d.ts
@@ -9,9 +9,9 @@ import { AppRscStateFingerprintInput } from "./app-rsc-state-fingerprint.js";
  * repeated canonicalization redirects.
  */
 declare const VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM = "_rsc";
+declare const VINEXT_RSC_BUILD_ID_HEADER = "X-Vinext-RSC-Build-Id";
 declare const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
 declare const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
-declare const VINEXT_RSC_VARY_HEADER: string;
 type CreateRscRequestHeadersOptions = {
   clientReuseManifestHeader?: string | null;
   interceptionContext?: string | null;
@@ -26,13 +26,14 @@ type CreateRscRequestHeadersOptions = {
     routeId: string;
   } | null;
   routerState?: AppRscStateFingerprintInput | null;
+  deploymentId?: string | null;
 };
 type ResolveInvalidRscCacheBustingRequestOptions = {
   isRscRequest: boolean;
   request: Request;
 };
 declare function getVinextRscCompatibilityId(): string | null;
-declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined): void;
+declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined, buildId?: string | null | undefined): void;
 declare function applyRscDeploymentIdHeader(headers: Headers): void;
 declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
 type RscCompatibilityNavigationDecision = {
@@ -65,10 +66,27 @@ declare function stripRscCacheBustingSearchParam(url: URL): void;
  * unchanged when the suffix is absent.
  */
 declare function stripRscSuffix(pathname: string): string;
+declare function createCanonicalRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
+/** Headers for the deterministic loading-boundary prefetch representation. */
+declare function createCanonicalLoadingShellRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
 declare function createRscRequestHeaders(options?: CreateRscRequestHeadersOptions): Headers;
+/**
+ * Convert a full, non-contextual navigation request to the definitive ISR RSC
+ * variant. Partial/intercepted/mounted-slot payloads remain contextual because
+ * their bytes can legitimately differ from the destination's full route.
+ */
+declare function canonicalizePrewarmableRscRequestHeaders(headers: Headers): boolean;
+/**
+ * Convert an ordinary loading-boundary prefetch to the shared loading-shell
+ * variant. The payload is selected by the three retained mode headers; visible
+ * router state is transport context and must not fragment the shared response.
+ */
+declare function canonicalizeLoadingShellRscRequestHeaders(headers: Headers): boolean;
 declare function createRscRequestUrl(href: string, headers: Headers): Promise<string>;
+/** Build the definitive full-route RSC URL shared by prefetch and navigation. */
+declare function createCanonicalRscRequestUrl(href: string): string;
 declare function createServerActionRequestUrl(href: string): string;
 declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
 declare function resolveInvalidRscCacheBustingRequest(options: ResolveInvalidRscCacheBustingRequestOptions): Promise<Response | null>;
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_BUILD_ID_HEADER, VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, computeRscCacheBustingSearchParam, createCanonicalLoadingShellRscRequestHeaders, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

package/dist/server/app-rsc-cache-busting.js

@@ -1,6 +1,6 @@
-import { NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER } from "./headers.js";
+import { NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER } from "./headers.js";
 import { fnv1a64 } from "../utils/hash.js";
-import { parseAppRscRenderMode } from "./app-rsc-render-mode.js";
+import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
 import { applyDeploymentIdHeader, getDeploymentId } from "../utils/deployment-id.js";
 import { createAppRscStateFingerprint } from "./app-rsc-state-fingerprint.js";
 //#region src/server/app-rsc-cache-busting.ts
@@ -11,20 +11,9 @@ import { createAppRscStateFingerprint } from "./app-rsc-state-fingerprint.js";
 * repeated canonicalization redirects.
 */
 const VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM = "_rsc";
+const VINEXT_RSC_BUILD_ID_HEADER = "X-Vinext-RSC-Build-Id";
 const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
 const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
-const VINEXT_RSC_VARY_HEADER = [
-	"RSC",
-	NEXT_ROUTER_STATE_TREE_HEADER,
-	NEXT_ROUTER_PREFETCH_HEADER,
-	NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
-	NEXT_URL_HEADER,
-	VINEXT_INTERCEPTION_CONTEXT_HEADER,
-	VINEXT_INTERCEPTION_ID_HEADER,
-	VINEXT_MOUNTED_SLOTS_HEADER,
-	VINEXT_RSC_RENDER_MODE_HEADER,
-	VINEXT_RSC_STATE_FINGERPRINT_HEADER
-].join(", ");
 const CACHE_BUSTING_DIGEST_BYTES = 12;
 const textEncoder = new TextEncoder();
 function encodeBase64Url(bytes) {
@@ -41,10 +30,16 @@ function normalizeCompatibilityId(value) {
 function getVinextRscCompatibilityId() {
 	return normalizeCompatibilityId(process.env.__VINEXT_RSC_COMPATIBILITY_ID);
 }
-function applyRscCompatibilityIdHeader(headers, compatibilityId = getVinextRscCompatibilityId()) {
+function getVinextRscBuildId() {
+	return normalizeCompatibilityId(process.env.__VINEXT_RSC_BUILD_IDENTITY);
+}
+function applyRscCompatibilityIdHeader(headers, compatibilityId = getVinextRscCompatibilityId(), buildId = getVinextRscBuildId()) {
 	const normalized = normalizeCompatibilityId(compatibilityId);
 	if (normalized) headers.set(VINEXT_RSC_COMPATIBILITY_ID_HEADER, normalized);
 	else headers.delete(VINEXT_RSC_COMPATIBILITY_ID_HEADER);
+	const normalizedBuildId = normalizeCompatibilityId(buildId);
+	if (normalizedBuildId) headers.set(VINEXT_RSC_BUILD_ID_HEADER, normalizedBuildId);
+	else headers.delete(VINEXT_RSC_BUILD_ID_HEADER);
 }
 function applyRscDeploymentIdHeader(headers) {
 	const deploymentId = getDeploymentId();
@@ -147,12 +142,24 @@ function stripRscCacheBustingSearchParam(url) {
 function stripRscSuffix(pathname) {
 	return pathname.endsWith(".rsc") ? pathname.slice(0, -4) : pathname;
 }
-function createRscRequestHeaders(options = {}) {
+function createCanonicalRscRequestHeaders(deploymentId = getDeploymentId()) {
 	const headers = new Headers({
 		Accept: VINEXT_RSC_CONTENT_TYPE,
 		["RSC"]: "1"
 	});
-	applyDeploymentIdHeader(headers);
+	applyDeploymentIdHeader(headers, deploymentId ?? void 0);
+	return headers;
+}
+/** Headers for the deterministic loading-boundary prefetch representation. */
+function createCanonicalLoadingShellRscRequestHeaders(deploymentId = getDeploymentId()) {
+	const headers = createCanonicalRscRequestHeaders(deploymentId);
+	headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+	headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
+	headers.set(VINEXT_RSC_RENDER_MODE_HEADER, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL);
+	return headers;
+}
+function createRscRequestHeaders(options = {}) {
+	const headers = createCanonicalRscRequestHeaders(options.deploymentId);
 	if (options.prefetchRouterState) {
 		if (options.includePrefetchHeader !== false) headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
 		headers.set(NEXT_ROUTER_STATE_TREE_HEADER, encodeURIComponent(JSON.stringify(options.prefetchRouterState)));
@@ -169,15 +176,58 @@ function createRscRequestHeaders(options = {}) {
 	if (renderMode !== "navigation") headers.set(VINEXT_RSC_RENDER_MODE_HEADER, renderMode);
 	return headers;
 }
+/**
+* Convert a full, non-contextual navigation request to the definitive ISR RSC
+* variant. Partial/intercepted/mounted-slot payloads remain contextual because
+* their bytes can legitimately differ from the destination's full route.
+*/
+function canonicalizePrewarmableRscRequestHeaders(headers) {
+	if (headers.has("X-Vinext-Rsc-Render-Mode") || headers.has("X-Vinext-Interception-Context") || headers.has("X-Vinext-Interception-Id") || headers.has("X-Vinext-Mounted-Slots")) return false;
+	headers.delete(NEXT_ROUTER_PREFETCH_HEADER);
+	headers.delete(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER);
+	headers.delete(NEXT_ROUTER_STATE_TREE_HEADER);
+	headers.delete(NEXT_URL_HEADER);
+	headers.delete(VINEXT_RSC_STATE_FINGERPRINT_HEADER);
+	headers.delete(VINEXT_CLIENT_REUSE_MANIFEST_HEADER);
+	return true;
+}
+/**
+* Convert an ordinary loading-boundary prefetch to the shared loading-shell
+* variant. The payload is selected by the three retained mode headers; visible
+* router state is transport context and must not fragment the shared response.
+*/
+function canonicalizeLoadingShellRscRequestHeaders(headers) {
+	if (headers.get("X-Vinext-Rsc-Render-Mode") !== "prefetch-loading-shell" || headers.has("X-Vinext-Interception-Context") || headers.has("X-Vinext-Interception-Id") || headers.has("X-Vinext-Mounted-Slots")) return false;
+	headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+	headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
+	headers.delete(NEXT_ROUTER_STATE_TREE_HEADER);
+	headers.delete(NEXT_URL_HEADER);
+	headers.delete(VINEXT_RSC_STATE_FINGERPRINT_HEADER);
+	headers.delete(VINEXT_CLIENT_REUSE_MANIFEST_HEADER);
+	return true;
+}
 function toRscRequestPath(href) {
 	const hashIndex = href.indexOf("#");
 	return hashIndex === -1 ? href : href.slice(0, hashIndex);
 }
 async function createRscRequestUrl(href, headers) {
 	const url = new URL(toRscRequestPath(href), "http://vinext.local");
+	if (typeof window !== "undefined" && process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export") {
+		const basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
+		const isBasePathRoot = basePath !== "" && url.pathname === basePath;
+		if (url.pathname.endsWith("/")) url.pathname += "index.txt";
+		else url.pathname += isBasePathRoot ? "/index.txt" : ".txt";
+		return `${url.pathname}${url.search}`;
+	}
 	setRscCacheBustingSearchParam(url, await computeRscCacheBustingSearchParam(headers));
 	return `${url.pathname}${url.search}`;
 }
+/** Build the definitive full-route RSC URL shared by prefetch and navigation. */
+function createCanonicalRscRequestUrl(href) {
+	const url = new URL(toRscRequestPath(href), "http://vinext.local");
+	setRscCacheBustingSearchParam(url, "");
+	return `${url.pathname}${url.search}`;
+}
 function createServerActionRequestUrl(href) {
 	const hashIndex = href.indexOf("#");
 	const beforeHash = hashIndex === -1 ? href : href.slice(0, hashIndex);
@@ -247,4 +297,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_BUILD_ID_HEADER, VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, computeRscCacheBustingSearchParam, createCanonicalLoadingShellRscRequestHeaders, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

package/dist/server/app-rsc-handler.d.ts

@@ -38,10 +38,12 @@ type AppRscHandlerRoute = {
   slots?: AppRouteTreePrefetchRoute["slots"];
 };
 type AppRscRouteMatch<TRoute> = {
+  interceptionSourceIsConcrete?: boolean;
   params: AppPageParams;
   route: TRoute;
 };
 type DispatchMatchedPageOptions<TRoute> = {
+  bypassInterceptionContextCache: boolean;
   clientReuseManifest: ClientReuseManifestParseResult;
   cleanPathname: string;
   displayPathname: string;