vinext 1.0.0 → 1.1.0

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

@@ -1,9 +1,9 @@
-import { isrCacheControl } from "./isr-cache.js";
+import { isrCacheControl, resolveRouteExpireSeconds } from "./isr-cache.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { applyRouteHandlerMiddlewareContext, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
 import { markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { resolveAppRouteHandlerSpecialError } from "./app-route-handler-policy.js";
-import { runAppRouteHandler, traceAppRouteHandlerExecution } from "./app-route-handler-execution.js";
+import { completeAppRouteHandlerResponse, runAppRouteHandler, traceAppRouteHandlerExecution } from "./app-route-handler-execution.js";
 //#region src/server/app-route-handler-cache.ts
 const EMPTY_PARAMS = Object.freeze({});
 function getCachedAppRouteValue(entry) {
@@ -64,17 +64,21 @@ async function readAppRouteHandlerCacheResponse(options) {
 					options.setNavigationContext(null);
 				}
 				if ("specialError" in tracedResult) return;
-				const { dynamicUsedInHandler, response } = tracedResult.handlerResult;
+				const { dynamicUsedInHandler, response, didAccessDynamicRequest } = tracedResult.handlerResult;
 				assertSupportedAppRouteHandlerResponse(response);
-				if (dynamicUsedInHandler) {
-					markKnownDynamicAppRoute(options.routePattern);
+				const completed = await completeAppRouteHandlerResponse(response);
+				const lateDynamicUsage = options.consumeDynamicUsage();
+				const becameDynamic = dynamicUsedInHandler || lateDynamicUsage || didAccessDynamicRequest();
+				if (!completed.completed || becameDynamic || response.headers.has("set-cookie")) {
+					completed.response.body?.cancel().catch(() => {});
+					if (becameDynamic) markKnownDynamicAppRoute(options.routePattern);
 					options.isrDebug?.("route regen skipped (dynamic usage)", options.cleanPathname);
 					return;
 				}
 				const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
-				const routeCacheValue = await buildAppRouteCacheValue(response);
+				const routeCacheValue = await buildAppRouteCacheValue(completed.response, response.headers.get("Cache-Control") ?? void 0);
 				await options.isrSet(routeKey, routeCacheValue, {
-					cacheControl: isrCacheControl(options.revalidateSeconds, { expireSeconds: options.expireSeconds }),
+					cacheControl: isrCacheControl(options.revalidateSeconds === Infinity ? false : options.revalidateSeconds, { expireSeconds: resolveRouteExpireSeconds(options.revalidateSeconds, options.expireSeconds) }),
 					tags: routeTags
 				});
 				options.isrDebug?.("route regen complete", routeKey);

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

@@ -5,15 +5,16 @@ import { reportRequestError } from "./instrumentation.js";
 import { beginRouteCacheability, getRouteCacheabilityDynamicReason } from "../shims/cacheability-classification.js";
 import { applyCdnResponseBuildIdentityHeaders } from "./cache-control.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
-import { consumeDynamicUsage, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
+import { markDynamicUsage } from "../shims/internal/headers-state.js";
+import { consumeDynamicUsage, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, setHeadersAccessPhase } from "../shims/headers.js";
 import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
+import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { traceResponseStart } from "./response-start-tracing.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { applyRouteHandlerMiddlewareContext, finalizeRouteHandlerResponse } from "./app-route-handler-response.js";
-import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 import "../shims/navigation.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
@@ -101,11 +102,12 @@ async function dispatchAppRouteHandlerImpl(options) {
 		method,
 		revalidateSeconds
 	});
-	const revalidateReason = isOnDemandRevalidateRequest(options.request.headers.get("x-prerender-revalidate")) ? "on-demand" : shouldReadRouteCache ? "stale" : void 0;
+	const revalidateReason = isOnDemandRevalidateRequest(options.request.headers.get("x-prerender-revalidate")) ? "on-demand" : shouldReadRouteCache && revalidateSeconds !== Infinity ? "stale" : void 0;
 	const fetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
 	setCurrentFetchCacheMode(fetchCacheMode);
 	setCurrentFetchRevalidate(configuredRevalidateSeconds);
 	setCurrentForceDynamicFetchDefault(handler.dynamic === "force-dynamic");
+	let isRevalidation = false;
 	if (shouldReadRouteCache && resolvedHandlerFn) {
 		const cachedRouteResponse = await readAppRouteHandlerCacheResponse({
 			basePath: options.basePath,
@@ -123,7 +125,11 @@ async function dispatchAppRouteHandlerImpl(options) {
 			isAutoHead,
 			appendResponseLink,
 			isrDebug: options.isrDebug,
-			isrGet: options.isrGet,
+			async isrGet(key) {
+				const entry = await options.isrGet(key);
+				isRevalidation = entry?.value.value?.kind === "APP_ROUTE";
+				return entry;
+			},
 			isrRouteKey: options.isrRouteKey,
 			isrSet: options.isrSet,
 			markDynamicUsage,
@@ -159,6 +165,7 @@ async function dispatchAppRouteHandlerImpl(options) {
 	}
 	if (resolvedHandlerFn) {
 		const response = await executeAppRouteHandler({
+			isRevalidation,
 			basePath: options.basePath,
 			bypassSharedCache: options.bypassSharedCache,
 			buildPageCacheTags(pathname, extraTags) {

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

@@ -4,7 +4,8 @@ import { NextRequest } from "../shims/server.js";
 import { FrameworkSpan } from "./framework-tracer.js";
 import { CachedRouteValue } from "../shims/cache-handler.js";
 import { IsrWritePolicy } from "./isr-cache.js";
-import { HeadersAccessPhase } from "../shims/headers.js";
+import { HeadersAccessPhase } from "../shims/internal/headers-state.js";
+import "../shims/headers.js";
 import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
 import { AppRouteHandlerModule } from "./app-route-handler-policy.js";
 //#region src/server/app-route-handler-execution.d.ts
@@ -62,6 +63,11 @@ type RunAppRouteHandlerResult = {
   dynamicUsedInHandler: boolean;
   response: Response;
 };
+type CompletedAppRouteHandlerResponse = {
+  completed: boolean;
+  response: Response;
+};
+export declare function completeAppRouteHandlerResponse(response: Response): Promise<CompletedAppRouteHandlerResponse>;
 export declare function applyDraftModeCachePolicy(response: Response, isDraftMode: boolean): Response;
 type ExecuteAppRouteHandlerOptions = {
   buildPageCacheTags: (pathname: string, extraTags: string[]) => string[];
@@ -78,6 +84,8 @@ type ExecuteAppRouteHandlerOptions = {
   initialDraftModeCookie?: string | null;
   isDraftMode?: boolean;
   isProduction: boolean;
+  /** An existing entry may require foreground regeneration after hard expiry. */
+  isRevalidation?: boolean;
   isrDebug?: AppRouteDebugLogger;
   isrRouteKey: (pathname: string) => string;
   isrSet: RouteHandlerCacheSetter;

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

@@ -1,8 +1,10 @@
+import { isFullyBufferedBody } from "./fully-buffered-response.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { frameworkTracer } from "./tracer.js";
-import { getRouteCacheabilityCaptureOptions, getRouteCacheabilityDynamicReason, isRouteCacheabilityEvaluation, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete } from "../shims/cacheability-classification.js";
+import { getRouteCacheabilityCaptureOptions, getRouteCacheabilityDynamicReason, isRouteCacheabilityEvaluation, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy, hasExplicitNonCacheableResponsePolicy } from "./cache-control.js";
-import { isrCacheControl } from "./isr-cache.js";
+import { buildAppRouteMissIsrCacheControl } from "./isr-decision.js";
+import { isrCacheControl, resolveRouteExpireSeconds } 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";
@@ -18,6 +20,10 @@ function hasExplicitCacheableResponsePolicy(headers) {
 	return !hasExplicitNonCacheableResponsePolicy(headers) && hasCdnResponsePolicy(headers);
 }
 async function completeAppRouteHandlerResponse(response) {
+	if (isFullyBufferedBody(response)) return {
+		completed: true,
+		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);
@@ -189,16 +195,13 @@ async function executeAppRouteHandlerImpl(options) {
 		const handlerResult = tracedResult.handlerResult;
 		let { dynamicUsedInHandler, response } = handlerResult;
 		assertSupportedAppRouteHandlerResponse(response);
-		const handlerSetCachePolicy = hasCdnResponsePolicy(response.headers);
-		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,
+			hasExplicitCacheablePolicy: hasExplicitCacheableResponsePolicy(response.headers),
+			handlerSetCachePolicy: hasCdnResponsePolicy(response.headers),
 			isAutoHead: options.isAutoHead,
 			isDraftMode: draftModeBeforeCompletion || handlerDraftCookieBeforeCompletion != null,
 			isProduction: options.isProduction,
@@ -213,6 +216,9 @@ async function executeAppRouteHandlerImpl(options) {
 			const dynamicUsedDuringCompletion = options.consumeDynamicUsage();
 			dynamicUsedInHandler = handlerResult.didAccessDynamicRequest() || dynamicUsedDuringCompletion || dynamicUsedInHandler;
 		}
+		const browserCacheControl = response.headers.get("Cache-Control") ?? void 0;
+		const handlerSetCachePolicy = hasCdnResponsePolicy(response.headers);
+		if (handlerSetCachePolicy) markRouteCacheabilityExplicitResponsePolicy();
 		const requestCacheabilityVeto = getRouteCacheabilityDynamicReason();
 		const responseMustStayPrivate = Boolean(options.bypassSharedCache === true || options.handler.dynamic === "force-dynamic" || dynamicUsedInHandler || requestCacheabilityVeto || cleanupDeferredToBody);
 		if (dynamicUsedInHandler) markKnownDynamicAppRoute(options.routePattern);
@@ -222,6 +228,15 @@ async function executeAppRouteHandlerImpl(options) {
 		const shouldApplyDraftPolicy = (options.getActiveDraftModeState?.() ?? options.isDraftMode === true) || draftCookie != null;
 		if (handlerDraftCookie != null) markKnownDynamicAppRoute(options.routePattern);
 		const routeTags = options.buildPageCacheTags(options.cleanPathname, options.getCollectedFetchTags());
+		const frameworkCacheable = (options.isRevalidation === true || response.status < 400 || response.status === 404) && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && !responseMustStayPrivate && !shouldApplyDraftPolicy && pendingCookies.length === 0 && !response.headers.has("set-cookie") && (options.method === "GET" || options.isAutoHead);
+		recordRouteCacheability(frameworkCacheable ? {
+			cacheable: true,
+			cacheControl: buildAppRouteMissIsrCacheControl(options.revalidateSeconds, options.expireSeconds),
+			tags: routeTags
+		} : {
+			cacheable: false,
+			dynamicUsage: responseMustStayPrivate || shouldApplyDraftPolicy || options.revalidateSeconds === 0
+		});
 		if (shouldApplyAppRouteHandlerRevalidateHeader({
 			dynamicUsedInHandler: responseMustStayPrivate,
 			handlerSetCachePolicy,
@@ -234,9 +249,9 @@ async function executeAppRouteHandlerImpl(options) {
 			if (revalidateSeconds == null) throw new Error("Expected route handler revalidate seconds");
 			applyRouteHandlerRevalidateHeader(response, revalidateSeconds, options.expireSeconds, routeTags);
 		}
-		if (shouldWriteAppRouteHandlerCache({
+		if (frameworkCacheable && shouldWriteAppRouteHandlerCache({
 			dynamicConfig: options.handler.dynamic,
-			dynamicUsedInHandler: responseMustStayPrivate,
+			dynamicUsedInHandler: responseMustStayPrivate || pendingCookies.length > 0 || response.headers.has("set-cookie"),
 			handlerSetCachePolicy,
 			isAutoHead: options.isAutoHead,
 			isDraftMode: shouldApplyDraftPolicy,
@@ -251,9 +266,9 @@ async function executeAppRouteHandlerImpl(options) {
 			if (revalidateSeconds == null) throw new Error("Expected route handler cache revalidate seconds");
 			const routeWritePromise = (async () => {
 				try {
-					const routeCacheValue = await buildAppRouteCacheValue(routeClone);
+					const routeCacheValue = await buildAppRouteCacheValue(routeClone, browserCacheControl);
 					await options.isrSet(routeKey, routeCacheValue, {
-						cacheControl: isrCacheControl(revalidateSeconds, { expireSeconds: options.expireSeconds }),
+						cacheControl: isrCacheControl(revalidateSeconds === Infinity ? false : revalidateSeconds, { expireSeconds: resolveRouteExpireSeconds(options.revalidateSeconds, options.expireSeconds) }),
 						tags: routeTags
 					});
 					options.isrDebug?.("route cache written", routeKey);
@@ -268,7 +283,7 @@ async function executeAppRouteHandlerImpl(options) {
 			draftCookie,
 			isHead: options.isAutoHead
 		}), options.middlewareContext, middlewareMergeOptions), shouldApplyDraftPolicy);
-		const preserveHandlerPolicy = isRouteCacheabilityEvaluation() ? hasExplicitCacheablePolicy : handlerSetCachePolicy;
+		const preserveHandlerPolicy = handlerSetCachePolicy;
 		if (options.bypassSharedCache === true || responseMustStayPrivate && !preserveHandlerPolicy) {
 			const headers = new Headers(finalized.headers);
 			applyCdnResponseHeaders(headers, { cacheControl: NEVER_CACHE_CONTROL });
@@ -328,4 +343,4 @@ async function executeAppRouteHandlerImpl(options) {
 	}
 }
 //#endregion
-export { applyDraftModeCachePolicy, executeAppRouteHandler, runAppRouteHandler, traceAppRouteHandlerExecution };
+export { applyDraftModeCachePolicy, completeAppRouteHandlerResponse, executeAppRouteHandler, runAppRouteHandler, traceAppRouteHandlerExecution };

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

@@ -36,7 +36,7 @@ function resolveAppRouteHandlerMethod(handler, method) {
 	};
 }
 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";
+	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && 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.handlerSetCachePolicy;
@@ -51,7 +51,7 @@ 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);
+	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.dynamicConfig !== "force-dynamic" && !options.isDraftMode && !options.dynamicUsedInHandler && (options.method === "GET" || options.isAutoHead);
 }
 function resolveAppRouteHandlerSpecialError(error, requestUrl, options) {
 	if (!(error && typeof error === "object" && "digest" in error)) return null;

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

@@ -23,6 +23,6 @@ export declare function assertSupportedAppRouteHandlerResponse(response: Respons
 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 buildAppRouteCacheValue(response: Response, browserCacheControl?: string): Promise<CachedRouteValue>;
 export declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
 //#endregion

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

@@ -1,7 +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 { markRouteCacheabilityExplicitResponsePolicy, recordRouteCacheability } from "../shims/cacheability-classification.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
@@ -50,14 +50,22 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 		expireSeconds: options.expireSeconds,
 		cacheControlMeta: options.cacheControl
 	});
-	applyCdnResponseHeaders(headers, { cacheControl });
-	return new Response(options.isHead ? null : cachedValue.body, {
+	recordRouteCacheability({
+		cacheable: true,
+		cacheControl
+	});
+	if (headers.has("Cache-Control")) markRouteCacheabilityExplicitResponsePolicy();
+	applyCdnResponseHeaders(headers, {
+		cacheControl,
+		browserCacheControl: headers.get("Cache-Control") ?? void 0
+	});
+	const hasNoBody = options.isHead || cachedValue.status === 204 || cachedValue.status === 205 || cachedValue.status === 304;
+	return new Response(hasNoBody ? null : cachedValue.body, {
 		status: cachedValue.status,
 		headers
 	});
 }
 function applyRouteHandlerRevalidateHeader(response, revalidateSeconds, expireSeconds, tags) {
-	markRouteCacheabilityExplicitConfigPolicy();
 	applyCdnResponseHeaders(response.headers, {
 		cacheControl: buildAppRouteMissIsrCacheControl(revalidateSeconds, expireSeconds),
 		tags
@@ -125,13 +133,14 @@ function applyMutableCookieFallbacks(headers, pendingCookies) {
 	for (const cookie of fallbackCookies.values()) headers.append("Set-Cookie", cookie);
 	for (const cookie of returnedCookies) headers.append("Set-Cookie", normalizeReturnedCookie(cookie));
 }
-async function buildAppRouteCacheValue(response) {
+async function buildAppRouteCacheValue(response, browserCacheControl) {
 	const body = await response.arrayBuffer();
 	const headers = {};
 	response.headers.forEach((value, key) => {
 		if (key === "set-cookie" || key === "connection" || key === "content-length" || key === "date" || key === "keep-alive" || key === "transfer-encoding" || key === "x-next-cache-tags" || key === "x-vinext-metadata-route-cache" || key === "x-vinext-prerender-cache-life" || key === "X-Vinext-Cache".toLowerCase() || key === "x-nextjs-cache".toLowerCase() || key === "cache-control" || key.startsWith("x-middleware-")) return;
 		headers[key] = value;
 	});
+	if (browserCacheControl !== void 0) headers["cache-control"] = browserCacheControl;
 	const setCookies = response.headers.getSetCookie?.() ?? [];
 	if (setCookies.length > 0) headers["set-cookie"] = setCookies;
 	return {

package/dist/server/app-router-entry.d.ts

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

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

@@ -5,13 +5,12 @@ 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 { cloneRequestWithHeaders, filterInternalHeaders, guardProtocolRelativeUrl } from "./request-pipeline.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 { createStaticAssetRequest, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
@@ -48,6 +47,7 @@ async function handleRequest(request, env, platformCtx) {
 	const requestCtx = platformCtx?.trustedRevalidateOrigin ? platformCtx : createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx));
 	registerConfiguredCacheAdapters(env);
 	const cdnCacheAdapter = getCdnCacheAdapter();
+	const assets = platformCtx?.assets ?? cdnCacheAdapter.assets ?? env?.ASSETS;
 	let ctx = createWorkerPrerenderDiscoveryContext(requestCtx, request, __prerenderSecret);
 	const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
 	if (readinessResponse) {
@@ -81,11 +81,9 @@ async function handleRequest(request, env, platformCtx) {
 	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;
-		return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assetFetcher.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
-	}
-	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
+	if (isImageOptimizationPath(url.pathname) && assets && getImageOptimizer()) return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assets.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
+	const protocolRelativeGuard = guardProtocolRelativeUrl(url.pathname, url.search);
+	if (protocolRelativeGuard) return protocolRelativeGuard;
 	try {
 		decodeURIComponent(url.pathname);
 	} catch {
@@ -105,12 +103,10 @@ async function handleRequest(request, env, platformCtx) {
 	const result = await (ctx ? runWithExecutionContext(ctx, handleFn) : handleFn());
 	if (result instanceof Response) {
 		let response = result;
-		if (env?.ASSETS) {
-			const assetFetcher = env.ASSETS;
-			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(createStaticAssetRequest(path, request))) });
+		if (assets) {
+			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assets.fetch(createStaticAssetRequest(path, request))) });
 			if (assetResponse) response = assetResponse;
 		}
-		response = finalizeMissingStaticAssetResponse(response, missingBuildAsset);
 		return finalizeCacheabilityResponse ? finalizeCacheabilityResponse(response, ctx) : response;
 	}
 	if (result === null || result === void 0) {

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

@@ -22,7 +22,6 @@ type CreateRscOnErrorHandlerOptions = {
 export declare function hasDigest(error: unknown): error is {
   digest: unknown;
 };
-export declare function isAppRenderAbortError(error: unknown): boolean;
 /**
  * vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
  * string only when the error is a genuine control-flow signal — a redirect,

package/dist/server/app-rsc-errors.js

@@ -1,5 +1,6 @@
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
+import { isAppRenderAbortError } from "./app-render-abort-error.js";
 //#region src/server/app-rsc-errors.ts
 const ORIGINAL_SERVER_ERROR = Symbol.for("vinext.originalServerError");
 function hasDigest(error) {
@@ -7,11 +8,6 @@ function hasDigest(error) {
 }
 const BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
 const DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
-function isAppRenderAbortError(error) {
-	if (!error || typeof error !== "object") return false;
-	const name = Reflect.get(error, "name");
-	return name === "AbortError" || name === "ResponseAborted";
-}
 /**
 * vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
 * string only when the error is a genuine control-flow signal — a redirect,
@@ -85,4 +81,4 @@ function createRscOnErrorHandler(options) {
 	};
 }
 //#endregion
-export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, isAppRenderAbortError, sanitizeErrorForClient };
+export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };

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

@@ -85,6 +85,8 @@ type DispatchMatchedPageOptions<TRoute> = {
   scriptNonce?: string;
   searchParams: URLSearchParams;
   renderMode: AppRscRenderMode;
+  /** Render the document whole before its first byte (a regeneration or warm-up). */
+  renderWholeDocument?: boolean;
 };
 type DispatchMatchedRouteHandlerOptions<TRoute> = {
   /**
@@ -184,6 +186,7 @@ type NavigationContextValue = {
   searchParams: URLSearchParams;
 };
 export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
+  assetPrefix?: string;
   basePath: string;
   buildId: string | null;
   /**
@@ -234,6 +237,8 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   matchInterceptRoute?: (pathname: string, sourcePathname: string, interceptionId?: string | null) => AppRscRouteMatch<TRoute> | null;
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   matchRequestRoute?: (pathname: string) => AppRscRouteMatch<TRoute> | null;
+  /** `matchRequestRoute` without its decoded static page substitution. */
+  matchRawRequestRoute?: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;
   publicFiles: ReadonlySet<string>;
   prefetchInlining?: PrefetchInliningConfig;