vinext 1.0.0 → 1.0.1

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

@@ -11,7 +11,7 @@ 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 +48,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,10 +82,7 @@ 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 (isImageOptimizationPath(url.pathname) && assets && getImageOptimizer()) return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assets.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
 	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
 	try {
 		decodeURIComponent(url.pathname);
@@ -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

@@ -184,6 +184,7 @@ type NavigationContextValue = {
   searchParams: URLSearchParams;
 };
 export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
+  assetPrefix?: string;
   basePath: string;
   buildId: string | null;
   /**

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

@@ -4,14 +4,15 @@ import { PRERENDER_REVALIDATE_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROU
 import { hasMiddlewareRequestHeaderOverrides } from "../utils/middleware-request-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import "./app-rsc-vary.js";
-import { ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
+import { ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_REWRITTEN_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
 import { isInterceptionMatchedUrlPath, normalizePath } from "./normalize-path.js";
-import { badRequestResponse, notFoundResponse } from "./http-error-responses.js";
+import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
@@ -236,7 +237,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		...options.configRewrites.fallback,
 		...options.configHeaders
 	].some((rule) => rule.basePath === false);
-	const normalized = normalizeRscRequest(request, options.basePath, canHandleOutsideBasePath);
+	const normalized = normalizeRscRequest(request, options.basePath, canHandleOutsideBasePath, options.assetPrefix);
 	if (normalized instanceof Response) {
 		if (request.headers.has("X-Vinext-Interception-Context") || request.headers.has("X-Vinext-Interception-Id")) setInterceptionResponseUncacheable(true);
 		return normalized;
@@ -837,15 +838,18 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (response) preserveRouteCacheabilityResponsePolicy();
 		if (!response) return null;
 		if (sharedOuterPolicyNeedsReconciliation) reconcileCdnResponseHeadersAfterOuterPolicy(response.headers, await loadOuterResponsePolicy());
-		if (!pagesDataRequest || resolvedUrl === originalResolvedUrl) return dispatchPagesResponseStage ? markAppRscResponseConfigHeadersApplied(response) : response;
+		const isRewritten = resolvedUrl !== originalResolvedUrl;
+		const isPrerender = typeof process !== "undefined" && process.env?.VINEXT_PRERENDER === "1";
+		if ((!pagesDataRequest || !isRewritten) && !isPrerender) return dispatchPagesResponseStage ? markAppRscResponseConfigHeadersApplied(response) : response;
 		const headers = new Headers(response.headers);
-		headers.set("x-nextjs-rewrite", resolvedUrl);
-		const rewrittenResponse = new Response(response.body, {
+		if (pagesDataRequest && isRewritten) headers.set("x-nextjs-rewrite", resolvedUrl);
+		if (isPrerender) headers.set(VINEXT_PRERENDER_REWRITTEN_HEADER, isRewritten ? "1" : "0");
+		const markedResponse = new Response(response.body, {
 			headers,
 			status: response.status,
 			statusText: response.statusText
 		});
-		return dispatchPagesResponseStage ? markAppRscResponseConfigHeadersApplied(rewrittenResponse) : rewrittenResponse;
+		return dispatchPagesResponseStage ? markAppRscResponseConfigHeadersApplied(markedResponse) : markedResponse;
 	};
 	const staticPagesFallbackResponse = await renderPagesForMatchKind("static");
 	if (staticPagesFallbackResponse) {
@@ -943,6 +947,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		bypassInterceptionContextCache = !hasVerifiedFinalInterceptionSource;
 		setInterceptionResponseUncacheable(bypassInterceptionContextCache);
 	}
+	if ((!filesystemRouteEligible || !match) && isNextStaticPath(cleanPathname, "", assetPrefixPathname(options.assetPrefix ?? ""))) {
+		options.clearRequestContext();
+		const headers = new Headers();
+		mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+		applyCdnResponseHeaders(headers, { cacheControl: NEVER_CACHE_CONTROL });
+		return notFoundStaticAssetResponse(headers);
+	}
 	if (!filesystemRouteEligible) {
 		options.clearRequestContext();
 		const headers = new Headers();

package/dist/server/app-rsc-request-normalization.d.ts

@@ -55,6 +55,6 @@ export type NormalizedRscRequest = {
  * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
  *          or a NormalizedRscRequest for valid requests.
  */
-export declare function normalizeRscRequest(request: Request, basePath: string, allowOutsideBasePath?: boolean): Response | NormalizedRscRequest;
+export declare function normalizeRscRequest(request: Request, basePath: string, allowOutsideBasePath?: boolean, assetPrefix?: string): Response | NormalizedRscRequest;
 //#endregion
 export { normalizeMountedSlotsHeader };

package/dist/server/app-rsc-request-normalization.js

@@ -1,3 +1,4 @@
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./app-rsc-vary.js";
@@ -88,7 +89,7 @@ function tryNormalizeComparablePathAndSearch(value, basePath, baseUrl) {
 * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
 *          or a NormalizedRscRequest for valid requests.
 */
-function normalizeRscRequest(request, basePath, allowOutsideBasePath = false) {
+function normalizeRscRequest(request, basePath, allowOutsideBasePath = false, assetPrefix = "") {
 	const url = new URL(request.url);
 	const protoGuard = guardProtocolRelativeUrl(url.pathname);
 	if (protoGuard) return protoGuard;
@@ -103,7 +104,7 @@ function normalizeRscRequest(request, basePath, allowOutsideBasePath = false) {
 	let hadBasePath = true;
 	if (basePath) {
 		hadBasePath = hasBasePath(requestPathname, basePath);
-		if (!hadBasePath && !pathname.startsWith("/__vinext/") && !allowOutsideBasePath) return notFoundResponse();
+		if (!hadBasePath && !pathname.startsWith("/__vinext/") && !allowOutsideBasePath && !isNextStaticPath(pathname, "", assetPrefixPathname(assetPrefix))) return notFoundResponse();
 		if (hadBasePath) {
 			pathname = stripBasePath(pathname, basePath);
 			requestPathname = stripBasePath(requestPathname, basePath);

package/dist/server/app-rsc-response-finalizer.js

@@ -15,7 +15,10 @@ const configHeadersAlreadyApplied = /* @__PURE__ */ new WeakSet();
 function normalizeExplicitNonCacheablePolicy(headers) {
 	if (!hasExplicitNonCacheableResponsePolicy(headers)) return;
 	const cacheControl = headers.get("Cache-Control");
-	applyCdnResponseHeaders(headers, { cacheControl: cacheControl && isNonCacheableCacheControl(cacheControl) ? cacheControl : NO_STORE_CACHE_CONTROL });
+	applyCdnResponseHeaders(headers, {
+		cacheControl: cacheControl && isNonCacheableCacheControl(cacheControl) ? cacheControl : NO_STORE_CACHE_CONTROL,
+		browserCacheControl: cacheControl ?? void 0
+	});
 }
 /** Mark a response whose final target pipeline has already applied config headers. */
 function markAppRscResponseConfigHeadersApplied(response) {

package/dist/server/app-rsc-route-matching.js

@@ -1,5 +1,5 @@
 import { decodeMatchedParams, splitPathSegments, splitPathnameForRouteMatch } from "../routing/utils.js";
-import { createAppRouteGraphInterceptionId } from "../routing/app-route-graph.js";
+import { createAppRouteGraphInterceptionId } from "../routing/app-route-ids.js";
 import { buildRouteTrie, trieMatchRaw } from "../routing/route-trie.js";
 import { extractRawRoutePatternParams, matchRoutePatternPrefix, matchRoutePatternRaw } from "../routing/route-pattern.js";
 import { canonicalizeAppPageParams } from "./app-page-segment-state.js";

package/dist/server/app-server-action-execution.d.ts

@@ -2,7 +2,8 @@ import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
 import { FetchCacheMode } from "../shims/fetch-cache.js";
-import { HeadersAccessPhase } from "../shims/headers.js";
+import { HeadersAccessPhase } from "../shims/internal/headers-state.js";
+import "../shims/headers.js";
 import { ReactFormState } from "react-dom/client";
 //#region src/server/app-server-action-execution.d.ts
 type AppPageParams = Record<string, string | string[]>;

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

@@ -4,7 +4,7 @@ import { isOpenRedirectShaped } from "./open-redirect.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
-import { onRenderDynamicLatched } from "../shims/headers.js";
+import { onRenderDynamicLatched } from "../shims/internal/headers-state.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
@@ -19,10 +19,10 @@ import { BfcacheIdentityMapContext, ElementsContext, Slot } from "../shims/slot.
 import { getNextErrorDigest } from "./next-error-digest.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createClientPageSsrSearchParamsSource } from "./app-page-search-params-observation.js";
-import { isAppRenderAbortError } from "./app-rsc-errors.js";
+import { isAppRenderAbortError } from "./app-render-abort-error.js";
+import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
 import { createNavigationRuntimeRenderedSearchScript, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, waitAtLeastOneReactRenderTask } from "./app-ssr-stream.js";
 import { createInitialBfcacheMaps } from "./app-bfcache-identity.js";
-import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
 import { runWithRootParamsScope } from "../shims/root-params.js";
 import { runWithNavigationContext } from "../shims/navigation-state.js";

package/dist/server/app-ssr-search-params-gate.js

@@ -1,4 +1,4 @@
-import { isRenderDynamicLatched, markDynamicUsage, onRenderDynamicLatched } from "../shims/headers.js";
+import { isRenderDynamicLatched, markDynamicUsage, onRenderDynamicLatched } from "../shims/internal/headers-state.js";
 import { createSearchParamsGate } from "../shims/search-params-gate.js";
 //#region src/server/app-ssr-search-params-gate.ts
 /**

package/dist/server/app-ssr-stream.js

@@ -1,6 +1,6 @@
 import { createInlineScriptTag, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify } from "./html.js";
 import { bytesToBase64, concatUint8Arrays } from "./app-rsc-embedded-chunks.js";
-import { NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION } from "../client/navigation-runtime.js";
+import { NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION } from "../client/browser-globals.js";
 //#region src/server/app-ssr-stream.ts
 const RSC_EMBED_TEXT_BATCH_MAX_LENGTH = 65536;
 function waitAtLeastOneReactRenderTask() {

package/dist/server/cache-control.js

@@ -91,7 +91,7 @@ function applyCdnResponseHeaders(headers, input) {
 		if (value === "") continue;
 		headers.set(name, value);
 	}
-	if (useNextDeployPolicy) headers.set("Cache-Control", BROWSER_REVALIDATE_CACHE_CONTROL);
+	if (useNextDeployPolicy) headers.set("Cache-Control", input.browserCacheControl ?? "public, max-age=0, must-revalidate");
 }
 /**
 * Reconcile request-stage policy composed above a reusable response artifact.
@@ -106,19 +106,11 @@ function reconcileCdnResponseHeadersAfterOuterPolicy(headers, outerPolicyHeaders
 		return;
 	}
 	const cacheControl = outerPolicyHeaders.get("cache-control");
-	if (cacheControl !== null) {
-		applyCdnResponseHeaders(headers, { cacheControl });
-		for (const [name, value] of outerPolicyHeaders) {
-			if (name === "cache-control") continue;
-			if (isCdnResponsePolicyHeader(name)) headers.set(name, value);
-		}
-		return;
-	}
-	for (const [name, value] of outerPolicyHeaders) if (isCdnResponsePolicyHeader(name) && isNonCacheableCdnResponsePolicy(name, value)) {
+	if (cacheControl !== null) headers.set("Cache-Control", cacheControl);
+	for (const [name, value] of outerPolicyHeaders) if (name !== "cache-control" && isCdnResponsePolicyHeader(name) && isNonCacheableCdnResponsePolicy(name, value)) {
 		applyCdnResponseHeaders(headers, { cacheControl: NO_STORE_CACHE_CONTROL });
 		return;
 	}
-	if (hasExplicitNonCacheableResponsePolicy(outerPolicyHeaders)) applyCdnResponseHeaders(headers, { cacheControl: NO_STORE_CACHE_CONTROL });
 }
 /** Apply adapter-owned build identity to an HTML or RSC page response. */
 function applyCdnResponseIdentityHeaders(response, request) {