@qzsy/vinext 0.1.7

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

@@ -0,0 +1,538 @@
+import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { ACTION_REVALIDATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
+import { isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
+import { notFoundResponse } from "./http-error-responses.js";
+import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
+import { headersContextFromRequest } from "../shims/headers.js";
+import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { mergeRewriteQuery } from "../utils/query.js";
+import { getScriptNonceFromHeaderSources } from "./csp.js";
+import { normalizeDefaultLocalePathname } from "./pages-i18n.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 { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import "./app-page-response.js";
+import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
+import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
+import { flattenErrorCauses } from "../utils/error-cause.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
+import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
+import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
+import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
+import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
+import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
+//#region src/server/app-rsc-handler.ts
+const STATIC_METADATA_CONFIG_HEADER_OVERRIDES = new Set(["cache-control"]);
+function applyMiddlewareContextToResponse(response, middlewareContext) {
+	if (!middlewareContext.headers && middlewareContext.status == null) return response;
+	const headers = new Headers(response.headers);
+	mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+	return new Response(response.body, {
+		status: middlewareContext.status ?? response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function hasProperty(value, key) {
+	return key in value;
+}
+function isEdgeRouteHandler(handler) {
+	if (!handler || typeof handler !== "object" || !hasProperty(handler, "runtime")) return false;
+	return handler.runtime === "edge" || handler.runtime === "experimental-edge";
+}
+function isExecutionContextLike(value) {
+	if (!value || typeof value !== "object") return false;
+	return hasProperty(value, "waitUntil") && typeof value.waitUntil === "function";
+}
+function createMissingServerActionResponse(options, actionId) {
+	console.warn(getServerActionNotFoundMessage(actionId));
+	options.clearRequestContext();
+	return createServerActionNotFoundResponse();
+}
+function redirectDestinationWithBasePath(destination, basePath) {
+	if (!basePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
+	return basePath + destination;
+}
+async function applyRewrite(options, cleanPathname) {
+	if (!options.rewrites.length) return null;
+	const rewritten = matchRewrite(cleanPathname, options.rewrites, options.requestContext, options.basePathState);
+	if (!rewritten) return null;
+	if (isExternalUrl(rewritten)) {
+		options.clearRequestContext();
+		return proxyExternalRequest(options.request, rewritten);
+	}
+	return rewritten;
+}
+function requestContextForResolvedUrl(requestContext, resolvedUrl, baseUrl) {
+	return {
+		cookies: requestContext.cookies,
+		headers: requestContext.headers,
+		host: requestContext.host,
+		query: new URL(resolvedUrl, baseUrl).searchParams
+	};
+}
+function pathnameForResolvedUrl(resolvedUrl) {
+	return resolvedUrl.split("#", 1)[0].split("?", 1)[0];
+}
+function applyConfigHeadersToMiddlewareRedirect(response, options) {
+	if (response.status < 300 || response.status >= 400) return response;
+	if (!options.configHeaders.length) return response;
+	const headers = new Headers();
+	applyConfigHeadersToResponse(headers, {
+		configHeaders: options.configHeaders,
+		pathname: options.pathname,
+		requestContext: options.requestContext,
+		basePathState: options.basePathState
+	});
+	if (!headers.entries().next().done) {
+		mergeMiddlewareResponseHeaders(headers, response.headers);
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	}
+	return response;
+}
+function requestWithoutRscCacheBustingSearchParam(request) {
+	const url = new URL(request.url);
+	if (!hasRscCacheBustingSearchParam(url)) return request;
+	stripRscCacheBustingSearchParam(url);
+	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
+}
+function requestWithoutRscSuffix(request) {
+	const url = new URL(request.url);
+	const pathname = stripRscSuffix(url.pathname);
+	if (pathname === url.pathname) return request;
+	url.pathname = pathname;
+	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
+}
+async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest) {
+	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
+	if (process.env.NODE_ENV !== "production") {
+		const originBlock = options.validateDevRequestOrigin?.(request);
+		if (originBlock) return originBlock;
+	}
+	const normalized = normalizeRscRequest(request, options.basePath);
+	if (normalized instanceof Response) return normalized;
+	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest } = normalized;
+	let { pathname, cleanPathname } = normalized;
+	let resolvedUrl = cleanPathname + url.search;
+	const originalResolvedUrl = resolvedUrl;
+	const getResolvedSearchParams = () => new URL(resolvedUrl, url).searchParams;
+	const canonicalPathname = cleanPathname;
+	const basePathState = {
+		basePath: options.basePath,
+		hadBasePath: true
+	};
+	if (pathname === "/__vinext/prerender/static-params" || pathname === "/__vinext/prerender/pages-static-paths") {
+		const { handleAppPrerenderEndpoint } = await import("./app-prerender-endpoints.js");
+		const prerenderEndpointResponse = await handleAppPrerenderEndpoint(request, {
+			isPrerenderEnabled() {
+				return process.env.VINEXT_PRERENDER === "1";
+			},
+			loadPagesRoutes: options.loadPrerenderPagesRoutes,
+			pathname,
+			rootParamNamesByPattern: options.rootParamNamesByPattern,
+			staticParamsMap: options.staticParamsMap
+		});
+		if (prerenderEndpointResponse) return prerenderEndpointResponse;
+	}
+	const trailingSlashRedirect = normalizeTrailingSlash(pathname, options.basePath, options.trailingSlash, url.search);
+	if (trailingSlashRedirect) return trailingSlashRedirect;
+	const matchPathname = (p) => normalizeDefaultLocalePathname(p, options.i18nConfig, { hostname: url.hostname });
+	const redirect = matchRedirect(matchPathname(stripRscSuffix(pathname)), options.configRedirects, preMiddlewareRequestContext, basePathState);
+	if (redirect) {
+		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
+		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : preserveRedirectDestinationQuery(destination, url.search);
+		if (isDataRequest) return new Response(null, {
+			status: 200,
+			headers: { "x-nextjs-redirect": location }
+		});
+		return new Response(null, {
+			status: redirect.permanent ? 308 : 307,
+			headers: { Location: location }
+		});
+	}
+	const rscCacheBustingRedirect = await resolveInvalidRscCacheBustingRequest({
+		isRscRequest,
+		request
+	});
+	if (rscCacheBustingRedirect) return rscCacheBustingRedirect;
+	const normalizedUserlandRequest = requestWithoutRscSuffix(request);
+	const userlandRequest = requestWithoutRscCacheBustingSearchParam(normalizedUserlandRequest);
+	const middlewareContext = {
+		headers: null,
+		requestHeaders: null,
+		status: null
+	};
+	let didMiddlewareRewrite = false;
+	if (options.runMiddleware) {
+		const middlewareResult = await options.runMiddleware({
+			cleanPathname,
+			context: middlewareContext,
+			isDataRequest,
+			request: userlandRequest
+		});
+		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
+			basePathState,
+			configHeaders: options.configHeaders,
+			pathname: matchPathname(cleanPathname),
+			requestContext: preMiddlewareRequestContext
+		});
+		cleanPathname = middlewareResult.cleanPathname;
+		didMiddlewareRewrite = cleanPathname !== normalized.cleanPathname;
+		if (middlewareResult.search !== null) url.search = middlewareResult.search;
+		resolvedUrl = cleanPathname + url.search;
+	}
+	const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareContext.headers);
+	const postMiddlewareRequestContext = buildPostMwRequestContext(userlandRequest);
+	for (const rewrite of options.configRewrites.beforeFiles) {
+		const beforeFilesRewrite = await applyRewrite({
+			basePathState,
+			clearRequestContext: options.clearRequestContext,
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
+		}, matchPathname(cleanPathname));
+		if (beforeFilesRewrite instanceof Response) return beforeFilesRewrite;
+		if (beforeFilesRewrite) {
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, beforeFilesRewrite);
+			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		}
+	}
+	if (isImageOptimizationPath(cleanPathname)) {
+		const imageRedirect = resolveDevImageRedirect(url, [...options.imageConfig?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...options.imageConfig?.imageSizes ?? DEFAULT_IMAGE_SIZES], options.imageConfig?.qualities, { isDev: options.isDev });
+		if (!imageRedirect) return new Response("Invalid image optimization parameters", { status: 400 });
+		return Response.redirect(new URL(imageRedirect, url.origin).href, 302);
+	}
+	if (options.handleMetadataRouteRequest) {
+		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
+		if (metadataRouteResponse) {
+			applyConfigHeadersToResponse(metadataRouteResponse.headers, {
+				basePathState,
+				configHeaders: options.configHeaders,
+				overwriteExisting: STATIC_METADATA_CONFIG_HEADER_OVERRIDES,
+				pathname: matchPathname(cleanPathname),
+				requestContext: preMiddlewareRequestContext
+			});
+			return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
+		}
+	}
+	const publicFileResponse = resolvePublicFileRoute({
+		cleanPathname,
+		middlewareContext,
+		pathname,
+		publicFiles: options.publicFiles,
+		request
+	});
+	if (publicFileResponse) {
+		options.clearRequestContext();
+		return publicFileResponse;
+	}
+	stripRscCacheBustingSearchParam(url);
+	const resolved = new URL(resolvedUrl, url);
+	stripRscCacheBustingSearchParam(resolved);
+	resolvedUrl = resolved.pathname + resolved.search + resolved.hash;
+	options.setNavigationContext({
+		pathname: canonicalPathname,
+		searchParams: getResolvedSearchParams(),
+		params: {}
+	});
+	const preActionMatch = options.matchRoute(cleanPathname);
+	if (preActionMatch) setRootParams(pickRootParams(preActionMatch.params, preActionMatch.route.rootParamNames));
+	const actionId = request.headers.get("x-rsc-action") ?? request.headers.get("next-action");
+	const contentType = request.headers.get("content-type") || "";
+	const isPostRequest = request.method.toUpperCase() === "POST";
+	let progressiveActionResult = null;
+	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
+		if (options.handleProgressiveActionRequest) progressiveActionResult = await options.handleProgressiveActionRequest({
+			actionId,
+			cleanPathname,
+			contentType,
+			middlewareContext,
+			request
+		});
+		else if (preActionMatch?.route.__loadPage && !preActionMatch.route.__loadRouteHandler) return createMissingServerActionResponse(options, null);
+	}
+	if (progressiveActionResult instanceof Response) return progressiveActionResult;
+	const progressiveActionFormState = progressiveActionResult?.kind === "form-state" ? progressiveActionResult : null;
+	const isProgressiveActionRender = progressiveActionFormState !== null;
+	const formState = progressiveActionFormState?.formState ?? null;
+	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
+	const actionFailed = failedProgressiveActionResult !== null;
+	const actionError = failedProgressiveActionResult?.actionError;
+	const serverActionResponse = isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
+		actionId,
+		cleanPathname,
+		contentType,
+		interceptionContext: interceptionContextHeader,
+		isRscRequest,
+		middlewareContext,
+		mountedSlotsHeader,
+		request,
+		searchParams: getResolvedSearchParams()
+	}) : null;
+	if (serverActionResponse) return serverActionResponse;
+	if (isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
+	let match = preActionMatch;
+	const renderPagesForMatchKind = async (matchKind) => {
+		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
+			appRouteMatch: match ?? null,
+			allowRscDocumentFallback: didMiddlewareRewrite,
+			isDataRequest,
+			isRscRequest,
+			matchKind,
+			middlewareContext,
+			pathname: resolvedUrl,
+			pagesDataRequest,
+			request,
+			url
+		}) ?? null : null;
+		if (!response || !pagesDataRequest || resolvedUrl === originalResolvedUrl) return response;
+		const headers = new Headers(response.headers);
+		headers.set("x-nextjs-rewrite", resolvedUrl);
+		return new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	};
+	const staticPagesFallbackResponse = await renderPagesForMatchKind("static");
+	if (staticPagesFallbackResponse) {
+		options.clearRequestContext();
+		return staticPagesFallbackResponse;
+	}
+	if (!match || match.route.isDynamic) for (const rewrite of options.configRewrites.afterFiles) {
+		const afterFilesRewrite = await applyRewrite({
+			basePathState,
+			clearRequestContext: options.clearRequestContext,
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
+		}, matchPathname(cleanPathname));
+		if (afterFilesRewrite instanceof Response) return afterFilesRewrite;
+		if (!afterFilesRewrite) continue;
+		resolvedUrl = mergeRewriteQuery(resolvedUrl, afterFilesRewrite);
+		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		match = options.matchRoute(cleanPathname);
+		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
+		if (rewrittenStaticPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenStaticPagesResponse;
+		}
+		const rewrittenDynamicPagesResponse = await renderPagesForMatchKind("dynamic");
+		if (rewrittenDynamicPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenDynamicPagesResponse;
+		}
+		if (match) break;
+	}
+	const dynamicPagesFallbackResponse = await renderPagesForMatchKind("dynamic");
+	if (dynamicPagesFallbackResponse) {
+		options.clearRequestContext();
+		return dynamicPagesFallbackResponse;
+	}
+	if (!match) for (const rewrite of options.configRewrites.fallback) {
+		const fallbackRewrite = await applyRewrite({
+			basePathState,
+			clearRequestContext: options.clearRequestContext,
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
+		}, matchPathname(cleanPathname));
+		if (fallbackRewrite instanceof Response) return fallbackRewrite;
+		if (!fallbackRewrite) continue;
+		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		match = options.matchRoute(cleanPathname);
+		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
+		if (rewrittenStaticPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenStaticPagesResponse;
+		}
+		const rewrittenDynamicPagesResponse = await renderPagesForMatchKind("dynamic");
+		if (rewrittenDynamicPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenDynamicPagesResponse;
+		}
+		if (match) break;
+	}
+	if (pagesDataRequest) {
+		options.clearRequestContext();
+		return buildNextDataNotFoundResponse();
+	}
+	if (!match) {
+		if (process.env.NODE_ENV !== "production" && canonicalPathname === "/favicon.ico") {
+			options.clearRequestContext();
+			return new Response("", { status: 404 });
+		}
+		const renderedNotFoundResponse = await options.renderNotFound({
+			isRscRequest,
+			middlewareContext,
+			request,
+			route: null,
+			scriptNonce
+		});
+		if (renderedNotFoundResponse) return renderedNotFoundResponse;
+		options.clearRequestContext();
+		const headers = new Headers();
+		mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+		return notFoundResponse({ headers });
+	}
+	const { route, params } = match;
+	if (options.ensureRouteLoaded) await options.ensureRouteLoaded(route);
+	const prerenderRouteParamsMatch = matchPrerenderRouteParamsPayload(readTrustedPrerenderRouteParams(request), route.pattern, params);
+	const prerenderRouteParams = prerenderRouteParamsMatch?.params ?? null;
+	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
+	const renderParams = prerenderRouteParams ?? params;
+	const resolvedSearchParams = getResolvedSearchParams();
+	let runtimeFallbackShells = [];
+	if (options.createPprFallbackShells && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) runtimeFallbackShells = options.createPprFallbackShells({
+		params: route.params,
+		pattern: route.pattern,
+		rootParamNames: route.rootParamNames
+	}, params);
+	options.setNavigationContext({
+		pathname: canonicalPathname,
+		searchParams: resolvedSearchParams,
+		params: renderParams
+	});
+	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);
+		return options.dispatchMatchedRouteHandler({
+			cleanPathname,
+			middlewareContext,
+			params: route.isDynamic ? renderParams : null,
+			request: new Request(routeHandlerUrl, routeHandlerRequest),
+			route,
+			searchParams: resolvedSearchParams
+		});
+	}
+	const pageResponse = await options.dispatchMatchedPage({
+		clientReuseManifest,
+		cleanPathname,
+		displayPathname: canonicalPathname,
+		formState,
+		actionError,
+		actionFailed,
+		handlerStart,
+		interceptionContext: interceptionContextHeader,
+		isProgressiveActionRender,
+		isRscRequest,
+		middlewareContext,
+		mountedSlotsHeader,
+		params: renderParams,
+		pprFallbackCacheShells: runtimeFallbackShells,
+		pprFallbackShell: isPrerenderFallbackShell ? {
+			fallbackParamNames: prerenderRouteParamsMatch.fallbackParamNames,
+			routePattern: route.pattern
+		} : void 0,
+		renderedConcreteUrlPaths: getRenderedConcreteUrlPathsForRoute(route.pattern),
+		skipStaticParamsValidation: isPrerenderFallbackShell,
+		staticParamsValidationParams: prerenderRouteParams === null || isPrerenderFallbackShell ? void 0 : params,
+		rootParams,
+		request,
+		route,
+		scriptNonce,
+		searchParams: resolvedSearchParams,
+		renderMode
+	});
+	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionFormState);
+	return pageResponse;
+}
+/**
+* Append `Set-Cookie` headers and the `x-action-revalidated` marker captured
+* during progressive (no-JS) server action execution to the page render
+* response. See issue #1483.
+*
+* Falls back to rebuilding the response when the headers object is immutable
+* (e.g. `Response.redirect()`), so cookies set by the action ride out on a
+* redirect issued during the rerender too.
+*/
+function applyProgressiveActionSideEffects(response, sideEffects) {
+	const hasPendingCookies = sideEffects.pendingCookies.length > 0;
+	const hasDraftCookie = Boolean(sideEffects.draftCookie);
+	const hasRevalidationKind = sideEffects.revalidationKind !== 0;
+	if (!hasPendingCookies && !hasDraftCookie && !hasRevalidationKind) return response;
+	const applyTo = (headers) => {
+		for (const cookie of sideEffects.pendingCookies) headers.append("Set-Cookie", cookie);
+		if (sideEffects.draftCookie) headers.append("Set-Cookie", sideEffects.draftCookie);
+		if (hasRevalidationKind) headers.set(ACTION_REVALIDATED_HEADER, JSON.stringify(sideEffects.revalidationKind));
+	};
+	try {
+		applyTo(response.headers);
+		return response;
+	} catch {
+		const headers = new Headers(response.headers);
+		applyTo(headers);
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	}
+}
+function createAppRscHandler(options) {
+	return async function appRscHandler(rawRequest, ctx) {
+		options.registerCacheAdapters();
+		await options.ensureInstrumentation?.();
+		const mwCtx = rawRequest.headers.get(VINEXT_MW_CTX_HEADER);
+		const hasDataRequestHeader = rawRequest.headers.get("x-nextjs-data") === "1";
+		const pagesDataUrl = new URL(rawRequest.url);
+		const pagesDataInScope = !options.basePath || hasBasePath(pagesDataUrl.pathname, options.basePath);
+		if (pagesDataInScope) pagesDataUrl.pathname = stripBasePath(pagesDataUrl.pathname, options.basePath);
+		const pagesDataCandidate = pagesDataInScope ? cloneRequestWithUrl(rawRequest, pagesDataUrl.toString()) : null;
+		const pagesDataNormalization = options.renderPagesFallback && pagesDataCandidate ? normalizePagesDataRequest(pagesDataCandidate, options.buildId) : null;
+		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
+		const isDataRequest = hasDataRequestHeader || pagesDataNormalization?.isDataReq === true;
+		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(rawRequest);
+		const filteredHeaders = filterInternalHeaders(rawRequest.headers);
+		if (mwCtx !== null) filteredHeaders.set(VINEXT_MW_CTX_HEADER, mwCtx);
+		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
+		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
+		let appRequest = rawRequest;
+		if (pagesDataNormalization?.isDataReq) {
+			const appRequestUrl = new URL(pagesDataNormalization.request.url);
+			appRequestUrl.pathname = addBasePathToPathname(appRequestUrl.pathname, options.basePath);
+			appRequest = cloneRequestWithUrl(pagesDataCandidate, appRequestUrl.toString());
+		}
+		const request = cloneRequestWithHeaders(appRequest, filteredHeaders);
+		const pagesDataRequest = pagesDataNormalization?.isDataReq ? cloneRequestWithHeaders(pagesDataCandidate, filteredHeaders) : null;
+		const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
+		return runWithRequestContext(createRequestContext({
+			headersContext: headersContextFromRequest(request, { draftModeSecret: options.draftModeSecret }),
+			executionContext,
+			unstableCacheRevalidation: "background"
+		}), () => runWithPrerenderWorkUnit(async () => {
+			ensureFetchPatch();
+			const preMiddlewareRequestContext = requestContextFromRequest(request);
+			let response;
+			try {
+				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest);
+			} catch (error) {
+				if (process.env.NODE_ENV !== "production") flattenErrorCauses(error);
+				throw error;
+			}
+			return finalizeAppRscResponse(response, request, {
+				basePath: options.basePath,
+				configHeaders: options.configHeaders,
+				i18nConfig: options.i18nConfig,
+				requestContext: preMiddlewareRequestContext
+			});
+		}, { route: () => new URL(request.url).pathname }));
+	};
+}
+//#endregion
+export { createAppRscHandler };

package/dist/server/app-rsc-render-mode.d.ts

@@ -0,0 +1,11 @@
+//#region src/server/app-rsc-render-mode.d.ts
+type AppRscRenderMode = "navigation" | "prefetch-loading-shell" | "refresh-preserve-ui" | "action-rerender-preserve-ui";
+declare const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
+declare const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
+declare const APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI = "refresh-preserve-ui";
+declare const APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI = "action-rerender-preserve-ui";
+declare function shouldSuppressLoadingBoundaries(mode: AppRscRenderMode): boolean;
+declare function getRscRenderModeCacheVariant(mode: AppRscRenderMode): string | null;
+declare function parseAppRscRenderMode(value: string | null): AppRscRenderMode;
+//#endregion
+export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };

package/dist/server/app-rsc-render-mode.js

@@ -0,0 +1,25 @@
+//#region src/server/app-rsc-render-mode.ts
+const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
+const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
+const APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI = "refresh-preserve-ui";
+const APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI = "action-rerender-preserve-ui";
+function shouldSuppressLoadingBoundaries(mode) {
+	return mode === "refresh-preserve-ui" || mode === "action-rerender-preserve-ui";
+}
+function shouldUsePreserveUiCacheVariant(mode) {
+	return shouldSuppressLoadingBoundaries(mode);
+}
+function getRscRenderModeCacheVariant(mode) {
+	if (mode === "prefetch-loading-shell") return "prefetch-loading-shell";
+	return shouldUsePreserveUiCacheVariant(mode) ? "preserve-ui" : null;
+}
+function parseAppRscRenderMode(value) {
+	switch (value) {
+		case APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL: return APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL;
+		case APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI: return APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI;
+		case APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI: return APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI;
+		default: return APP_RSC_RENDER_MODE_NAVIGATION;
+	}
+}
+//#endregion
+export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };

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

@@ -0,0 +1,48 @@
+import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
+import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+
+//#region src/server/app-rsc-request-normalization.d.ts
+type NormalizedRscRequest = {
+  /** Parsed URL. Callers may mutate `url.search` after middleware runs. */url: URL; /** Normalized pathname with basePath stripped. Used for all internal routing. */
+  pathname: string; /** Pathname with `.rsc` suffix removed. Used for route matching and navigation context. */
+  cleanPathname: string; /** True when the request targets a canonical `.rsc` payload URL. */
+  isRscRequest: boolean; /** Sanitized X-Vinext-Interception-Context header (null bytes stripped). null when absent. */
+  interceptionContextHeader: string | null; /** Normalized x-vinext-mounted-slots header (deduplicated, sorted). null when absent or blank. */
+  mountedSlotsHeader: string | null; /** Semantic RSC payload mode. HTML requests always normalize to "navigation". */
+  renderMode: AppRscRenderMode; /** Parsed ClientReuseManifest hint. Verification and skip authorization happen later. */
+  clientReuseManifest: ClientReuseManifestParseResult;
+};
+/**
+ * Normalize an App Router RSC request.
+ *
+ * Performs all security-sensitive and compatibility-sensitive preprocessing before
+ * route matching. The ordering of steps is security-critical — changing it introduces
+ * vulnerabilities:
+ *
+ *   1. Parse URL
+ *   2. Protocol-relative URL guard — on the raw pathname, BEFORE normalizePath collapses
+ *      `//` to `/`. If the guard ran after normalization, `//evil.com` → `/evil.com`
+ *      would bypass the check and reach the trailing-slash redirector, which echoes the
+ *      path into a `Location` header that browsers interpret as protocol-relative.
+ *   3. Strict percent-decode each segment — throws on malformed sequences (→ 400). Must
+ *      run before basePath check so %2F-encoded slashes cannot create fake basePath prefixes.
+ *   4. Collapse double-slashes, resolve `.` and `..` segments (normalizePath)
+ *   5. basePath check + strip — 404 when pathname lacks the basePath prefix.
+ *      `/__vinext/` bypasses this for internal prerender endpoints.
+ *   6. RSC detection: `.rsc` suffix, or Next-style `RSC: 1` plus the internal
+ *      `_rsc` cache-busting query. The header alone does not select payload
+ *      rendering at the canonical HTML URL, so caches that ignore Vary cannot
+ *      store Flight responses under HTML URLs.
+ *   7. cleanPathname — pathname with `.rsc` suffix stripped
+ *   8. Sanitize X-Vinext-Interception-Context — strip null bytes (header injection)
+ *   9. Normalize x-vinext-mounted-slots — dedup and sort for canonical cache keys
+ *   10. Read semantic render mode for refresh/action payload rendering
+ *   11. Parse ClientReuseManifest hints on canonical RSC payload requests
+ *
+ * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
+ *          or a NormalizedRscRequest for valid requests.
+ */
+declare function normalizeRscRequest(request: Request, basePath: string): Response | NormalizedRscRequest;
+//#endregion
+export { NormalizedRscRequest, normalizeMountedSlotsHeader, normalizeRscRequest };