vinext 1.0.0-beta.8 → 1.0.0

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-handler-response.d.ts

@@ -1,6 +1,6 @@
 import { CacheControlMetadata, CachedRouteValue } from "../shims/cache-handler.js";
 //#region src/server/app-route-handler-response.d.ts
-type RouteHandlerMiddlewareContext = {
+export type RouteHandlerMiddlewareContext = {
   headers: Headers | null;
   status: number | null;
 };
@@ -16,14 +16,13 @@ type FinalizeRouteHandlerResponseOptions = {
   draftCookie?: string | null;
   isHead: boolean;
 };
-declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: {
+export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: {
   appendResponseLink?: boolean;
 }): Response;
-declare function assertSupportedAppRouteHandlerResponse(response: Response): void;
-declare function buildRouteHandlerCachedResponse(cachedValue: CachedRouteValue, options: BuildRouteHandlerCachedResponseOptions): Response;
-declare function applyRouteHandlerRevalidateHeader(response: Response, revalidateSeconds: number, expireSeconds?: number, tags?: readonly string[]): void;
-declare function markRouteHandlerCacheMiss(response: Response): void;
-declare function buildAppRouteCacheValue(response: Response): Promise<CachedRouteValue>;
-declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
-//#endregion
-export { RouteHandlerMiddlewareContext, applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss };
+export declare function assertSupportedAppRouteHandlerResponse(response: Response): void;
+export declare function buildRouteHandlerCachedResponse(cachedValue: CachedRouteValue, options: BuildRouteHandlerCachedResponseOptions): Response;
+export declare function applyRouteHandlerRevalidateHeader(response: Response, revalidateSeconds: number, expireSeconds?: number, tags?: readonly string[]): void;
+export declare function markRouteHandlerCacheMiss(response: Response): void;
+export declare function buildAppRouteCacheValue(response: Response): Promise<CachedRouteValue>;
+export declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
+//#endregion

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

@@ -1,6 +1,7 @@
 import "../utils/protocol-headers.js";
 import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER } from "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
+import { markRouteCacheabilityExplicitConfigPolicy } from "../shims/cacheability-classification.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
@@ -56,6 +57,7 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 	});
 }
 function applyRouteHandlerRevalidateHeader(response, revalidateSeconds, expireSeconds, tags) {
+	markRouteCacheabilityExplicitConfigPolicy();
 	applyCdnResponseHeaders(response.headers, {
 		cacheControl: buildAppRouteMissIsrCacheControl(revalidateSeconds, expireSeconds),
 		tags

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

@@ -2,8 +2,8 @@ import { NextI18nConfig } from "../config/next-config.js";
 import { NextRequest } from "../shims/server.js";
 //#region src/server/app-route-handler-runtime.d.ts
 declare const ROUTE_HANDLER_HTTP_METHODS: readonly ["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
-type RouteHandlerHttpMethod = (typeof ROUTE_HANDLER_HTTP_METHODS)[number];
-type RouteHandlerModule = Partial<Record<RouteHandlerHttpMethod | "default", unknown>>;
+export type RouteHandlerHttpMethod = (typeof ROUTE_HANDLER_HTTP_METHODS)[number];
+export type RouteHandlerModule = Partial<Record<RouteHandlerHttpMethod | "default", unknown>>;
 /**
  * Checks whether a string is a recognized HTTP method for App Router route
  * handlers. Invalid methods must be rejected with 400 before any auto-OPTIONS
@@ -11,11 +11,11 @@ type RouteHandlerModule = Partial<Record<RouteHandlerHttpMethod | "default", unk
  *
  * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/web/http.ts
  */
-declare function isValidHTTPMethod(maybeMethod: string): maybeMethod is RouteHandlerHttpMethod;
-declare function collectRouteHandlerMethods(handler: RouteHandlerModule): RouteHandlerHttpMethod[];
-declare function buildRouteHandlerAllowHeader(exportedMethods: readonly string[]): string;
-declare function isKnownDynamicAppRoute(pattern: string): boolean;
-declare function markKnownDynamicAppRoute(pattern: string): void;
+export declare function isValidHTTPMethod(maybeMethod: string): maybeMethod is RouteHandlerHttpMethod;
+export declare function collectRouteHandlerMethods(handler: RouteHandlerModule): RouteHandlerHttpMethod[];
+export declare function buildRouteHandlerAllowHeader(exportedMethods: readonly string[]): string;
+export declare function isKnownDynamicAppRoute(pattern: string): boolean;
+export declare function markKnownDynamicAppRoute(pattern: string): void;
 type RequestDynamicAccess = "request.headers" | "request.cookies" | "request.cf" | "request.ip" | "request.geo" | "request.url" | "request.body" | "request.blob" | "request.bytes" | "request.json" | "request.text" | "request.arrayBuffer" | "request.formData";
 type NextUrlDynamicAccess = "nextUrl.search" | "nextUrl.searchParams" | "nextUrl.url" | "nextUrl.href" | "nextUrl.toJSON" | "nextUrl.toString" | "nextUrl.origin";
 type AppRouteDynamicRequestAccess = RequestDynamicAccess | NextUrlDynamicAccess;
@@ -33,6 +33,5 @@ type TrackedAppRouteRequest = {
   request: NextRequest;
   didAccessDynamicRequest(): boolean;
 };
-declare function createTrackedAppRouteRequest(request: Request, options?: TrackedAppRouteRequestOptions): TrackedAppRouteRequest;
-//#endregion
-export { RouteHandlerHttpMethod, RouteHandlerModule, buildRouteHandlerAllowHeader, collectRouteHandlerMethods, createTrackedAppRouteRequest, isKnownDynamicAppRoute, isValidHTTPMethod, markKnownDynamicAppRoute };
+export declare function createTrackedAppRouteRequest(request: Request, options?: TrackedAppRouteRequestOptions): TrackedAppRouteRequest;
+//#endregion

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

@@ -1,5 +1,5 @@
-import { addBasePathToPathname } from "../utils/base-path.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
+import { addBasePathToPathname } from "../utils/base-path.js";
 import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { BUILT_IN_REQUEST_PROPERTIES } from "./app-route-request-built-ins.js";
@@ -191,10 +191,12 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		}
 		const requestHeaders = options.middlewareHeaders ? buildRequestHeadersFromMiddlewareResponse(input.headers, options.middlewareHeaders) : null;
 		const requestWithOverrides = requestHeaders ? cloneRequestWithHeaders(input, requestHeaders) : input;
-		const sourceCfMetadata = Reflect.get(requestWithOverrides, "cf", requestWithOverrides);
 		const sourceCfDescriptor = Reflect.getOwnPropertyDescriptor(requestWithOverrides, "cf");
+		const sourceCfAccessor = sourceCfDescriptor?.get;
+		const sourceCfMetadata = sourceCfAccessor ? void 0 : Reflect.get(requestWithOverrides, "cf", requestWithOverrides);
 		const nextRequest = requestMode === "force-static" ? createForceStaticNextRequest(requestWithOverrides, nextConfig) : requestWithOverrides instanceof NextRequest && sourceCfDescriptor?.configurable !== false ? requestWithOverrides : new NextRequest(requestWithOverrides, { nextConfig: nextConfig ?? void 0 });
-		const rawCfMetadata = sourceCfMetadata === void 0 ? Reflect.get(nextRequest, "cf", nextRequest) : sourceCfMetadata;
+		const rawCfMetadata = sourceCfAccessor ? void 0 : sourceCfMetadata === void 0 ? Reflect.get(nextRequest, "cf", nextRequest) : sourceCfMetadata;
+		const hasCfMetadata = sourceCfAccessor !== void 0 || rawCfMetadata !== void 0;
 		const originalCfDescriptor = sourceCfDescriptor ?? Reflect.getOwnPropertyDescriptor(nextRequest, "cf");
 		const accessCf = (read, forceStaticValue) => {
 			if (requestMode === "force-static") return forceStaticValue;
@@ -202,8 +204,8 @@ function createTrackedAppRouteRequest(request, options = {}) {
 			markDynamicAccess("request.cf");
 			return read();
 		};
-		const controlledCfGetter = () => accessCf(() => rawCfMetadata, void 0);
-		if (rawCfMetadata !== void 0) {
+		const controlledCfGetter = () => accessCf(sourceCfAccessor ? () => Reflect.apply(sourceCfAccessor, requestWithOverrides, []) : () => rawCfMetadata, void 0);
+		if (hasCfMetadata) {
 			if (requestMode === "force-static") Object.defineProperty(nextRequest, "cf", {
 				configurable: true,
 				enumerable: originalCfDescriptor?.enumerable ?? false,
@@ -217,7 +219,7 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		}
 		const cloneTrackedRequest = () => {
 			const cloned = nextRequest.clone();
-			if (rawCfMetadata !== void 0) Object.defineProperty(cloned, "cf", {
+			if (hasCfMetadata) Object.defineProperty(cloned, "cf", sourceCfDescriptor ?? {
 				value: rawCfMetadata,
 				enumerable: originalCfDescriptor?.enumerable ?? false,
 				configurable: true
@@ -356,16 +358,18 @@ function createTrackedAppRouteRequest(request, options = {}) {
 			},
 			preventExtensions(target) {
 				const descriptor = Reflect.getOwnPropertyDescriptor(target, "cf");
-				if (descriptor?.get === controlledCfGetter) if (requestMode === "force-static") {
-					if (!Reflect.deleteProperty(target, "cf")) return false;
-				} else {
-					accessCf(() => void 0, void 0);
-					Object.defineProperty(target, "cf", {
-						configurable: true,
-						enumerable: descriptor.enumerable,
-						value: rawCfMetadata,
-						writable: false
-					});
+				if (descriptor?.get === controlledCfGetter) {
+					if (requestMode === "force-static") {
+						if (!Reflect.deleteProperty(target, "cf")) return false;
+					} else {
+						accessCf(() => void 0, void 0);
+						Object.defineProperty(target, "cf", {
+							configurable: true,
+							enumerable: descriptor.enumerable,
+							value: rawCfMetadata,
+							writable: false
+						});
+					}
 				}
 				return Reflect.preventExtensions(target);
 			}

package/dist/server/app-route-module-loader.d.ts

@@ -71,7 +71,7 @@ type LazyLoadableSlot = {
   /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];
 };
-type LazyLoadableRoute = {
+export type LazyLoadableRoute = {
   page?: unknown;
   routeHandler?: unknown;
   layouts?: unknown[];
@@ -112,16 +112,15 @@ type LazyLoadableRoute = {
   __loading?: Promise<unknown> | null;
 };
 /** Hydrate an intercepting route's page module onto `intercept.page`. */
-declare function loadAppInterceptPage(intercept: LazyLoadableIntercept): Promise<void>;
+export declare function loadAppInterceptPage(intercept: LazyLoadableIntercept): Promise<void>;
 /** Hydrate an intercepting route's not-found boundary onto `intercept.notFound`. */
-declare function loadAppInterceptNotFound(intercept: LazyLoadableIntercept): Promise<void>;
-declare function loadAppInterceptLayouts(intercept: LazyLoadableIntercept): Promise<readonly unknown[]>;
+export declare function loadAppInterceptNotFound(intercept: LazyLoadableIntercept): Promise<void>;
+export declare function loadAppInterceptLayouts(intercept: LazyLoadableIntercept): Promise<readonly unknown[]>;
 /**
  * Resolve a route's lazy modules and assign them onto the route's synchronous
  * module fields. Returns the same route reference (synchronously when already
  * loaded, otherwise after the in-flight import resolves). Safe to call on
  * `null`/`undefined` routes and on eager routes that have no lazy thunks.
  */
-declare function ensureAppRouteModulesLoaded<TRoute extends LazyLoadableRoute>(route: TRoute | null | undefined): TRoute | Promise<TRoute>;
-//#endregion
-export { LazyLoadableRoute, ensureAppRouteModulesLoaded, loadAppInterceptLayouts, loadAppInterceptNotFound, loadAppInterceptPage };
+export declare function ensureAppRouteModulesLoaded<TRoute extends LazyLoadableRoute>(route: TRoute | null | undefined): TRoute | Promise<TRoute>;
+//#endregion

package/dist/server/app-route-request-built-ins.d.ts

@@ -1,5 +1,5 @@
 //#region src/server/app-route-request-built-ins.d.ts
-type BuiltInRequestProperty = {
+export type BuiltInRequestProperty = {
   descriptor: PropertyDescriptor;
   instanceOnly: boolean;
   key: PropertyKey;
@@ -11,6 +11,5 @@ type BuiltInRequestProperty = {
  * The production RSC entry imports this module ahead of userland; the global
  * symbol also preserves that first snapshot for the lazy dispatch chunk.
  */
-declare const BUILT_IN_REQUEST_PROPERTIES: readonly BuiltInRequestProperty[];
-//#endregion
-export { BUILT_IN_REQUEST_PROPERTIES, BuiltInRequestProperty };
+export declare const BUILT_IN_REQUEST_PROPERTIES: readonly BuiltInRequestProperty[];
+//#endregion

package/dist/server/app-route-tree-prefetch.d.ts

@@ -15,14 +15,14 @@ type AppRouteTreePrefetchSlot = {
   page?: unknown;
   routeSegments?: readonly string[] | null;
 };
-type AppRouteTreePrefetchRoute = {
+export type AppRouteTreePrefetchRoute = {
   layoutTreePositions?: readonly number[];
   layouts?: readonly unknown[];
   page?: unknown;
   routeSegments: readonly string[];
   slots?: Readonly<Record<string, AppRouteTreePrefetchSlot>> | null;
 };
-type TreePrefetch = {
+export type TreePrefetch = {
   name: string;
   param: TreePrefetchParam | null;
   prefetchHints: number;
@@ -33,11 +33,10 @@ type RouteTreePrefetchResponseOptions = {
   deploymentId?: string;
   prefetchInlining?: PrefetchInliningConfig;
 };
-type PrefetchInliningConfig = false | {
+export type PrefetchInliningConfig = false | {
   maxBundleSize: number;
   maxSize: number;
 };
-declare function isRouteTreePrefetchRequest(request: Request): boolean;
-declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
-//#endregion
-export { AppRouteTreePrefetchRoute, PrefetchInliningConfig, TreePrefetch, createRouteTreePrefetchResponse, isRouteTreePrefetchRequest };
+export declare function isRouteTreePrefetchRequest(request: Request): boolean;
+export declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
+//#endregion

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

@@ -1,6 +1,7 @@
+import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { NEXTJS_DEPLOYMENT_ID_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.d.ts

@@ -1,4 +1,5 @@
 import { ExecutionContextLike } from "../shims/request-context.js";
+import { __ensureInstrumentation } from "virtual:vinext-rsc-entry";
 //#region src/server/app-router-entry.d.ts
 type WorkerAssetEnv = {
   ASSETS?: {
@@ -6,6 +7,7 @@ type WorkerAssetEnv = {
   };
 };
 declare const _default: {
+  __ensureInstrumentation: typeof __ensureInstrumentation;
   fetch(request: Request, env?: WorkerAssetEnv, ctx?: ExecutionContextLike): Promise<Response>;
 };
 //#endregion

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

@@ -1,27 +1,85 @@
-import "./server-globals.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.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 "./app-rsc-vary.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 { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { applyCdnResponseIdentityHeaders, validateCdnRequest } from "./cache-control.js";
 import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+import { traceFrameworkRequest } from "./request-tracing.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 { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
 import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
+import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import rscHandler, { __assetPrefix, __basePath, __cacheabilityManifest, __ensureHybridPagesApplication, __ensureInstrumentation, __imageAllowedWidths, __imageConfig, __prerenderSecret } from "virtual:vinext-rsc-entry";
 //#region src/server/app-router-entry.ts
 const __workerBasePath = typeof __basePath === "string" ? __basePath : "";
 const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "string" ? __assetPrefix : "");
-var app_router_entry_default = { async fetch(request, env, ctx) {
-	return handleRequest(request, env, ctx);
-} };
+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 = {
+	__ensureInstrumentation,
+	async fetch(request, env, ctx) {
+		const handleFetch = async () => {
+			await __ensureInstrumentation();
+			const url = new URL(request.url);
+			return traceFrameworkRequest({
+				callback: async () => applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request),
+				getStatus: (response) => response?.status,
+				headers: request.headers,
+				isRsc: url.pathname.endsWith(".rsc") || request.headers.get("RSC") === "1",
+				method: request.method,
+				target: url.pathname + url.search
+			});
+		};
+		return ctx ? runWithExecutionContext(ctx, handleFetch) : handleFetch();
+	}
+};
 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) {
+		if (readinessResponse.status === 204) await __ensureHybridPagesApplication();
+		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 +95,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 +110,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 "./app-rsc-vary.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
@@ -8,10 +8,10 @@ import { AppRscStateFingerprintInput } from "./app-rsc-state-fingerprint.js";
  * proxies; stripping them changes the server hash and turns stale URLs into
  * repeated canonicalization redirects.
  */
-declare const VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM = "_rsc";
-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;
+export declare const VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM = "_rsc";
+export declare const VINEXT_RSC_BUILD_ID_HEADER = "X-Vinext-RSC-Build-Id";
+export declare const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
+export declare const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
 type CreateRscRequestHeadersOptions = {
   clientReuseManifestHeader?: string | null;
   interceptionContext?: string | null;
@@ -26,23 +26,24 @@ 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 applyRscDeploymentIdHeader(headers: Headers): void;
-declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
+export declare function getVinextRscCompatibilityId(): string | null;
+export declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined, buildId?: string | null | undefined): void;
+export declare function applyRscDeploymentIdHeader(headers: Headers): void;
+export declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
 type RscCompatibilityNavigationDecision = {
   kind: "compatible";
 } | {
   hardNavigationTarget: string;
   kind: "hard-navigate";
 };
-declare function resolveHardNavigationTargetFromRscResponse(responseUrl: string | null | undefined, currentHref: string, origin: string): string;
-declare function resolveRscCompatibilityNavigationDecision(options: {
+export declare function resolveHardNavigationTargetFromRscResponse(responseUrl: string | null | undefined, currentHref: string, origin: string): string;
+export declare function resolveRscCompatibilityNavigationDecision(options: {
   clientCompatibilityId?: string | null;
   currentHref: string;
   origin: string;
@@ -56,19 +57,43 @@ declare function resolveRscCompatibilityNavigationDecision(options: {
  * built on this helper and the stripper can never disagree on which pairs
  * count as `_rsc`, including encoded-key edge cases like `%5Frsc`.
  */
-declare function hasRscCacheBustingSearchParam(url: URL): boolean;
-declare function computeRscCacheBustingSearchParam(headers: Headers): Promise<string>;
-declare function setRscCacheBustingSearchParam(url: URL, hash: string): void;
-declare function stripRscCacheBustingSearchParam(url: URL): void;
+export declare function hasRscCacheBustingSearchParam(url: URL): boolean;
+export declare function computeRscCacheBustingSearchParam(headers: Headers): Promise<string>;
+export declare function setRscCacheBustingSearchParam(url: URL, hash: string): void;
+export declare function stripRscCacheBustingSearchParam(url: URL): void;
+/**
+ * Reduce a URL's query to the one `_rsc` value that selects its representation.
+ * For RSC requests that is the value `resolveInvalidRscCacheBustingRequest`
+ * validated (the first pair), re-serialized; ignored duplicates and encodings
+ * are dropped. Other requests keep no `_rsc`, because it selects nothing there.
+ */
+export declare function keepOnlyValidatedRscCacheBustingSearchParam(url: URL, isRscRequest: boolean): void;
 /**
  * Remove a trailing `.rsc` suffix from a pathname. Returns the pathname
  * unchanged when the suffix is absent.
  */
-declare function stripRscSuffix(pathname: string): string;
-declare function createRscRequestHeaders(options?: CreateRscRequestHeadersOptions): Headers;
-declare function createRscRequestUrl(href: string, headers: Headers): Promise<string>;
-declare function createServerActionRequestUrl(href: string): string;
-declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
-declare function resolveInvalidRscCacheBustingRequest(options: ResolveInvalidRscCacheBustingRequestOptions): Promise<Response | null>;
+export declare function stripRscSuffix(pathname: string): string;
+export declare function createCanonicalRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
+/** Headers for the deterministic loading-boundary prefetch representation. */
+export declare function createCanonicalLoadingShellRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
+export 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.
+ */
+export 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.
+ */
+export declare function canonicalizeLoadingShellRscRequestHeaders(headers: Headers): boolean;
+export declare function createRscRequestUrl(href: string, headers: Headers): Promise<string>;
+/** Build the definitive full-route RSC URL shared by prefetch and navigation. */
+export declare function createCanonicalRscRequestUrl(href: string): string;
+export declare function createServerActionRequestUrl(href: string): string;
+export declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
+export 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_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER };