vinext 1.0.0-beta.9 → 1.0.0

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

@@ -1,41 +1,52 @@
-import { closeAfterResponse, closeAfterResponseWithBody, createRequestContext, preserveFullyBufferedBodyMetadata, runWithRequestContext } from "../shims/unified-request-context.js";
+import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { closeAfterResponse, closeAfterResponseWithBody, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { PRERENDER_REVALIDATE_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { hasMiddlewareRequestHeaderOverrides } from "../utils/middleware-request-headers.js";
+import { requestContextFromRequest } from "../config/request-context.js";
+import { isExternalUrl } from "../utils/external-url.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 { requestContextFromRequest } from "../config/request-context.js";
-import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
-import { ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS } from "./headers.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 { isInterceptionMatchedUrlPath, normalizePath } from "./normalize-path.js";
-import { isExternalUrl } from "../utils/external-url.js";
 import { badRequestResponse, notFoundResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
-import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
-import { isOnDemandRevalidateRequest } from "./isr-cache.js";
-import { getHeadersContext, headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
-import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { markRouteCacheabilityDynamic, preserveRouteCacheabilityResponsePolicy } from "../shims/cacheability-classification.js";
+import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, captureCdnResponsePolicyOverrides, isCdnResponsePolicyHeader, reconcileCdnResponseHeadersAfterOuterPolicy } from "./cache-control.js";
+import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
+import { getDraftModeCookieHeader, getEffectiveRequestCookieHeader, getHeadersContext, hasEffectiveRequestCookieChanges, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, runWithHeadersContext } from "../shims/headers.js";
 import { mergeRewriteQuery } from "../utils/query.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
+import { traceFindPageComponents } from "./pages-execution-tracing.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, resolveDevImageRedirect } from "./image-optimization.js";
-import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { parseCacheabilityManifest } from "./cacheability-manifest.js";
+import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestUrl, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { consumeResponseStageLinkProvenance, copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
 import "./app-page-response.js";
 import { parseNextHttpErrorDigest } from "./next-error-digest.js";
-import { markRouteCacheabilityDynamic, preserveRouteCacheabilityResponsePolicy } from "../shims/cacheability-classification.js";
+import { traceAppPageRender } from "./app-page-tracing.js";
+import { setFrameworkRequestRoute, traceFrameworkRequest } from "./request-tracing.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
-import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.js";
+import { createSharedAppPageCacheIdentity, isStaticCandidateAppPageDispatch, prepareSharedAppPageDispatch, withoutAppPageDispatchQuery } from "./app-worker-stages.js";
 import { flattenErrorCauses } from "../utils/error-cause.js";
-import { applyAppRscConfigHeaders, finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
+import { applyAppRscConfigHeaders, finalizeAppRscResponse, markAppRscResponseConfigHeadersApplied } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
+import { hasPagesPreviewCookie } from "./pages-response-stage.js";
 import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
+import { consumePagesResponseStagePolicyOwner, withoutResponseStageVary } from "./response-stage-policy.js";
 //#region src/server/app-rsc-handler.ts
-const STATIC_METADATA_CONFIG_HEADER_OVERRIDES = /* @__PURE__ */ new Set(["cache-control"]);
 const HAS_CONFIG_HEADERS = process.env.__VINEXT_HAS_CONFIG_HEADERS !== "false";
 const HAS_CONFIG_REDIRECTS = process.env.__VINEXT_HAS_CONFIG_REDIRECTS !== "false";
 const HAS_CONFIG_REWRITES = process.env.__VINEXT_HAS_CONFIG_REWRITES !== "false";
@@ -66,16 +77,45 @@ function haveSamePageParams(first, second) {
 	}
 	return true;
 }
+function rewriteCachePathname(sourcePathname, resolvedPathname) {
+	return `${sourcePathname}?__vinext_rewrite=${encodeURIComponent(resolvedPathname)}`;
+}
+function requestOptsOutOfWorkerResponseStage(request, options, scriptNonce, allowInternalRscDocumentFallback) {
+	if (request.method !== "GET" && request.method !== "HEAD") return true;
+	if (allowInternalRscDocumentFallback || scriptNonce !== void 0) return true;
+	if (isDraftModeRequest(request, options.draftModeSecret) || isDraftModeEnabled()) return true;
+	if (isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate"))) return true;
+	if (request.headers.has("x-vinext-prerender-route-params")) return true;
+	return false;
+}
+let parsedCacheabilityRequestProjection;
+function readCacheabilityRequestProjection(options) {
+	const raw = options.cacheabilityRequestProjection;
+	if (!raw || !options.buildId) return null;
+	if (parsedCacheabilityRequestProjection?.raw !== raw || parsedCacheabilityRequestProjection.buildId !== options.buildId) parsedCacheabilityRequestProjection = {
+		buildId: options.buildId,
+		manifest: parseCacheabilityManifest(raw, options.buildId),
+		raw
+	};
+	return parsedCacheabilityRequestProjection.manifest;
+}
+function adapterUsesQueryFreeCacheIdentity() {
+	const adapter = getCdnCacheAdapter();
+	return adapter.requiresCompletedResponseAdmission === true && adapter.responseStageCacheIdentity === "query-free";
+}
 function hasUrlParserDotSegment(pathname) {
 	return pathname.split("/").some((segment) => {
 		const decodedDots = segment.replaceAll(/%2e/gi, ".");
 		return decodedDots === "." || decodedDots === "..";
 	});
 }
-function applyMiddlewareContextToResponse(response, middlewareContext) {
+function applyMiddlewareContextToResponse(response, middlewareContext, appendToPostConfigLink = false) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const headers = new Headers(response.headers);
+	const responseLink = appendToPostConfigLink ? headers.get("link") : null;
 	mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+	const middlewareLink = middlewareContext.headers?.get("link");
+	if (responseLink && middlewareLink) headers.set("link", `${middlewareLink}, ${responseLink}`);
 	return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
 		status: middlewareContext.status ?? response.status,
 		statusText: response.statusText,
@@ -105,11 +145,11 @@ function redirectDestinationWithBasePath(destination, basePath, hadBasePath) {
 	if (!basePath || !hadBasePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
 	return basePath + destination;
 }
-async function applyRewrite(options, cleanPathname) {
+async function applyRewrite(options, cleanPathname, recordCacheability = true) {
 	if (!HAS_CONFIG_REWRITES || !options.rewrites.length) return null;
 	const sourcePathname = options.paramsPathname ?? cleanPathname;
 	const configMatchers = await import("../config/config-matchers.js");
-	const rewritten = configMatchers.matchRewrite(sourcePathname, options.rewrites, options.requestContext, options.basePathState, options.paramsPathname, markConditionalRewriteCacheability);
+	const rewritten = configMatchers.matchRewrite(sourcePathname, options.rewrites, options.requestContext, options.basePathState, options.paramsPathname, recordCacheability ? markConditionalRewriteCacheability : void 0);
 	if (!rewritten) return null;
 	if (isExternalUrl(rewritten)) {
 		const validationResponse = await options.validateExternalRewriteRequest();
@@ -139,7 +179,8 @@ async function applyConfigHeadersToMiddlewareRedirect(response, options) {
 		configHeaders: options.configHeaders,
 		pathname: options.pathname,
 		requestContext: options.requestContext,
-		basePathState: options.basePathState
+		basePathState: options.basePathState,
+		recordCacheability: options.recordCacheability
 	});
 	if (!headers.entries().next().done) {
 		mergeMiddlewareResponseHeaders(headers, response.headers);
@@ -182,7 +223,7 @@ function markUnverifiedInterceptionResponseUncacheable(response) {
 	}
 	return markedResponse;
 }
-async function handleAppRscRequest(options, request, preMiddlewareRequestContext, middlewareContext, isDataRequest, isMiddlewareDataRequest, pagesDataRequest, dispatchInternalRequest, allowInternalRscDocumentFallback, setInterceptionResponseUncacheable) {
+async function handleAppRscRequest(options, request, preMiddlewareRequestContext, middlewareContext, isDataRequest, isMiddlewareDataRequest, pagesDataRequest, dispatchInternalRequest, allowInternalRscDocumentFallback, dispatchResponseStage, responseStageProbeMode = null, setInterceptionResponseUncacheable = () => {}) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
 		const originBlock = options.validateDevRequestOrigin?.(request);
@@ -201,6 +242,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		return normalized;
 	}
 	const { url, isRscRequest, interceptionContextHeader, interceptionIdHeader, mountedSlotsHeader, renderMode, clientReuseManifest, hadBasePath } = normalized;
+	setFrameworkRequestRoute(void 0, isRscRequest);
 	const hasRawInterceptionContext = isRscRequest && request.headers.has("X-Vinext-Interception-Context");
 	if (hasRawInterceptionContext) setInterceptionResponseUncacheable(true);
 	let interceptionSourcePathname = null;
@@ -264,7 +306,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const matchPathname = (p) => normalizeDefaultLocalePathname(p, options.i18nConfig, { hostname: url.hostname });
 	const redirectPathname = matchPathname(requestCleanPathname);
 	const configMatchers = HAS_CONFIG_REDIRECTS && options.configRedirects.length ? await import("../config/config-matchers.js") : null;
-	const redirect = configMatchers ? configMatchers.matchRedirect(redirectPathname, options.configRedirects, preMiddlewareRequestContext, basePathState, markConditionalRedirectCacheability) : null;
+	const redirect = configMatchers ? configMatchers.matchRedirect(redirectPathname, options.configRedirects, preMiddlewareRequestContext, basePathState, dispatchResponseStage ? void 0 : markConditionalRedirectCacheability) : null;
 	if (configMatchers && redirect) {
 		const destination = configMatchers.sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath, hadBasePath));
 		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : configMatchers.preserveRedirectDestinationQuery(destination, url.search);
@@ -304,13 +346,14 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			request: userlandRequest,
 			validateExternalRewriteRequest: () => validateClaimedOutsideBasePathRsc(true)
 		});
-		if (middlewareResult.pathnameEligible) markRouteCacheabilityDynamic(middlewareResult.matched ? "middleware matched this request" : "middleware is eligible for this pathname");
+		if (!dispatchResponseStage && middlewareResult.pathnameEligible) markRouteCacheabilityDynamic(middlewareResult.matched ? "middleware matched this request" : "middleware is eligible for this pathname");
 		if (middlewareResult.kind === "response") {
 			if (request.body && !request.body.locked) request.body.cancel().catch(() => {});
 			return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
 				basePathState,
 				configHeaders: options.configHeaders,
 				pathname: matchPathname(requestCleanPathname),
+				recordCacheability: dispatchResponseStage === void 0,
 				requestContext: preMiddlewareRequestContext
 			});
 		}
@@ -322,6 +365,158 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		resolvedUrl = cleanPathname + url.search;
 	}
 	const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareContext.headers);
+	const hasMiddlewareCookieOverlay = hasEffectiveRequestCookieChanges(request.headers.get("cookie"));
+	const middlewareCookieOverlay = hasMiddlewareCookieOverlay ? getEffectiveRequestCookieHeader() ?? "" : null;
+	const draftModeCookie = dispatchResponseStage || options.renderResponseStageLocally ? getDraftModeCookieHeader() : null;
+	const responseStageCacheability = (resolvedRouteUrl) => ({
+		policyHeaders: null,
+		probeMode: responseStageProbeMode,
+		resolvedRoutePathname: pathnameForResolvedUrl(resolvedRouteUrl)
+	});
+	let responseStagePolicyPromise;
+	const loadResponseStagePolicy = () => responseStagePolicyPromise ??= options.configHeaders.length ? import("./config-headers.js").then(({ resolveResponseStageCachePolicy }) => withoutResponseStageVary(resolveResponseStageCachePolicy({
+		basePathState,
+		configHeaders: options.configHeaders,
+		pathname: matchPathname(requestCleanPathname),
+		requestContext: preMiddlewareRequestContext
+	}))) : Promise.resolve(null);
+	let canUseSharedWorkerResponseStage = draftModeCookie === null && !hasMiddlewareCookieOverlay && !hasMiddlewareRequestHeaderOverrides(middlewareContext.requestHeaders ?? middlewareContext.headers) && !requestOptsOutOfWorkerResponseStage(request, options, scriptNonce, allowInternalRscDocumentFallback);
+	const isOnDemandRevalidate = isOnDemandRevalidateRequest(request.headers.get(PRERENDER_REVALIDATE_HEADER));
+	const transportedResponseStage = dispatchResponseStage ? async (stageRequest, props) => {
+		const responseStagePolicy = await loadResponseStagePolicy();
+		const cache = responseStageProbeMode || isOnDemandRevalidate || (props.kind === "app-page" || props.kind === "app-route-handler") && (props.bypassInterceptionContextCache || props.forceDynamic === true && responseStagePolicy === null) ? "bypass" : canUseSharedWorkerResponseStage ? "shared" : "bypass";
+		let dispatchRequest = props.kind === "app-page" ? prepareSharedAppPageDispatch(stageRequest, cache) : stageRequest;
+		let canonicalRsc = null;
+		if (cache === "shared" && props.kind === "app-page" && props.isRscRequest && props.matchKind === "request" && props.interceptionContext === null && props.interceptionId === null && props.mountedSlotsHeader === null) {
+			const headers = new Headers(dispatchRequest.headers);
+			if (props.renderMode === "navigation" ? canonicalizePrewarmableRscRequestHeaders(headers) : props.renderMode === "prefetch-loading-shell" && props.canUseCanonicalLoadingShell ? canonicalizeLoadingShellRscRequestHeaders(headers) : false) {
+				canonicalRsc = {
+					headers,
+					navigation: props.renderMode === "navigation"
+				};
+				dispatchRequest = cloneRequestWithHeaders(dispatchRequest, headers);
+			}
+		}
+		let stageProps = {
+			...props,
+			cacheability: {
+				...props.cacheability,
+				policyHeaders: responseStagePolicy
+			}
+		};
+		if (cache === "shared" && responseStagePolicy === null && stageProps.kind === "app-page") {
+			const projection = readCacheabilityRequestProjection(options);
+			if (projection && isStaticCandidateAppPageDispatch(projection, dispatchRequest, stageProps)) {
+				const queryFree = withoutAppPageDispatchQuery(dispatchRequest.url, stageProps);
+				dispatchRequest = cloneRequestWithUrl(dispatchRequest, queryFree.url);
+				stageProps = queryFree.props;
+			}
+		}
+		if (canonicalRsc) {
+			const rscPath = canonicalRsc.navigation ? createCanonicalRscRequestUrl(dispatchRequest.url) : await createRscRequestUrl(dispatchRequest.url, canonicalRsc.headers);
+			dispatchRequest = cloneRequestWithUrl(dispatchRequest, new URL(rscPath, dispatchRequest.url).toString());
+		}
+		const cacheIdentity = cache === "shared" && responseStagePolicy === null && stageProps.kind === "app-page" && stageProps.matchKind !== "interception" && stageProps.interceptionContext === null && stageProps.interceptionId === null && stageProps.mountedSlotsHeader === null && adapterUsesQueryFreeCacheIdentity() ? createSharedAppPageCacheIdentity(dispatchRequest, stageProps) : void 0;
+		let response = await dispatchResponseStage(dispatchRequest, stageProps, cacheIdentity ? {
+			cache,
+			cacheIdentity
+		} : { cache });
+		if (stageRequest.method.toUpperCase() === "HEAD" && response.body) {
+			await response.body.cancel();
+			response = new Response(null, {
+				headers: response.headers,
+				status: response.status,
+				statusText: response.statusText
+			});
+		}
+		if (props.kind !== "app-page" || !props.isRscRequest) return response;
+		const headers = new Headers(response.headers);
+		if (Object.keys(props.params).length > 0) headers.set(VINEXT_PARAMS_HEADER, encodeURIComponent(JSON.stringify(props.params)));
+		else headers.delete(VINEXT_PARAMS_HEADER);
+		headers.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(props.resolvedUrl));
+		return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		}));
+	} : void 0;
+	const responseStageRequest = (stageRequest = request) => {
+		const activeHeaders = getHeadersContext()?.headers;
+		if (!activeHeaders) return stageRequest;
+		return cloneRequestWithHeaders(stageRequest, new Headers(activeHeaders));
+	};
+	const renderMetadataRouteIfMatched = async () => {
+		if (!filesystemRouteEligible || (options.isMetadataRoute ? !options.isMetadataRoute(cleanPathname) : !options.handleMetadataRouteRequest)) return null;
+		const metadataRoutePathname = cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname;
+		const metadataResponseStage = transportedResponseStage ?? options.renderResponseStageLocally;
+		if (metadataResponseStage) {
+			const response = await metadataResponseStage(responseStageRequest(), {
+				kind: "app-metadata",
+				buildId: options.buildId,
+				cacheability: responseStageCacheability(resolvedUrl),
+				canonicalPathname,
+				cleanPathname,
+				draftModeCookie,
+				isRscRequest,
+				middlewareCookieOverlay,
+				mountedSlotsHeader,
+				protocolVersion: 10,
+				requestOrigin: url.origin,
+				renderMode,
+				resolvedUrl,
+				routePathname: metadataRoutePathname,
+				scriptNonce: scriptNonce ?? null
+			});
+			if (response.headers.get("x-vinext-app-metadata-stage-no-match") === "1") {
+				await response.body?.cancel();
+				return null;
+			}
+			return response;
+		}
+		return options.handleMetadataRouteRequest?.(cleanPathname, metadataRoutePathname) ?? null;
+	};
+	const applyConfigHeadersToResponseStage = async (response, preserveExistingPolicy = false) => {
+		const headers = new Headers(response.headers);
+		copyLinkHeaderProvenance(response.headers, headers);
+		await applyAppRscConfigHeaders(headers, request, {
+			basePath: options.basePath,
+			configHeaders: options.configHeaders,
+			i18nConfig: options.i18nConfig,
+			middlewareHeaders: middlewareContext.headers,
+			overwriteExisting: preserveExistingPolicy ? /* @__PURE__ */ new Set() : isCdnResponsePolicyHeader,
+			recordCacheability: dispatchResponseStage === void 0,
+			requestContext: preMiddlewareRequestContext
+		});
+		return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		}));
+	};
+	let preHandlerResponseHeadersPromise;
+	const loadPreHandlerResponseHeaders = () => preHandlerResponseHeadersPromise ??= (async () => {
+		const headers = new Headers();
+		await applyAppRscConfigHeaders(headers, request, {
+			basePath: options.basePath,
+			configHeaders: options.configHeaders,
+			i18nConfig: options.i18nConfig,
+			overwriteExisting: isCdnResponsePolicyHeader,
+			recordCacheability: false,
+			requestContext: preMiddlewareRequestContext
+		});
+		mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+		return headers;
+	})();
+	let outerResponsePolicyPromise;
+	const loadOuterResponsePolicy = () => outerResponsePolicyPromise ??= Promise.all([loadPreHandlerResponseHeaders(), loadResponseStagePolicy()]).then(([headers, responseStagePolicy]) => captureCdnResponsePolicyOverrides(headers, new Headers(responseStagePolicy ?? [])));
+	const composeResponseStageResponse = async (response) => {
+		const transportedLink = consumeResponseStageLinkProvenance(response);
+		response = transportedLink.response;
+		response = await applyConfigHeadersToResponseStage(response, Boolean(dispatchResponseStage || options.renderResponseStageLocally));
+		response = applyMiddlewareContextToResponse(response, middlewareContext, transportedLink.appendToPostConfigLink);
+		reconcileCdnResponseHeadersAfterOuterPolicy(response.headers, await loadOuterResponsePolicy());
+		return markAppRscResponseConfigHeadersApplied(response);
+	};
 	const postMiddlewareRequestContext = buildPostMwRequestContext(userlandRequest);
 	filesystemRouteEligible ||= didMiddlewareRewrite;
 	for (const rewrite of options.configRewrites.beforeFiles) {
@@ -333,7 +528,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 			rewrites: [rewrite],
 			validateExternalRewriteRequest: () => validateClaimedOutsideBasePathRsc(true)
-		}, matchPathname(cleanPathname));
+		}, matchPathname(cleanPathname), dispatchResponseStage === void 0);
 		if (beforeFilesRewrite instanceof Response) return beforeFilesRewrite;
 		if (beforeFilesRewrite) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, beforeFilesRewrite);
@@ -360,7 +555,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 				rewrites: [rewrite],
 				validateExternalRewriteRequest: () => validateClaimedOutsideBasePathRsc(true)
-			}, matchPathname(cleanPathname));
+			}, matchPathname(cleanPathname), dispatchResponseStage === void 0);
 			if (rewritten instanceof Response) return rewritten;
 			if (!rewritten) continue;
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
@@ -379,7 +574,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 				rewrites: [rewrite],
 				validateExternalRewriteRequest: () => validateClaimedOutsideBasePathRsc(true)
-			}, matchPathname(cleanPathname));
+			}, matchPathname(cleanPathname), dispatchResponseStage === void 0);
 			if (rewritten instanceof Response) return rewritten;
 			if (!rewritten) continue;
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
@@ -398,20 +593,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!imageRedirect) return new Response("Invalid image optimization parameters", { status: 400 });
 		return Response.redirect(new URL(imageRedirect, url.origin).href, 302);
 	}
-	if (filesystemRouteEligible && options.handleMetadataRouteRequest) {
-		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
-		if (metadataRouteResponse && HAS_CONFIG_HEADERS && options.configHeaders.length) {
-			const { applyConfigHeadersToResponse } = await import("./config-headers.js");
-			applyConfigHeadersToResponse(metadataRouteResponse.headers, {
-				basePathState,
-				configHeaders: options.configHeaders,
-				overwriteExisting: STATIC_METADATA_CONFIG_HEADER_OVERRIDES,
-				pathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
-				requestContext: preMiddlewareRequestContext
-			});
-		}
-		if (metadataRouteResponse) return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
-	}
+	const metadataRouteResponse = await renderMetadataRouteIfMatched();
+	if (metadataRouteResponse) return composeResponseStageResponse(metadataRouteResponse);
 	const publicFileResponse = filesystemRouteEligible ? resolvePublicFileRoute({
 		cleanPathname,
 		middlewareContext,
@@ -488,7 +671,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			if (sourceMiddlewareRequest.body && !sourceMiddlewareRequest.bodyUsed && !sourceMiddlewareRequest.body.locked) sourceMiddlewareRequest.body.cancel().catch(() => {});
 			if (sourceRequest !== userlandRequest && sourceRequest.body && !sourceRequest.bodyUsed && !sourceRequest.body.locked) sourceRequest.body.cancel().catch(() => {});
 		}
-		if (sourceMiddlewareResult.pathnameEligible) markRouteCacheabilityDynamic(sourceMiddlewareResult.matched ? "middleware matched this request" : "middleware is eligible for this pathname");
+		if (!dispatchResponseStage && sourceMiddlewareResult.pathnameEligible) markRouteCacheabilityDynamic(sourceMiddlewareResult.matched ? "middleware matched this request" : "middleware is eligible for this pathname");
 		if (sourceMiddlewareResult.kind === "response") {
 			options.clearRequestContext();
 			return sourceMiddlewareResult.response;
@@ -509,7 +692,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			targetHeadersContext.headers.set(name, value);
 			addedSourceHeader = true;
 		}
-		if (addedSourceHeader) targetHeadersContext.readonlyHeaders = void 0;
+		if (addedSourceHeader) {
+			targetHeadersContext.readonlyHeaders = void 0;
+			canUseSharedWorkerResponseStage = false;
+		}
 		if (sourceMiddlewareResult.rewritten) {
 			const rewrittenSourceMatch = options.matchRoute(sourceMiddlewareResult.cleanPathname);
 			if (sourceMiddlewareResult.search !== sourceUrl.search || rewrittenSourceMatch?.route !== interceptionSourceMatch.route || !haveSamePageParams(rewrittenSourceMatch.params, interceptionSourceMatch.params)) {
@@ -566,6 +752,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			basePath: options.basePath,
 			configHeaders: options.configHeaders,
 			i18nConfig: options.i18nConfig,
+			recordCacheability: dispatchResponseStage === void 0,
 			requestContext: preMiddlewareRequestContext
 		});
 	}
@@ -590,9 +777,54 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
 		if (!filesystemRouteEligible) return null;
+		let sharedOuterPolicyNeedsReconciliation = false;
+		const dispatchPagesResponseStage = dispatchResponseStage ? async (stageRequest, resourceKind, dataKind, hasRequestAwareDocument) => {
+			const pagesOnDemandRevalidate = resourceKind === "page" && isOnDemandRevalidateRequest(stageRequest.headers.get("x-prerender-revalidate"));
+			const cache = responseStageProbeMode || pagesOnDemandRevalidate || hasPagesPreviewCookie(stageRequest.headers.get("cookie")) || resourceKind === "page" && dataKind === "static" && hasRequestAwareDocument ? "bypass" : canUseSharedWorkerResponseStage ? "shared" : "bypass";
+			let response = await dispatchResponseStage(responseStageRequest(stageRequest), {
+				kind: "hybrid-pages",
+				buildId: options.buildId,
+				cacheability: {
+					...responseStageCacheability(resolvedUrl),
+					policyHeaders: await loadResponseStagePolicy(),
+					...isDataRequest ? { representation: "pages-data" } : {}
+				},
+				allowRscDocumentFallback: didMiddlewareRewritePathname || allowInternalRscDocumentFallback,
+				appRouteMatch: match ? {
+					isDynamic: match.route.isDynamic,
+					pattern: match.route.pattern
+				} : null,
+				canonicalPathname,
+				cleanPathname,
+				draftModeCookie,
+				isDataRequest,
+				isRscRequest,
+				matchKind,
+				middlewareCookieOverlay,
+				preHandlerHeaders: cache === "shared" && resourceKind === "page" && dataKind === "static" ? null : [...await loadPreHandlerResponseHeaders()],
+				protocolVersion: 10,
+				requestOrigin: url.origin,
+				resourceKind,
+				requestUrl: request.url,
+				resolvedUrl,
+				scriptNonce: scriptNonce ?? null
+			}, { cache });
+			const policyOwner = resourceKind === "page" ? consumePagesResponseStagePolicyOwner(response) : {
+				owner: null,
+				response
+			};
+			response = policyOwner.response;
+			const requestTimePolicyOwner = policyOwner.owner === "request-time" || policyOwner.owner === null && dataKind === "server";
+			sharedOuterPolicyNeedsReconciliation = cache === "shared" && resourceKind === "page" && !requestTimePolicyOwner;
+			const responseStageHasContentLength = response.headers.has("Content-Length");
+			response = await applyConfigHeadersToResponseStage(response, resourceKind === "api" || requestTimePolicyOwner);
+			if (!responseStageHasContentLength) response.headers.delete("Content-Length");
+			return response;
+		} : void 0;
 		const response = !isInterceptionMatch && (match === null || match.route.isDynamic) ? await options.renderPagesFallback?.({
 			appRouteMatch: match ?? null,
 			allowRscDocumentFallback: didMiddlewareRewritePathname || allowInternalRscDocumentFallback,
+			dispatchPagesResponseStage,
 			isDataRequest,
 			isRscRequest,
 			matchKind,
@@ -603,14 +835,17 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			url
 		}) ?? null : null;
 		if (response) preserveRouteCacheabilityResponsePolicy();
-		if (!response || !pagesDataRequest || resolvedUrl === originalResolvedUrl) return response;
+		if (!response) return null;
+		if (sharedOuterPolicyNeedsReconciliation) reconcileCdnResponseHeadersAfterOuterPolicy(response.headers, await loadOuterResponsePolicy());
+		if (!pagesDataRequest || resolvedUrl === originalResolvedUrl) return dispatchPagesResponseStage ? markAppRscResponseConfigHeadersApplied(response) : response;
 		const headers = new Headers(response.headers);
 		headers.set("x-nextjs-rewrite", resolvedUrl);
-		return new Response(response.body, {
+		const rewrittenResponse = new Response(response.body, {
 			headers,
 			status: response.status,
 			statusText: response.statusText
 		});
+		return dispatchPagesResponseStage ? markAppRscResponseConfigHeadersApplied(rewrittenResponse) : rewrittenResponse;
 	};
 	const staticPagesFallbackResponse = await renderPagesForMatchKind("static");
 	if (staticPagesFallbackResponse) {
@@ -626,7 +861,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 			rewrites: [rewrite],
 			validateExternalRewriteRequest: () => validateClaimedOutsideBasePathRsc(true)
-		}, matchPathname(cleanPathname));
+		}, matchPathname(cleanPathname), dispatchResponseStage === void 0);
 		if (afterFilesRewrite instanceof Response) {
 			invalidateInterceptionCacheProof();
 			return afterFilesRewrite;
@@ -639,6 +874,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		filesystemRouteEligible = true;
 		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
 		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
+		const rewrittenMetadataResponse = await renderMetadataRouteIfMatched();
+		if (rewrittenMetadataResponse) return composeResponseStageResponse(rewrittenMetadataResponse);
 		match = matchCleanPathname();
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -666,7 +903,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 			rewrites: [rewrite],
 			validateExternalRewriteRequest: () => validateClaimedOutsideBasePathRsc(true)
-		}, matchPathname(cleanPathname));
+		}, matchPathname(cleanPathname), dispatchResponseStage === void 0);
 		if (fallbackRewrite instanceof Response) {
 			invalidateInterceptionCacheProof();
 			return fallbackRewrite;
@@ -679,6 +916,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		filesystemRouteEligible = true;
 		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
 		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
+		const rewrittenMetadataResponse = await renderMetadataRouteIfMatched();
+		if (rewrittenMetadataResponse) return composeResponseStageResponse(rewrittenMetadataResponse);
 		match = matchCleanPathname();
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -730,13 +969,31 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			options.clearRequestContext();
 			return new Response("", { status: 404 });
 		}
-		const renderedNotFoundResponse = await options.renderNotFound({
+		setFrameworkRequestRoute("/404", isRscRequest);
+		const notFoundResponseStage = transportedResponseStage ?? options.renderResponseStageLocally;
+		if (notFoundResponseStage) return composeResponseStageResponse(await notFoundResponseStage(responseStageRequest(), {
+			kind: "app-not-found",
+			buildId: options.buildId,
+			cacheability: responseStageCacheability(resolvedUrl),
+			canonicalPathname,
+			cleanPathname,
+			draftModeCookie,
+			isRscRequest,
+			middlewareCookieOverlay,
+			mountedSlotsHeader,
+			protocolVersion: 10,
+			requestOrigin: url.origin,
+			renderMode,
+			resolvedUrl,
+			scriptNonce: scriptNonce ?? null
+		}));
+		const renderedNotFoundResponse = await traceAppPageRender("/404", "render", () => options.renderNotFound({
 			isRscRequest,
 			middlewareContext,
 			request,
 			route: null,
 			scriptNonce
-		});
+		}));
 		if (renderedNotFoundResponse) return renderedNotFoundResponse;
 		options.clearRequestContext();
 		const headers = new Headers();
@@ -744,7 +1001,18 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		return notFoundResponse({ headers });
 	}
 	const { route, params } = match;
-	if (options.ensureRouteLoaded) await options.ensureRouteLoaded(route);
+	const requestPathnameDiffersFromCachePath = requestCleanPathname !== cleanPathname;
+	const rawRequestPathnameIsObservable = isInterceptionMatch || route.routeHandler != null || typeof route.__loadRouteHandler === "function";
+	if ((!isInterceptionMatch || requestPathnameDiffersFromCachePath) && options.matchRequestRoute) {
+		const cachePathMatch = options.matchRoute(cleanPathname);
+		if (requestPathnameDiffersFromCachePath && rawRequestPathnameIsObservable || !cachePathMatch || cachePathMatch.route.pattern !== route.pattern || !haveSamePageParams(cachePathMatch.params, params)) {
+			bypassInterceptionContextCache = true;
+			setInterceptionResponseUncacheable(true);
+		}
+	}
+	const cachePathname = cleanPathnameIsRequestPathname ? cleanPathname : rewriteCachePathname(canonicalPathname, cleanPathname);
+	setFrameworkRequestRoute(patternToNextFormat(route.pattern), isRscRequest);
+	if (options.ensureRouteLoaded) await traceFindPageComponents(route.pattern, () => options.ensureRouteLoaded(route));
 	const resolvedSearchParams = getResolvedSearchParams();
 	if (isRouteTreePrefetchRequest(request) && !route.routeHandler) {
 		const response = await createRouteTreePrefetchResponse(route, {
@@ -754,10 +1022,14 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		options.clearRequestContext();
 		return applyMiddlewareContextToResponse(response, middlewareContext);
 	}
-	const prerenderRouteParamsMatch = matchPrerenderRouteParamsPayload(readTrustedPrerenderRouteParams(request), route.pattern, params);
+	const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
+	const prerenderRouteParamsMatch = matchPrerenderRouteParamsPayload(prerenderRouteParamsPayload, route.pattern, params);
 	const prerenderRouteParams = prerenderRouteParamsMatch?.params ?? null;
 	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
 	const renderParams = prerenderRouteParams ?? params;
+	const responseStageMatchKind = isInterceptionMatch ? "interception" : cleanPathnameIsRequestPathname && options.matchRequestRoute ? "request" : "resolved";
+	const responseStageRoutePathname = isInterceptionMatch ? preActionRoutePathname : cleanPathnameIsRequestPathname ? requestCleanPathname || "/" : cleanPathname || "/";
+	const matchedResponseStage = transportedResponseStage ?? options.renderResponseStageLocally;
 	let runtimeFallbackShells = [];
 	if (options.createPprFallbackShells && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) runtimeFallbackShells = options.createPprFallbackShells({
 		params: route.params,
@@ -772,13 +1044,42 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const rootParams = pickRootParams(renderParams, route.rootParamNames);
 	setRootParams(rootParams);
 	if (route.routeHandler) {
-		setCurrentFetchSoftTags(buildPageCacheTags(cleanPathname, [], [...route.routeSegments], "route"));
 		const routeHandlerRequest = isEdgeRouteHandler(route.routeHandler) ? userlandRequest : normalizedUserlandRequest;
 		const routeHandlerUrl = new URL(routeHandlerRequest.url);
 		const internalRscValues = isEdgeRouteHandler(route.routeHandler) ? [] : routeHandlerUrl.searchParams.getAll(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
 		routeHandlerUrl.search = resolvedSearchParams.toString();
 		for (const internalRscValue of internalRscValues) routeHandlerUrl.searchParams.append(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, internalRscValue);
+		if (matchedResponseStage) return composeResponseStageResponse(await matchedResponseStage(responseStageRequest(), {
+			kind: "app-route-handler",
+			buildId: options.buildId,
+			cacheability: responseStageCacheability(resolvedUrl),
+			bypassInterceptionContextCache,
+			cachePathname,
+			canUseCanonicalLoadingShell: route.canUseCanonicalLoadingShell === true,
+			canonicalPathname,
+			cleanPathname,
+			draftModeCookie,
+			forceDynamic: route.forceDynamic === true,
+			interceptionContext: interceptionContextHeader,
+			interceptionId: interceptionIdHeader,
+			isRscRequest,
+			matchKind: responseStageMatchKind,
+			middlewareCookieOverlay,
+			mountedSlotsHeader,
+			params,
+			protocolVersion: 10,
+			requestOrigin: url.origin,
+			renderMode,
+			resolvedUrl,
+			routePattern: route.pattern,
+			routePathname: responseStageRoutePathname,
+			scriptNonce: scriptNonce ?? null
+		}));
+		const { setCurrentFetchSoftTags } = await import("../shims/fetch-cache.js");
+		setCurrentFetchSoftTags(buildPageCacheTags(cleanPathname, [], [...route.routeSegments], "route"));
 		return options.dispatchMatchedRouteHandler({
+			bypassInterceptionContextCache,
+			cachePathname,
 			cleanPathname,
 			middlewareContext,
 			params: route.isDynamic ? renderParams : null,
@@ -787,8 +1088,34 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			searchParams: resolvedSearchParams
 		});
 	}
-	const pageResponse = await options.dispatchMatchedPage({
+	const pageResponse = matchedResponseStage ? await matchedResponseStage(responseStageRequest(), {
+		kind: "app-page",
+		buildId: options.buildId,
+		cacheability: responseStageCacheability(resolvedUrl),
+		bypassInterceptionContextCache,
+		cachePathname,
+		canUseCanonicalLoadingShell: route.canUseCanonicalLoadingShell === true,
+		canonicalPathname,
+		cleanPathname,
+		draftModeCookie,
+		forceDynamic: route.forceDynamic === true,
+		interceptionContext: isRscRequest ? interceptionContextHeader : null,
+		interceptionId: interceptionIdHeader,
+		isRscRequest,
+		matchKind: responseStageMatchKind,
+		middlewareCookieOverlay,
+		mountedSlotsHeader,
+		params,
+		protocolVersion: 10,
+		requestOrigin: url.origin,
+		renderMode,
+		resolvedUrl,
+		routePattern: route.pattern,
+		routePathname: responseStageRoutePathname,
+		scriptNonce: scriptNonce ?? null
+	}).then(composeResponseStageResponse) : await options.dispatchMatchedPage({
 		bypassInterceptionContextCache,
+		cachePathname,
 		clientReuseManifest,
 		cleanPathname,
 		displayPathname: canonicalPathname,
@@ -796,7 +1123,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		actionError: normalizedProgressiveActionError,
 		actionFailed,
 		handlerStart,
-		interceptionContext: interceptionContextHeader,
+		interceptionContext: isRscRequest ? interceptionContextHeader : null,
 		interceptionId: interceptionIdHeader,
 		interceptionPathname: cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname,
 		isProgressiveActionRender,
@@ -855,10 +1182,9 @@ function applyProgressiveActionSideEffects(response, sideEffects) {
 		});
 	}
 }
-function createAppRscHandler(options) {
-	return async function appRscHandler(rawRequest, ctx, allowInternalRscDocumentFallback = false) {
-		options.registerCacheAdapters();
-		await options.ensureInstrumentation?.();
+/** Build the request-only handler without retaining the response renderer graph. */
+function createAppRscRequestHandler(options) {
+	const handleAppRscRequestLifecycle = async (rawRequest, ctx, allowInternalRscDocumentFallback = false, dispatchResponseStage, responseStageProbeMode = null, transportedPrerenderState) => {
 		const mwCtx = rawRequest.headers.get(VINEXT_MW_CTX_HEADER);
 		const pagesDataUrl = new URL(rawRequest.url);
 		const pagesDataInScope = !options.basePath || hasBasePath(pagesDataUrl.pathname, options.basePath);
@@ -868,8 +1194,12 @@ function createAppRscHandler(options) {
 		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
 		const isPagesDataRequest = pagesDataNormalization?.isDataReq === true;
 		const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
-		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(rawRequest);
-		const isTrustedSpeculativePrerender = process.env.VINEXT_PRERENDER === "1" && rawRequest.headers.get("x-vinext-prerender-secret") !== null && rawRequest.headers.get("x-vinext-prerender-speculative") === "1";
+		const trustedPrerenderState = transportedPrerenderState !== void 0 ? transportedPrerenderState : process.env.VINEXT_PRERENDER === "1" && rawRequest.headers.get("x-vinext-prerender-secret") !== null ? {
+			routeParams: readTrustedPrerenderRouteParams(rawRequest),
+			speculative: rawRequest.headers.get(VINEXT_PRERENDER_SPECULATIVE_HEADER) === "1"
+		} : null;
+		const prerenderRouteParamsPayload = trustedPrerenderState?.routeParams ?? null;
+		const isTrustedSpeculativePrerender = trustedPrerenderState?.speculative === true;
 		const filteredHeaders = executionContext?.isInternalPagesRevalidation ? new Headers(rawRequest.headers) : filterInternalHeaders(rawRequest.headers);
 		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
 		if (isForwardedActionContext(ctx)) filteredHeaders.set("x-action-forwarded", "1");
@@ -885,14 +1215,18 @@ function createAppRscHandler(options) {
 		}
 		const request = cloneRequestWithHeaders(appRequest, filteredHeaders);
 		const pagesDataRequest = pagesDataNormalization?.isDataReq ? cloneRequestWithHeaders(pagesDataCandidate, filteredHeaders) : null;
+		const headersContext = headersContextFromRequest(request, { draftModeSecret: options.draftModeSecret });
 		const requestContext = createRequestContext({
-			headersContext: headersContextFromRequest(request, { draftModeSecret: options.draftModeSecret }),
+			headersContext,
 			executionContext,
 			unstableCacheRevalidation: "background"
 		});
 		let interceptionResponseUncacheable = false;
 		const responsePromise = runWithRequestContext(requestContext, () => runWithPrerenderWorkUnit(async () => {
-			ensureFetchPatch();
+			if (!dispatchResponseStage) {
+				const { ensureFetchPatch } = await import("../shims/fetch-cache.js");
+				ensureFetchPatch();
+			}
 			const preMiddlewareRequestContext = requestContextFromRequest(request);
 			const middlewareContext = {
 				headers: null,
@@ -901,7 +1235,7 @@ function createAppRscHandler(options) {
 			};
 			let response;
 			try {
-				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, middlewareContext, isPagesDataRequest, isPagesDataRequest, pagesDataRequest, (internalRequest) => appRscHandler(internalRequest, ctx, true), allowInternalRscDocumentFallback, (uncacheable) => {
+				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, middlewareContext, isPagesDataRequest, isPagesDataRequest, pagesDataRequest, (internalRequest) => appRscHandler(internalRequest, ctx, true, dispatchResponseStage, responseStageProbeMode, trustedPrerenderState, true), allowInternalRscDocumentFallback, dispatchResponseStage, responseStageProbeMode, (uncacheable) => {
 					interceptionResponseUncacheable = uncacheable;
 				});
 			} catch (error) {
@@ -913,6 +1247,7 @@ function createAppRscHandler(options) {
 				configHeaders: options.configHeaders,
 				i18nConfig: options.i18nConfig,
 				middlewareHeaders: middlewareContext.headers,
+				recordCacheability: dispatchResponseStage === void 0,
 				requestContext: preMiddlewareRequestContext
 			});
 			return interceptionResponseUncacheable ? markUnverifiedInterceptionResponseUncacheable(response) : response;
@@ -929,6 +1264,21 @@ function createAppRscHandler(options) {
 		}
 		return closeAfterResponseWithBody(response, requestContext);
 	};
+	const appRscHandler = async function appRscHandler(rawRequest, ctx, allowInternalRscDocumentFallback = false, dispatchResponseStage, responseStageProbeMode = null, transportedPrerenderState, detachedTrace = false) {
+		options.registerCacheAdapters();
+		await options.ensureInstrumentation?.();
+		const traceUrl = new URL(rawRequest.url);
+		return traceFrameworkRequest({
+			callback: () => handleAppRscRequestLifecycle(rawRequest, ctx, allowInternalRscDocumentFallback, dispatchResponseStage, responseStageProbeMode, transportedPrerenderState),
+			detached: detachedTrace,
+			getStatus: (response) => response?.status,
+			headers: rawRequest.headers,
+			isRsc: traceUrl.pathname.endsWith(".rsc") || rawRequest.headers.get("RSC") === "1",
+			method: rawRequest.method,
+			target: traceUrl.pathname + traceUrl.search
+		});
+	};
+	return appRscHandler;
 }
 //#endregion
-export { createAppRscHandler };
+export { createAppRscRequestHandler };