vinext 1.0.0-beta.9 → 1.0.0

package/dist/server/app-rsc-redirect-flight.d.ts

@@ -24,7 +24,7 @@ import { ReactNode } from "react";
  *   `.nextjs-ref/packages/next/src/client/components/redirect.ts:20-23`
  *   `.nextjs-ref/packages/next/src/client/components/redirect-error.ts`
  */
-declare function formatNextRedirectDigest(options: {
+export declare function formatNextRedirectDigest(options: {
   type: "push" | "replace";
   url: string;
   statusCode: number;
@@ -35,7 +35,7 @@ declare function formatNextRedirectDigest(options: {
  * environment-specific renderer, which accepts a wider element type; a plain
  * throwing React element satisfies all of them.
  */
-type RedirectFlightStreamRenderer = (element: ReactNode, options: {
+export type RedirectFlightStreamRenderer = (element: ReactNode, options: {
   onError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 }) => ReadableStream<Uint8Array>;
 /**
@@ -57,9 +57,8 @@ type RedirectFlightStreamRenderer = (element: ReactNode, options: {
  * through the `buildRscRedirectFlightStream` option of
  * `buildAppPageSpecialErrorResponse`.
  */
-declare function buildRscRedirectFlightStream(options: {
+export declare function buildRscRedirectFlightStream(options: {
   renderToReadableStream: RedirectFlightStreamRenderer;
   digest: string;
 }): ReadableStream<Uint8Array>;
-//#endregion
-export { RedirectFlightStreamRenderer, buildRscRedirectFlightStream, formatNextRedirectDigest };
+//#endregion

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

@@ -1,10 +1,9 @@
 //#region src/server/app-rsc-render-mode.d.ts
-type AppRscRenderMode = "navigation" | "prefetch-empty" | "prefetch-dynamic-shell" | "prefetch-loading-shell";
-declare const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
-declare const APP_RSC_RENDER_MODE_PREFETCH_EMPTY = "prefetch-empty";
-declare const APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL = "prefetch-dynamic-shell";
-declare const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
-declare function getRscRenderModeCacheVariant(mode: AppRscRenderMode): string | null;
-declare function parseAppRscRenderMode(value: string | null): AppRscRenderMode;
-//#endregion
-export { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_EMPTY, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode };
+export type AppRscRenderMode = "navigation" | "prefetch-empty" | "prefetch-dynamic-shell" | "prefetch-loading-shell";
+export declare const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
+export declare const APP_RSC_RENDER_MODE_PREFETCH_EMPTY = "prefetch-empty";
+export declare const APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL = "prefetch-dynamic-shell";
+export declare const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
+export declare function getRscRenderModeCacheVariant(mode: AppRscRenderMode): string | null;
+export declare function parseAppRscRenderMode(value: string | null): AppRscRenderMode;
+//#endregion

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

@@ -2,7 +2,7 @@ import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 //#region src/server/app-rsc-request-normalization.d.ts
-type NormalizedRscRequest = {
+export type NormalizedRscRequest = {
   /** Parsed URL. Callers may mutate `url.search` after middleware runs. */
   url: URL;
   /** Normalized pathname with basePath stripped. Used for all internal routing. */
@@ -55,6 +55,6 @@ type NormalizedRscRequest = {
  * @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, allowOutsideBasePath?: boolean): Response | NormalizedRscRequest;
+export declare function normalizeRscRequest(request: Request, basePath: string, allowOutsideBasePath?: boolean): Response | NormalizedRscRequest;
 //#endregion
-export { NormalizedRscRequest, normalizeMountedSlotsHeader, normalizeRscRequest };
+export { normalizeMountedSlotsHeader };

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

@@ -1,6 +1,7 @@
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
-import { NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.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";
+import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { badRequestResponse, notFoundResponse } from "./http-error-responses.js";
 import { guardProtocolRelativeUrl } from "./request-pipeline.js";

package/dist/server/app-rsc-response-finalizer.d.ts

@@ -18,13 +18,17 @@ type FinalizeAppRscResponseOptions = {
    * before middleware runs.
    */
   requestContext: RequestContext;
+  /** Existing response headers that matching next.config rules may replace. */
+  overwriteExisting?: ReadonlySet<string> | ((name: string) => boolean);
   /** Response headers emitted by middleware after config matching. */
   middlewareHeaders?: Headers | null;
+  /** Whether config matching should update the active cacheability classification. */
+  recordCacheability?: boolean;
 };
 /** Mark a response whose final target pipeline has already applied config headers. */
-declare function markAppRscResponseConfigHeadersApplied(response: Response): Response;
+export declare function markAppRscResponseConfigHeadersApplied(response: Response): Response;
 /** Apply only the matching next.config headers for an App Router request. */
-declare function applyAppRscConfigHeaders(headers: Headers, request: Request, options: FinalizeAppRscResponseOptions): Promise<void>;
+export declare function applyAppRscConfigHeaders(headers: Headers, request: Request, options: FinalizeAppRscResponseOptions): Promise<void>;
 /**
  * Apply App Router response finalization that must happen outside individual
  * route dispatchers.
@@ -37,6 +41,5 @@ declare function applyAppRscConfigHeaders(headers: Headers, request: Request, op
  * headers that throw on mutation, and Next.js does not apply config headers
  * to redirects regardless.
  */
-declare function finalizeAppRscResponse(response: Response, request: Request, options: FinalizeAppRscResponseOptions): Promise<Response>;
-//#endregion
-export { applyAppRscConfigHeaders, finalizeAppRscResponse, markAppRscResponseConfigHeadersApplied };
+export declare function finalizeAppRscResponse(response: Response, request: Request, options: FinalizeAppRscResponseOptions): Promise<Response>;
+//#endregion

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

@@ -1,18 +1,17 @@
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
-import { VINEXT_RSC_VARY_HEADER } from "./headers.js";
+import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { sanitizeMethodNotAllowedHeaders } from "./http-error-responses.js";
 import { isStaticFileSignal } from "./static-file-signal.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
 import { isNonCacheableCacheControl } from "../shims/cdn-cache.js";
-import { NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, hasExplicitNonCacheableResponsePolicy } from "./cache-control.js";
+import { captureRouteCacheabilityResponsePolicy } from "../shims/cacheability-classification.js";
+import { NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, captureCdnResponsePolicyHeaders, hasExplicitNonCacheableResponsePolicy, isCdnResponsePolicyHeader } from "./cache-control.js";
 import "./app-rsc-cache-busting.js";
 import { mergeVaryHeader } from "./middleware-response-headers.js";
 import { hasPostConfigLinkHeaders } from "./app-response-header-provenance.js";
-import { CACHEABILITY_POLICY_HEADERS, captureRouteCacheabilityResponsePolicy } from "../shims/cacheability-classification.js";
 //#region src/server/app-rsc-response-finalizer.ts
 const HAS_CONFIG_HEADERS = process.env.__VINEXT_HAS_CONFIG_HEADERS !== "false";
 const configHeadersAlreadyApplied = /* @__PURE__ */ new WeakSet();
-const CONFIG_CACHE_POLICY_HEADERS = new Set(CACHEABILITY_POLICY_HEADERS);
 function normalizeExplicitNonCacheablePolicy(headers) {
 	if (!hasExplicitNonCacheableResponsePolicy(headers)) return;
 	const cacheControl = headers.get("Cache-Control");
@@ -42,7 +41,8 @@ async function applyAppRscConfigHeaders(headers, request, options) {
 		},
 		appendToPostConfigLink: hasPostConfigLinkHeaders(headers),
 		middlewareHeaders: options.middlewareHeaders,
-		overwriteExisting: CONFIG_CACHE_POLICY_HEADERS
+		recordCacheability: options.recordCacheability,
+		overwriteExisting: options.overwriteExisting ?? isCdnResponsePolicyHeader
 	});
 }
 /**
@@ -66,7 +66,7 @@ async function finalizeAppRscResponse(response, request, options) {
 	}
 	if (!response.headers.has("Cache-Control")) {
 		applyCdnResponseHeaders(response.headers, { cacheControl: "" });
-		captureRouteCacheabilityResponsePolicy(response.headers);
+		captureRouteCacheabilityResponsePolicy(captureCdnResponsePolicyHeaders(response.headers));
 	}
 	if (configHeadersAlreadyApplied.has(response)) {
 		normalizeExplicitNonCacheablePolicy(response.headers);

package/dist/server/app-rsc-response-stage.d.ts

@@ -0,0 +1,6 @@
+import { VinextResponseStageDispatchOptions } from "./multi-stage.js";
+import { AppWorkerResponseStageProps } from "./app-worker-stages.js";
+import { AppRscHandlerRoute, CreateAppRscHandlerOptions } from "./app-rsc-handler.js";
+//#region src/server/app-rsc-response-stage.d.ts
+export declare function renderAppWorkerResponseStage<TRoute extends AppRscHandlerRoute>(options: CreateAppRscHandlerOptions<TRoute>, rawRequest: Request, ctx: unknown, props: AppWorkerResponseStageProps, _stageOptions?: VinextResponseStageDispatchOptions): Promise<Response>;
+//#endregion

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

@@ -0,0 +1,251 @@
+import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { closeAfterResponse, closeAfterResponseWithBody, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import "./headers.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders } from "./request-pipeline.js";
+import { applyEffectiveRequestCookieHeader, getDraftModeCookieHeader, headersContextFromRequest, restoreDraftModeTransition } from "../shims/headers.js";
+import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { traceFindPageComponents } from "./pages-execution-tracing.js";
+import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, hasRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { traceAppPageRender } from "./app-page-tracing.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
+import "./app-worker-stages.js";
+import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
+import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
+import { stripInheritedResponseStageCookies } from "./response-stage-policy.js";
+//#region src/server/app-rsc-response-stage.ts
+function haveSamePageParams(first, second) {
+	const firstKeys = Object.keys(first);
+	const secondKeys = Object.keys(second);
+	if (firstKeys.length !== secondKeys.length) return false;
+	for (const key of firstKeys) {
+		const firstValue = first[key];
+		const secondValue = second[key];
+		if (Array.isArray(firstValue)) {
+			if (!Array.isArray(secondValue) || firstValue.length !== secondValue.length || firstValue.some((value, index) => value !== secondValue[index])) return false;
+		} else if (firstValue !== secondValue) return false;
+	}
+	return true;
+}
+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) {
+	return !!value && typeof value === "object" && hasProperty(value, "waitUntil") && typeof value.waitUntil === "function";
+}
+function requestWithoutRscCacheBustingSearchParam(request) {
+	const url = new URL(request.url);
+	if (!hasRscCacheBustingSearchParam(url)) return request;
+	stripRscCacheBustingSearchParam(url);
+	return cloneRequestWithUrl(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, url.toString());
+}
+function pathnameForResolvedUrl(resolvedUrl) {
+	return resolvedUrl.split("#", 1)[0].split("?", 1)[0];
+}
+function rematchAppWorkerResponseStageRoute(options, normalized, props) {
+	let match = null;
+	if (props.matchKind === "interception") {
+		if (normalized.interceptionContextHeader !== null) match = options.matchInterceptRoute?.(props.routePathname, normalized.interceptionContextHeader, props.interceptionId) ?? null;
+	} else if (props.matchKind === "request") match = options.matchRequestRoute?.(props.routePathname) ?? null;
+	else match = options.matchRoute(props.routePathname);
+	if (!match) return null;
+	if (match.route.pattern !== props.routePattern || !haveSamePageParams(match.params, props.params)) return null;
+	return match;
+}
+async function renderAppWorkerResponseStage(options, rawRequest, ctx, props, _stageOptions) {
+	if (props.protocolVersion !== 10 || props.buildId !== options.buildId) return new Response("Incompatible vinext App response stage", { status: 409 });
+	if (props.kind === "app-full-request") return new Response("Invalid vinext App response stage", { status: 400 });
+	options.registerCacheAdapters();
+	await options.ensureInstrumentation?.();
+	const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
+	const filteredHeaders = executionContext?.isInternalPagesRevalidation ? new Headers(rawRequest.headers) : filterInternalHeaders(rawRequest.headers);
+	filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
+	const request = cloneRequestWithHeaders(rawRequest, filteredHeaders);
+	if (props.kind === "hybrid-pages") try {
+		if (new URL(props.requestUrl).origin !== new URL(request.url).origin) return new Response("Invalid vinext App response stage", { status: 400 });
+	} catch {
+		return new Response("Invalid vinext App response stage", { status: 400 });
+	}
+	const liveNormalized = normalizeRscRequest(request, options.basePath, true);
+	if (liveNormalized instanceof Response) return new Response("Invalid vinext App response stage", { status: 400 });
+	const normalized = props.kind === "hybrid-pages" ? liveNormalized : {
+		...liveNormalized,
+		interceptionContextHeader: props.kind === "app-page" || props.kind === "app-route-handler" ? props.interceptionContext : liveNormalized.interceptionContextHeader,
+		interceptionIdHeader: props.kind === "app-page" || props.kind === "app-route-handler" ? props.interceptionId : liveNormalized.interceptionIdHeader,
+		isRscRequest: props.isRscRequest,
+		mountedSlotsHeader: props.mountedSlotsHeader,
+		renderMode: props.renderMode
+	};
+	const match = props.kind === "hybrid-pages" || props.kind === "app-metadata" || props.kind === "app-not-found" ? null : rematchAppWorkerResponseStageRoute(options, normalized, props);
+	if (props.kind !== "hybrid-pages" && props.kind !== "app-metadata" && props.kind !== "app-not-found" && !match) return new Response("Invalid vinext App response stage", { status: 400 });
+	const route = match?.route ?? null;
+	if (route) {
+		if (options.ensureRouteLoaded) await traceFindPageComponents(route.pattern, () => options.ensureRouteLoaded(route));
+		if (props.kind === "app-page" && route.routeHandler || props.kind === "app-route-handler" && !route.routeHandler) return new Response("Invalid vinext App response stage", { status: 400 });
+	}
+	const headersContext = headersContextFromRequest(request, { draftModeSecret: options.draftModeSecret });
+	const requestContext = createRequestContext({
+		headersContext,
+		executionContext,
+		unstableCacheRevalidation: "background"
+	});
+	const middlewareContext = {
+		headers: null,
+		requestHeaders: null,
+		status: null
+	};
+	const responsePromise = runWithRequestContext(requestContext, () => runWithPrerenderWorkUnit(async () => {
+		if (props.middlewareCookieOverlay !== null) applyEffectiveRequestCookieHeader(props.middlewareCookieOverlay);
+		if (props.draftModeCookie !== null) restoreDraftModeTransition(props.draftModeCookie);
+		ensureFetchPatch();
+		if (props.kind === "app-metadata") {
+			if (!options.handleMetadataRouteRequest) return new Response("Invalid vinext App response stage", { status: 400 });
+			let response = await options.handleMetadataRouteRequest(props.cleanPathname, props.routePathname) ?? new Response(null, {
+				status: 204,
+				headers: { ["x-vinext-app-metadata-stage-no-match"]: "1" }
+			});
+			const draftCookie = getDraftModeCookieHeader();
+			if (draftCookie) {
+				const headers = new Headers(response.headers);
+				headers.append("Set-Cookie", draftCookie);
+				response = preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+					headers,
+					status: response.status,
+					statusText: response.statusText
+				}));
+			}
+			return response;
+		}
+		if (props.kind === "app-not-found") {
+			options.setNavigationContext({
+				pathname: props.canonicalPathname,
+				searchParams: new URL(props.resolvedUrl, request.url).searchParams,
+				params: {}
+			});
+			setRootParams({});
+			return await traceAppPageRender("/404", "render", () => options.renderNotFound({
+				isRscRequest: normalized.isRscRequest,
+				middlewareContext,
+				request,
+				route: null,
+				scriptNonce: props.scriptNonce ?? void 0
+			})) ?? new Response("Not Found", { status: 404 });
+		}
+		if (props.kind === "hybrid-pages") {
+			if (!options.renderPagesFallback) return new Response("Invalid vinext App response stage", { status: 400 });
+			const resolvedPathname = pathnameForResolvedUrl(props.resolvedUrl);
+			if ((resolvedPathname === "/api" || resolvedPathname.startsWith("/api/") ? "api" : "page") !== props.resourceKind) return new Response("Invalid vinext App response stage", { status: 400 });
+			const pageRequest = props.isDataRequest ? cloneRequestWithUrl(request, new URL(props.resolvedUrl, request.url).toString()) : request;
+			const preHandlerHeaders = props.preHandlerHeaders === null ? void 0 : new Headers(props.preHandlerHeaders);
+			preHandlerHeaders?.delete("Content-Length");
+			let pagesResponse = await options.renderPagesFallback({
+				allowRscDocumentFallback: props.allowRscDocumentFallback,
+				appRouteMatch: props.appRouteMatch ? { route: {
+					isDynamic: props.appRouteMatch.isDynamic,
+					pattern: props.appRouteMatch.pattern
+				} } : null,
+				isDataRequest: props.isDataRequest,
+				isRscRequest: props.isRscRequest,
+				matchKind: props.matchKind,
+				middlewareContext,
+				initialResponseHeaders: preHandlerHeaders,
+				pathname: props.resolvedUrl,
+				pagesDataRequest: props.isDataRequest ? request : null,
+				request: pageRequest,
+				url: new URL(props.requestUrl)
+			});
+			if (!pagesResponse) return new Response("Invalid vinext App response stage", { status: 404 });
+			if (preHandlerHeaders) pagesResponse = stripInheritedResponseStageCookies(pagesResponse, preHandlerHeaders);
+			return pagesResponse;
+		}
+		if (!route) return new Response("Invalid vinext App response stage", { status: 400 });
+		const searchParams = new URL(props.resolvedUrl, request.url).searchParams;
+		const renderParams = props.params;
+		options.setNavigationContext({
+			pathname: props.canonicalPathname,
+			searchParams,
+			params: renderParams
+		});
+		const rootParams = pickRootParams(renderParams, route.rootParamNames);
+		setRootParams(rootParams);
+		if (props.kind === "app-route-handler") {
+			setCurrentFetchSoftTags(buildPageCacheTags(props.cleanPathname, [], [...route.routeSegments], "route"));
+			const normalizedUserlandRequest = requestWithoutRscSuffix(request);
+			const userlandRequest = requestWithoutRscCacheBustingSearchParam(normalizedUserlandRequest);
+			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 = searchParams.toString();
+			for (const internalRscValue of internalRscValues) routeHandlerUrl.searchParams.append(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, internalRscValue);
+			return options.dispatchMatchedRouteHandler({
+				bypassInterceptionContextCache: props.bypassInterceptionContextCache,
+				cachePathname: props.cachePathname,
+				cleanPathname: props.cleanPathname,
+				middlewareContext,
+				params: route.isDynamic ? renderParams : null,
+				request: cloneRequestWithUrl(routeHandlerRequest, routeHandlerUrl.toString()),
+				route,
+				searchParams
+			});
+		}
+		let pprFallbackCacheShells = [];
+		if (options.createPprFallbackShells && request.method === "GET" && !normalized.isRscRequest && route.params) pprFallbackCacheShells = options.createPprFallbackShells({
+			params: route.params,
+			pattern: route.pattern,
+			rootParamNames: route.rootParamNames
+		}, renderParams);
+		return options.dispatchMatchedPage({
+			bypassInterceptionContextCache: props.bypassInterceptionContextCache,
+			cachePathname: props.cachePathname,
+			clientReuseManifest: normalized.clientReuseManifest,
+			cleanPathname: props.cleanPathname,
+			displayPathname: props.canonicalPathname,
+			formState: null,
+			handlerStart: process.env.NODE_ENV !== "production" ? performance.now() : 0,
+			interceptionContext: normalized.interceptionContextHeader,
+			interceptionId: normalized.interceptionIdHeader,
+			interceptionPathname: props.matchKind === "resolved" ? props.cleanPathname : normalized.requestCleanPathname,
+			isProgressiveActionRender: false,
+			isRscRequest: normalized.isRscRequest,
+			middlewareContext,
+			mountedSlotsHeader: normalized.mountedSlotsHeader,
+			params: renderParams,
+			pprFallbackCacheShells,
+			renderedConcreteUrlPaths: getRenderedConcreteUrlPathsForRoute(route.pattern),
+			rootParams,
+			request,
+			renderedPathAndSearch: props.resolvedUrl,
+			route,
+			searchParams,
+			scriptNonce: props.scriptNonce ?? void 0,
+			renderMode: normalized.renderMode
+		});
+	}, {
+		cacheComponents: options.createPprFallbackShells !== void 0,
+		route: () => props.canonicalPathname
+	}));
+	let response;
+	try {
+		response = await responsePromise;
+	} catch (error) {
+		await closeAfterResponse(requestContext);
+		throw error;
+	}
+	return closeAfterResponseWithBody(response, requestContext);
+}
+//#endregion
+export { renderAppWorkerResponseStage };

package/dist/server/app-rsc-route-matching.d.ts

@@ -5,7 +5,7 @@ import { RoutePatternParams } from "../routing/route-pattern.js";
  * When a matched intercept carries this key, the render layer replaces the
  * route's main page element instead of a parallel slot.
  */
-declare const SIBLING_PAGE_INTERCEPT_SLOT_KEY = "__vinext_page_intercept";
+export declare const SIBLING_PAGE_INTERCEPT_SLOT_KEY = "__vinext_page_intercept";
 type AppRscRouteParams = RoutePatternParams;
 type AppRscInterceptForMatching = {
   targetPattern: string;
@@ -120,7 +120,7 @@ type AppRscInterceptLookupEntry = {
   slotId: string | null;
   targetRouteGraphId: string | null;
 };
-declare function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(routes: Route[]): {
+export declare function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(routes: Route[]): {
   hasInterceptionId(interceptionId: string): boolean;
   matchRoute(url: string): {
     route: Route;
@@ -132,5 +132,4 @@ declare function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(
   } | null;
   findIntercept(pathname: string, sourcePathname?: string | null, interceptionId?: string | null): AppRscInterceptMatch | null;
 };
-//#endregion
-export { SIBLING_PAGE_INTERCEPT_SLOT_KEY, createAppRscRouteMatcher };
+//#endregion

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

@@ -1,6 +1,6 @@
 import { decodeMatchedParams, splitPathSegments, splitPathnameForRouteMatch } from "../routing/utils.js";
-import { buildRouteTrie, trieMatchRaw } from "../routing/route-trie.js";
 import { createAppRouteGraphInterceptionId } from "../routing/app-route-graph.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";
 //#region src/server/app-rsc-route-matching.ts
@@ -20,7 +20,8 @@ function appRscPathnameParts(pathname, isNormalized = false) {
 }
 function appRscInterceptionSourcePathnameParts(pathname) {
 	const pathOnly = pathname.split("?")[0];
-	return splitPathSegments(pathOnly === "/" ? "/" : pathOnly.replace(/\/$/, "")).map((segment) => {
+	const normalizedPathname = pathOnly === "/" ? "/" : pathOnly.replace(/\/$/, "");
+	return splitPathSegments(normalizedPathname).map((segment) => {
 		try {
 			return decodeURIComponent(segment);
 		} catch {

package/dist/server/app-rsc-state-fingerprint.d.ts

@@ -1,5 +1,5 @@
 //#region src/server/app-rsc-state-fingerprint.d.ts
-type AppRscStateFingerprintInput = {
+export type AppRscStateFingerprintInput = {
   pathAndSearch: string;
   routeId: string;
 };
@@ -9,6 +9,5 @@ type AppRscStateFingerprintInput = {
  * does not emit Next.js' Flight router-tree wire format, so reusing that header
  * would give it incorrect routing semantics.
  */
-declare function createAppRscStateFingerprint(input: AppRscStateFingerprintInput): string;
-//#endregion
-export { AppRscStateFingerprintInput, createAppRscStateFingerprint };
+export declare function createAppRscStateFingerprint(input: AppRscStateFingerprintInput): string;
+//#endregion

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

@@ -0,0 +1,16 @@
+//#region src/server/app-rsc-vary.d.ts
+/** Request selectors that define a reusable full-route RSC response variant. */
+export declare const RSC_HEADER = "RSC";
+export declare const NEXT_ROUTER_STATE_TREE_HEADER = "Next-Router-State-Tree";
+export declare const NEXT_ROUTER_PREFETCH_HEADER = "Next-Router-Prefetch";
+export declare const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = "Next-Router-Segment-Prefetch";
+export declare const NEXT_URL_HEADER = "Next-Url";
+export declare const VINEXT_INTERCEPTION_CONTEXT_HEADER = "X-Vinext-Interception-Context";
+export declare const VINEXT_INTERCEPTION_ID_HEADER = "X-Vinext-Interception-Id";
+export declare const VINEXT_MOUNTED_SLOTS_HEADER = "X-Vinext-Mounted-Slots";
+export declare const VINEXT_RSC_RENDER_MODE_HEADER = "X-Vinext-Rsc-Render-Mode";
+export declare const VINEXT_RSC_STATE_FINGERPRINT_HEADER = "X-Vinext-Rsc-State-Fingerprint";
+export declare const VINEXT_RSC_VARY_HEADER: string;
+/** Whether a normalized response `Vary` field is a framework RSC selector. */
+export declare function isVinextRscVaryField(name: string): boolean;
+//#endregion

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

@@ -0,0 +1,31 @@
+//#region src/server/app-rsc-vary.ts
+/** Request selectors that define a reusable full-route RSC response variant. */
+const RSC_HEADER = "RSC";
+const NEXT_ROUTER_STATE_TREE_HEADER = "Next-Router-State-Tree";
+const NEXT_ROUTER_PREFETCH_HEADER = "Next-Router-Prefetch";
+const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = "Next-Router-Segment-Prefetch";
+const NEXT_URL_HEADER = "Next-Url";
+const VINEXT_INTERCEPTION_CONTEXT_HEADER = "X-Vinext-Interception-Context";
+const VINEXT_INTERCEPTION_ID_HEADER = "X-Vinext-Interception-Id";
+const VINEXT_MOUNTED_SLOTS_HEADER = "X-Vinext-Mounted-Slots";
+const VINEXT_RSC_RENDER_MODE_HEADER = "X-Vinext-Rsc-Render-Mode";
+const VINEXT_RSC_STATE_FINGERPRINT_HEADER = "X-Vinext-Rsc-State-Fingerprint";
+const VINEXT_RSC_VARY_HEADER = [
+	"RSC",
+	NEXT_ROUTER_STATE_TREE_HEADER,
+	NEXT_ROUTER_PREFETCH_HEADER,
+	NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
+	NEXT_URL_HEADER,
+	VINEXT_INTERCEPTION_CONTEXT_HEADER,
+	VINEXT_INTERCEPTION_ID_HEADER,
+	VINEXT_MOUNTED_SLOTS_HEADER,
+	VINEXT_RSC_RENDER_MODE_HEADER,
+	VINEXT_RSC_STATE_FINGERPRINT_HEADER
+].join(", ");
+const VINEXT_RSC_VARY_FIELDS = new Set(VINEXT_RSC_VARY_HEADER.split(",").map((name) => name.trim().toLowerCase()));
+/** Whether a normalized response `Vary` field is a framework RSC selector. */
+function isVinextRscVaryField(name) {
+	return VINEXT_RSC_VARY_FIELDS.has(name.trim().toLowerCase());
+}
+//#endregion
+export { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER, isVinextRscVaryField };