vinext 1.2.1 → 1.3.1

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

@@ -1,6 +1,6 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
@@ -78,6 +78,7 @@ async function renderAppPageHtmlStream(options) {
 		sideStream: options.sideStream,
 		capturedRscDataRef: options.capturedRscDataRef,
 		pprFallbackShellSignal: options.pprFallbackShellSignal,
+		preloadRoutePattern: options.preloadRoutePattern,
 		waitForAllReady: options.waitForAllReady,
 		isStaticGeneration: options.isStaticGeneration,
 		isForceStatic: options.isForceStatic,
@@ -86,6 +87,7 @@ async function renderAppPageHtmlStream(options) {
 		onSsrError: options.onSsrError,
 		mirrorNextFlight: options.mirrorNextFlight,
 		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError ?? (options.waitForAllReady !== true && options.hasCustomGlobalError === false),
+		resolveCaughtNotFoundBoundaries: options.resolveCaughtNotFoundBoundaries,
 		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 		getInitialNavigationCacheMetadata: options.getInitialNavigationCacheMetadata
 	};
@@ -93,6 +95,12 @@ async function renderAppPageHtmlStream(options) {
 }
 async function renderAppPageHtmlResponse(options) {
 	const { htmlStream, linkHeader: reactLinkHeader } = await renderAppPageHtmlStream(options);
+	return buildAppPageHtmlDocumentResponse(htmlStream, {
+		...options,
+		reactLinkHeader
+	});
+}
+function buildAppPageHtmlDocumentResponse(htmlStream, options) {
 	const safeStream = deferUntilStreamConsumed(htmlStream, () => {
 		options.clearRequestContext();
 	});
@@ -102,7 +110,7 @@ async function renderAppPageHtmlResponse(options) {
 	});
 	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders ?? null);
-	const frameworkLinkHeader = buildAppPageLinkHeader(reactLinkHeader, options.fontLinkHeader, options.reactMaxHeadersLength);
+	const frameworkLinkHeader = buildAppPageLinkHeader(options.reactLinkHeader, options.fontLinkHeader, options.reactMaxHeadersLength);
 	if (frameworkLinkHeader) headers.append("Link", frameworkLinkHeader);
 	const response = new Response(safeStream, {
 		status: options.status,
@@ -113,8 +121,20 @@ async function renderAppPageHtmlResponse(options) {
 }
 async function renderAppPageHtmlStreamWithRecovery(options) {
 	try {
-		const { htmlStream, metadataReady, renderComplete, capturedRscData, linkHeader, shellErrorRecovered } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
+		const { htmlStream, metadataReady, renderComplete, capturedRscData, linkHeader, shellErrorRecovered, caughtShellError } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
 		options.onShellRendered?.();
+		const caughtSpecialError = caughtShellError === void 0 ? null : options.resolveSpecialError(caughtShellError);
+		if (caughtSpecialError) return {
+			htmlStream: null,
+			response: await options.renderSpecialErrorResponse(caughtSpecialError, {
+				htmlStream,
+				linkHeader
+			}),
+			metadataReady: resolvedMetadataReady,
+			renderComplete: renderComplete ?? resolvedMetadataReady,
+			capturedRscData: null,
+			shellErrorRecovered: false
+		};
 		return {
 			htmlStream,
 			response: null,
@@ -184,4 +204,4 @@ function createAppPageRscErrorTracker(baseOnError) {
 	};
 }
 //#endregion
-export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };
+export { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

package/dist/server/app-pages-bridge.d.ts

@@ -1,4 +1,5 @@
 import { AppMiddlewareContext } from "./app-middleware.js";
+import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 import { EdgeApiExecutionRuntime } from "./edge-api-runtime.js";
 //#region src/server/app-pages-bridge.d.ts
 export type PagesEntry = {
@@ -24,7 +25,7 @@ type AppRouteMatch = {
 type RenderPagesFallbackDependencies = {
   loadPagesEntry: () => Promise<PagesEntry> | PagesEntry;
   buildRequestHeaders: (requestHeaders: Headers, middlewareRequestHeaders: Headers) => Headers | null;
-  applyRouteHandlerMiddlewareContext: (response: Response, middlewareContext: AppMiddlewareContext) => Response;
+  applyRouteHandlerMiddlewareContext: (response: Response, middlewareContext: AppMiddlewareContext, options?: MiddlewareResponseMergeOptions) => Response;
   /**
    * Returns the `__prerender_bypass` Set-Cookie header emitted by a
    * `draftMode().enable()`/`disable()` call inside middleware, if any. Reading
@@ -60,4 +61,5 @@ type RenderPagesFallbackOptions = {
  * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
  */
 export declare function renderPagesFallback(options: RenderPagesFallbackOptions, dependencies: RenderPagesFallbackDependencies): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-pages-bridge.js

@@ -23,15 +23,18 @@ async function renderPagesFallback(options, dependencies) {
 	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
 	const pagesRequestHeaders = middlewareContext.requestHeaders ? buildRequestHeaders(request.headers, middlewareContext.requestHeaders) : null;
-	let pagesRequest = request;
-	if (pagesRequestHeaders) pagesRequest = cloneRequestWithHeaders(request, pagesRequestHeaders);
+	const matchRequest = pagesRequestHeaders ? new Request(request.url, {
+		headers: pagesRequestHeaders,
+		method: request.method
+	}) : request;
+	const claimPagesRequest = () => pagesRequestHeaders ? cloneRequestWithHeaders(request, pagesRequestHeaders) : request;
 	const queryIndex = pathname.indexOf("?");
 	const pagesPathname = queryIndex === -1 ? pathname : pathname.slice(0, queryIndex);
 	const pagesUrl = pagesPathname + (queryIndex === -1 ? url.search || "" : pathname.slice(queryIndex));
 	if (pagesPathname.startsWith("/api/") || pagesPathname === "/api") {
 		if (typeof pagesEntry.handleApiRoute !== "function") return null;
 		const hasApiMatcher = typeof pagesEntry.matchApiRoute === "function";
-		const apiMatch = hasApiMatcher ? pagesEntry.matchApiRoute?.(pagesUrl, pagesRequest) ?? null : null;
+		const apiMatch = hasApiMatcher ? pagesEntry.matchApiRoute?.(pagesUrl, matchRequest) ?? null : null;
 		if (hasApiMatcher && apiMatch === null) return null;
 		if (apiMatch !== null && matchKind === "static" && apiMatch.route.isDynamic) return null;
 		if (apiMatch !== null && matchKind === "dynamic" && !apiMatch.route.isDynamic) return null;
@@ -41,24 +44,25 @@ async function renderPagesFallback(options, dependencies) {
 		if (apiMatch !== null) beginRouteCacheability("pages-api", apiMatch.route.pattern);
 		const executionContext = getRequestExecutionContext();
 		const apiArgs = [
-			pagesRequest,
+			claimPagesRequest(),
 			pagesUrl,
 			executionContext ?? void 0,
-			executionContext?.trustedRevalidateOrigin ?? new URL(pagesRequest.url).origin,
+			executionContext?.trustedRevalidateOrigin,
 			executionContext?.hostRuntime ?? "node"
 		];
 		const pagesApiResponse = await (initialResponseHeaders ? pagesEntry.handleApiRoute(...apiArgs, initialResponseHeaders) : pagesEntry.handleApiRoute(...apiArgs));
 		const draftCookie = getDraftModeCookieHeader();
-		return applyDraftModeCookie(applyRouteHandlerMiddlewareContext(pagesApiResponse, middlewareContext), draftCookie);
+		return applyDraftModeCookie(applyRouteHandlerMiddlewareContext(pagesApiResponse, middlewareContext, { appendResponseChallenges: false }), draftCookie);
 	}
 	if (typeof pagesEntry.renderPage !== "function") return null;
 	const hasPageMatcher = typeof pagesEntry.matchPageRoute === "function";
-	const pageMatch = hasPageMatcher ? pagesEntry.matchPageRoute?.(pagesUrl, pagesRequest) ?? null : null;
+	const pageMatch = hasPageMatcher ? pagesEntry.matchPageRoute?.(pagesUrl, matchRequest) ?? null : null;
 	if (hasPageMatcher && pageMatch === null) return null;
 	if (pageMatch !== null && matchKind === "static" && pageMatch.route.isDynamic) return null;
 	if (pageMatch !== null && matchKind === "dynamic" && !pageMatch.route.isDynamic) return null;
 	if (appRouteMatch !== null && (pageMatch === null || !pagesRouteHasPriorityOverAppRoute(pageMatch.route, appRouteMatch.route))) return null;
 	if (pageMatch !== null) beginRouteCacheability("pages-page", pageMatch.route.pattern);
+	const pagesRequest = claimPagesRequest();
 	const renderArgs = [
 		pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest,
 		pagesUrl,

package/dist/server/app-ppr-fallback-shell-render.d.ts

@@ -13,4 +13,5 @@ export type WarmPprFallbackShellCachesOptions = {
   state: PprFallbackShellState;
 };
 export declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-ppr-fallback-shell.d.ts

@@ -29,4 +29,5 @@ export declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
   pathname: string;
   searchParams: URLSearchParams;
 }): string;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-prerender-endpoints.d.ts

@@ -15,4 +15,5 @@ type HandleAppPrerenderEndpointOptions = {
   staticParamsMap: AppPrerenderStaticParamsMap;
 };
 export declare function handleAppPrerenderEndpoint(request: Request, options: HandleAppPrerenderEndpointOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-prerender-static-params.d.ts

@@ -34,4 +34,5 @@ type CallAppPrerenderStaticParamsOptions = {
   rootParamNamesByPattern: Record<string, readonly string[] | undefined>;
 };
 export declare function callAppPrerenderStaticParams(options: CallAppPrerenderStaticParamsOptions): Promise<unknown>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-prerender-static-params.js

@@ -1,4 +1,5 @@
 import { isUnknownRecord } from "../utils/record.js";
+import { shareIsolatePromise } from "./isolate-shared-promise.js";
 import { pickRootParams, runWithRootParamsScope } from "../shims/root-params.js";
 //#region src/server/app-prerender-static-params.ts
 /**
@@ -42,7 +43,7 @@ function createAppPrerenderStaticParamsResolver(sources, rootParamNames) {
 	let resolvePromise = null;
 	const resolveFns = () => {
 		if (resolvedFns) return Promise.resolve(resolvedFns);
-		if (!resolvePromise) resolvePromise = (async () => {
+		if (!resolvePromise) resolvePromise = shareIsolatePromise((async () => {
 			resolvedFns = (await Promise.all(usableSources.map(async (source) => {
 				if (isGenerateStaticParamsFunction(source)) return source;
 				const mod = await source.load();
@@ -50,7 +51,7 @@ function createAppPrerenderStaticParamsResolver(sources, rootParamNames) {
 				return isGenerateStaticParamsFunction(fn) ? fn : null;
 			}))).filter((fn) => fn !== null);
 			return resolvedFns;
-		})();
+		})());
 		return resolvePromise;
 	};
 	return async (input) => {

package/dist/server/app-render-dependency.d.ts

@@ -11,7 +11,17 @@ export type AppPageRenderDependency = AppRenderDependency & {
 /** Whether `component` is a "use client" export seen from the RSC environment. */
 export declare function isAppClientReference(component: unknown): boolean;
 export declare function isReactOwnedAppComponent(component: unknown): boolean;
-export declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>): ReactNode | Promise<ReactNode>;
+/**
+ * `mapError` replaces an error thrown by a CSS-wrapped export's inner
+ * component, which renders after this call returns. The caller maps the
+ * errors this call throws or rejects with.
+ */
+export declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, mapError?: (error: unknown) => unknown): ReactNode | Promise<ReactNode>;
+/**
+ * `invokeAppComponent()`, with every error the component throws or rejects
+ * with replaced by `mapError(error)`, including its CSS-wrapped inner one's.
+ */
+export declare function invokeAppComponentMappingErrors(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, mapError: (error: unknown) => unknown): ReactNode | Promise<ReactNode>;
 export declare function registerAppElementRenderDependencies(elements: Readonly<Record<string, unknown>>, dependenciesByElementId: ReadonlyMap<string, AppRenderDependency>): void;
 export declare function releaseAppElementRenderDependency(elements: Readonly<Record<string, unknown>>, elementId: string): void;
 export declare function createAppRenderDependency(): AppRenderDependency;

package/dist/server/app-render-dependency.js

@@ -1,5 +1,5 @@
 import { isPromiseLike } from "../utils/promise.js";
-import { createElement, use } from "react";
+import { Fragment, createElement, isValidElement, use } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/server/app-render-dependency.tsx
 const REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
@@ -15,13 +15,72 @@ function isReactOwnedAppComponent(component) {
 	if (candidate?.$$typeof === REACT_MEMO || candidate?.$$typeof === REACT_LAZY || candidate?.$$typeof === REACT_FORWARD_REF) return false;
 	return typeof candidate !== "function" || candidate.$$typeof === REACT_CLIENT_REFERENCE || candidate.prototype?.isReactComponent != null;
 }
-function invokeAppComponent(component, props) {
+/**
+* `mapError` replaces an error thrown by a CSS-wrapped export's inner
+* component, which renders after this call returns. The caller maps the
+* errors this call throws or rejects with.
+*/
+function invokeAppComponent(component, props, mapError) {
 	const candidate = component;
-	if (candidate.$$typeof === REACT_MEMO && candidate.type) return invokeAppComponent(candidate.type, props);
-	if (candidate.$$typeof === REACT_LAZY && candidate._init) return invokeAppComponent(candidate._init(candidate._payload), props);
+	if (candidate.$$typeof === REACT_MEMO && candidate.type) return invokeAppComponent(candidate.type, props, mapError);
+	if (candidate.$$typeof === REACT_LAZY && candidate._init) return invokeAppComponent(candidate._init(candidate._payload), props, mapError);
 	if (candidate.$$typeof === REACT_FORWARD_REF && candidate.render) return candidate.render(props, void 0);
 	if (isReactOwnedAppComponent(candidate)) return createElement(candidate, props);
-	return candidate(props);
+	const result = candidate(props);
+	return isPromiseLike(result) ? result : invokeCssWrappedComponent(result, props, mapError);
+}
+/**
+* `invokeAppComponent()`, with every error the component throws or rejects
+* with replaced by `mapError(error)`, including its CSS-wrapped inner one's.
+*/
+function invokeAppComponentMappingErrors(component, props, mapError) {
+	try {
+		const result = invokeAppComponent(component, props, mapError);
+		return isPromiseLike(result) ? Promise.resolve(result).catch((error) => {
+			throw mapError(error);
+		}) : result;
+	} catch (error) {
+		throw mapError(error);
+	}
+}
+/**
+* Whether `elementProps` are what `createElement(type, props)` produces: the
+* same values, plus any `type.defaultProps` for keys that are `undefined`.
+* Defaulted values aren't read again, since a default can be a getter.
+*/
+function isElementOfProps(elementProps, props, defaultProps) {
+	const keys = new Set(Object.keys(props));
+	const defaulted = /* @__PURE__ */ new Set();
+	for (const key in defaultProps) if (props[key] === void 0) {
+		keys.add(key);
+		defaulted.add(key);
+	}
+	return Object.keys(elementProps).length === keys.size && [...keys].every((key) => Object.hasOwn(elementProps, key) && (defaulted.has(key) || Object.is(elementProps[key], props[key])));
+}
+/**
+* `@vitejs/plugin-rsc` wraps a server component export whose module imports
+* CSS (`__vite_rsc_wrap_css__`). The wrapper returns
+* `<><Css /><Component {...props} /></>`, so a component vinext invokes
+* directly renders as an element with its props after all. React's dev build
+* serializes an element's props as debug info and calls `then` on `params`
+* and `searchParams`, which counts as reading them. Invoke the inner
+* component from an element without props instead, as for an export without
+* CSS.
+*/
+function invokeCssWrappedComponent(result, props, mapError) {
+	if (!isValidElement(result) || result.type !== Fragment || result.key !== null) return result;
+	const children = result.props.children;
+	if (!Array.isArray(children) || children.length !== 2) return result;
+	const [css, inner] = children;
+	if (!isValidElement(inner) || typeof inner.type !== "function" || inner.key !== null) return result;
+	const component = inner.type;
+	if (!isElementOfProps(inner.props, props, component.defaultProps)) return result;
+	const componentProps = inner.props;
+	function CssWrappedComponent() {
+		return mapError ? invokeAppComponentMappingErrors(component, componentProps, mapError) : invokeAppComponent(component, componentProps);
+	}
+	CssWrappedComponent.displayName = component.displayName ?? component.name;
+	return createElement(Fragment, null, css, createElement(CssWrappedComponent));
 }
 const appElementRenderDependencies = /* @__PURE__ */ new WeakMap();
 function registerAppElementRenderDependencies(elements, dependenciesByElementId) {
@@ -92,4 +151,4 @@ function renderAppComponentWithDependencyBarrier(component, props, dependency) {
 	return createElement(AppComponentDependencyBarrier);
 }
 //#endregion
-export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };
+export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, invokeAppComponentMappingErrors, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };

package/dist/server/app-request-stage-independent-entry.d.ts

@@ -5,4 +5,5 @@ import { DispatchAppWorkerResponseStage } from "./app-worker-stages.js";
 export type AppRequestStageEnv = Record<string, unknown>;
 type AppRequestStageContext = ExecutionContextLike & VinextRequestStageContext;
 export declare function handleRequestStage(request: Request, env: AppRequestStageEnv | undefined, ctx: AppRequestStageContext | undefined, dispatchResponseStage: DispatchAppWorkerResponseStage): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-request-stage-independent-entry.js

@@ -26,7 +26,7 @@ const rejectResponseStage = () => Promise.resolve(new Response(null, { status: 4
 function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 	const originalRequest = request;
 	const handleStage = async () => {
-		await __ensureInstrumentation();
+		await __ensureInstrumentation(ctx);
 		const url = new URL(request.url);
 		return traceFrameworkRequest({
 			callback: () => handleRequest(request, env, ctx, dispatchResponseStage, ctx?.assets).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest)),
@@ -56,7 +56,7 @@ async function handleRequest(request, env, platformCtx, dispatchResponseStage, a
 		if (validationResponse) return validationResponse;
 		didValidateCdnRequest = true;
 		if (readinessResponse.status !== 204) return readinessResponse;
-		await __ensureHybridPagesApplication();
+		await __ensureHybridPagesApplication(ctx);
 	}
 	let probeMode = null;
 	let probeRoute = null;

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

@@ -6,4 +6,5 @@ type AppResponseStageEnv = Record<string, unknown>;
 /** Invoke one transformed public cache function without rendering its owning route. */
 export declare function invokeCacheFunction(invocation: VinextCacheFunctionInvocation, env: AppResponseStageEnv | undefined, platformCtx: ExecutionContextLike | undefined, dispatchRequestStage: VinextRequestStageTransport): Promise<void>;
 export declare function handleResponseStage(request: Request, env: AppResponseStageEnv | undefined, platformCtx: ExecutionContextLike | undefined, props: AppWorkerResponseStageProps, dispatchRequestStage: VinextRequestStageTransport, options?: VinextResponseStageDispatchOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

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

@@ -19,7 +19,7 @@ import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 /** Cacheable App response stage. This is the only multi-stage App entry that imports user routes. */
 /** Invoke one transformed public cache function without rendering its owning route. */
 async function invokeCacheFunction(invocation, env, platformCtx, dispatchRequestStage) {
-	await __ensureInstrumentation();
+	await __ensureInstrumentation(platformCtx);
 	const [{ loadServerAction }, { invokeCacheFunction: invokeRegisteredCacheFunction }] = await Promise.all([import("@vitejs/plugin-rsc/core/rsc"), import("../shims/cache-callable-runtime.js")]);
 	registerConfiguredCacheAdapters(env);
 	ensureFetchPatch();
@@ -37,8 +37,8 @@ async function handleResponseStage(request, env, platformCtx, props, dispatchReq
 	if (props.requestOrigin !== new URL(request.url).origin) return new Response("Invalid vinext App response stage", { status: 400 });
 	const currentBuildId = process.env.__VINEXT_BUILD_ID ?? null;
 	if (props.buildId !== currentBuildId) return new Response("Incompatible vinext App response stage", { status: 409 });
-	await __ensureInstrumentation();
-	if (props.kind === "app-full-request" && props.prerenderDiscovery) await __ensureHybridPagesApplication();
+	await __ensureInstrumentation(platformCtx);
+	if (props.kind === "app-full-request" && props.prerenderDiscovery) await __ensureHybridPagesApplication(platformCtx);
 	registerConfiguredImageOptimizer(env);
 	let ctx = createWorkerRevalidationContext(platformCtx, (internalRequest) => dispatchRequestStage(internalRequest), "node");
 	if (props.kind === "app-full-request" && props.prerenderDiscovery) ctx = {

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

@@ -45,4 +45,5 @@ type ReadAppRouteHandlerCacheOptions = {
   } | null) => void;
 };
 export declare function readAppRouteHandlerCacheResponse(options: ReadAppRouteHandlerCacheOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

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

@@ -46,4 +46,5 @@ type DispatchAppRouteHandlerOptions = {
   searchParams: URLSearchParams;
 };
 export declare function dispatchAppRouteHandler(options: DispatchAppRouteHandlerOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

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

@@ -1,4 +1,4 @@
-import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { closeAfterResponse, createRequestContext, getRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import "../utils/protocol-headers.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
@@ -14,9 +14,9 @@ import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { traceResponseStart } from "./response-start-tracing.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import { applyRouteHandlerMiddlewareContext, finalizeRouteHandlerResponse } from "./app-route-handler-response.js";
 import "../shims/navigation.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
@@ -40,6 +40,7 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 	const requestContext = createRequestContext({
 		headersContext,
 		executionContext: getRequestExecutionContext(),
+		phase: "route-handler",
 		unstableCacheRevalidation: "foreground"
 	});
 	const revalidation = runWithRequestContext(requestContext, () => runInWorkStoreScope(async () => {
@@ -203,6 +204,7 @@ async function dispatchAppRouteHandlerImpl(options) {
 				return reportRequestError(error, request, context);
 			},
 			request: options.request,
+			requestSignal: getRequestContext().requestSignal ?? void 0,
 			expireSeconds: options.expireSeconds,
 			revalidateSeconds,
 			revalidateReason,

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

@@ -56,6 +56,8 @@ type RunAppRouteHandlerOptions = {
    */
   params: AppRouteParams | null;
   request: Request;
+  /** Host signal for the client connection; only the foreground request has one. */
+  requestSignal?: AbortSignal;
   routePattern?: string;
   setHeadersAccessPhase?: (phase: HeadersAccessPhase) => HeadersAccessPhase;
 };
@@ -102,4 +104,5 @@ type ExecuteAppRouteHandlerOptions = {
 export declare function runAppRouteHandler(options: RunAppRouteHandlerOptions): Promise<RunAppRouteHandlerResult>;
 export declare function executeAppRouteHandler(options: ExecuteAppRouteHandlerOptions): Promise<Response>;
 export declare function traceAppRouteHandlerExecution<T>(routePattern: string, callback: (span: FrameworkSpan) => T): T;
-//#endregion
+//#endregion
+export {};

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

@@ -118,6 +118,7 @@ async function runAppRouteHandler(options) {
 			options.markDynamicUsage();
 		},
 		requestMode: options.dynamicConfig === "force-static" || options.dynamicConfig === "error" ? options.dynamicConfig : "auto",
+		signal: options.requestSignal,
 		staticGenerationErrorMessage(expression) {
 			return getAppRouteStaticGenerationErrorMessage(options.routePattern, expression);
 		}
@@ -210,10 +211,16 @@ async function executeAppRouteHandlerImpl(options) {
 			revalidateSeconds: options.revalidateSeconds,
 			requiresCompletedResponseAdmission: isRouteCacheabilityEvaluation()
 		})) {
-			const completed = await completeAppRouteHandlerResponse(response);
+			const completed = await completeAppRouteHandlerResponse(response).catch(async (error) => {
+				await _drainPendingRevalidations().catch(() => {});
+				throw error;
+			});
 			response = completed.response;
 			cleanupDeferredToBody = !completed.completed;
-			if (completed.completed) markRouteCacheabilityResponseBodyComplete();
+			if (completed.completed) {
+				markRouteCacheabilityResponseBodyComplete();
+				await _drainPendingRevalidations();
+			}
 			const dynamicUsedDuringCompletion = options.consumeDynamicUsage();
 			dynamicUsedInHandler = handlerResult.didAccessDynamicRequest() || dynamicUsedDuringCompletion || dynamicUsedInHandler;
 		}

package/dist/server/app-route-handler-middleware-context.d.ts

@@ -1,8 +1,9 @@
+import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 //#region src/server/app-route-handler-middleware-context.d.ts
 export type RouteHandlerMiddlewareContext = {
   headers: Headers | null;
   status: number | null;
 };
 /** Apply request-stage middleware response metadata to a route-handler response. */
-export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext): Response;
+export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: MiddlewareResponseMergeOptions): Response;
 //#endregion

package/dist/server/app-route-handler-middleware-context.js

@@ -1,10 +1,10 @@
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { mergeMiddlewareResponseHeadersOntoResponse } from "./middleware-response-headers.js";
 //#region src/server/app-route-handler-middleware-context.ts
 /** Apply request-stage middleware response metadata to a route-handler response. */
-function applyRouteHandlerMiddlewareContext(response, middlewareContext) {
+function applyRouteHandlerMiddlewareContext(response, middlewareContext, options = {}) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const responseHeaders = new Headers(response.headers);
-	mergeMiddlewareResponseHeaders(responseHeaders, middlewareContext.headers);
+	mergeMiddlewareResponseHeadersOntoResponse(responseHeaders, middlewareContext.headers, options);
 	return new Response(response.body, {
 		status: middlewareContext.status ?? response.status,
 		statusText: response.statusText,

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

@@ -1,3 +1,4 @@
+import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 import { CacheControlMetadata, CachedRouteValue } from "../shims/cache-handler.js";
 //#region src/server/app-route-handler-response.d.ts
 export type RouteHandlerMiddlewareContext = {
@@ -16,7 +17,7 @@ type FinalizeRouteHandlerResponseOptions = {
   draftCookie?: string | null;
   isHead: boolean;
 };
-export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: {
+export declare function applyRouteHandlerMiddlewareContext(response: Response, middlewareContext: RouteHandlerMiddlewareContext, options?: MiddlewareResponseMergeOptions & {
   appendResponseLink?: boolean;
 }): Response;
 export declare function assertSupportedAppRouteHandlerResponse(response: Response): void;
@@ -25,4 +26,5 @@ export declare function applyRouteHandlerRevalidateHeader(response: Response, re
 export declare function markRouteHandlerCacheMiss(response: Response): void;
 export declare function buildAppRouteCacheValue(response: Response, browserCacheControl?: string): Promise<CachedRouteValue>;
 export declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
-//#endregion
+//#endregion
+export {};

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

@@ -5,7 +5,7 @@ import { markRouteCacheabilityExplicitResponsePolicy, recordRouteCacheability }
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { mergeMiddlewareResponseHeadersOntoResponse } from "./middleware-response-headers.js";
 import { markEdgeRouteHandlerLinkHeaders } from "./app-response-header-provenance.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts
@@ -22,7 +22,7 @@ function applyRouteHandlerMiddlewareContext(response, middlewareContext, options
 		return response;
 	}
 	const responseHeaders = new Headers(response.headers);
-	mergeMiddlewareResponseHeaders(responseHeaders, middlewareContext.headers);
+	mergeMiddlewareResponseHeadersOntoResponse(responseHeaders, middlewareContext.headers, options);
 	if (responseLink && middlewareContext.headers?.get("link")) responseHeaders.append("link", responseLink);
 	const result = new Response(response.body, {
 		status: middlewareContext.status ?? response.status,

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

@@ -30,6 +30,8 @@ type TrackedAppRouteRequestOptions = {
   middlewareHeaders?: Headers | null;
   onDynamicAccess?: (access: AppRouteDynamicRequestAccess) => void;
   requestMode?: AppRouteRequestMode;
+  /** Host signal for the client connection (UnifiedRequestContext.requestSignal). */
+  signal?: AbortSignal;
   staticGenerationErrorMessage?: (expression?: string) => string;
 };
 type TrackedAppRouteRequest = {
@@ -37,4 +39,5 @@ type TrackedAppRouteRequest = {
   didAccessDynamicRequest(): boolean;
 };
 export declare function createTrackedAppRouteRequest(request: Request, options?: TrackedAppRouteRequestOptions): TrackedAppRouteRequest;
-//#endregion
+//#endregion
+export {};

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

@@ -72,7 +72,20 @@ function buildNextConfig(options) {
 		skipTrailingSlashRedirect: options.skipTrailingSlashRedirect
 	};
 }
-function createForceStaticNextRequest(input, nextConfig) {
+/**
+* Undici's Request follows its input's signal through a WeakRef, and so does
+* every clone between the host signal and the handler's request. A handler
+* that only listens on `request.signal` (e.g. to stop a stream) would miss the
+* abort once GC collects any of them, so the request follows the host signal
+* directly and stays reachable for as long as that signal is.
+*/
+const requestsByHostSignal = /* @__PURE__ */ new WeakMap();
+function retainWhileSignalLives(signal, request) {
+	const requests = requestsByHostSignal.get(signal);
+	if (requests) requests.push(request);
+	else requestsByHostSignal.set(signal, [request]);
+}
+function createForceStaticNextRequest(input, nextConfig, signal) {
 	const read = (key) => {
 		const descriptor = BUILT_IN_REQUEST_PROPERTY_MAP.get(key)?.descriptor;
 		if (descriptor?.get) return descriptor.get.call(input);
@@ -89,7 +102,7 @@ function createForceStaticNextRequest(input, nextConfig) {
 		redirect: read("redirect"),
 		referrer: read("referrer"),
 		referrerPolicy: read("referrerPolicy"),
-		signal: read("signal"),
+		signal: signal ?? read("signal"),
 		nextConfig: nextConfig ?? void 0
 	});
 }
@@ -215,7 +228,11 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		const sourceCfDescriptor = Reflect.getOwnPropertyDescriptor(requestWithOverrides, "cf");
 		const sourceCfAccessor = sourceCfDescriptor?.get;
 		const sourceCfMetadata = sourceCfAccessor ? void 0 : Reflect.get(requestWithOverrides, "cf", requestWithOverrides);
-		const nextRequest = requestMode === "force-static" ? createForceStaticNextRequest(requestWithOverrides, nextConfig) : requestWithOverrides instanceof NextRequest && sourceCfDescriptor?.configurable !== false ? requestWithOverrides : new NextRequest(requestWithOverrides, { nextConfig: nextConfig ?? void 0 });
+		const nextRequest = requestMode === "force-static" ? createForceStaticNextRequest(requestWithOverrides, nextConfig, options.signal) : requestWithOverrides instanceof NextRequest && sourceCfDescriptor?.configurable !== false && !options.signal ? requestWithOverrides : new NextRequest(requestWithOverrides, {
+			nextConfig: nextConfig ?? void 0,
+			signal: options.signal
+		});
+		if (options.signal) retainWhileSignalLives(options.signal, nextRequest);
 		const rawCfMetadata = sourceCfAccessor ? void 0 : sourceCfMetadata === void 0 ? Reflect.get(nextRequest, "cf", nextRequest) : sourceCfMetadata;
 		const hasCfMetadata = sourceCfAccessor !== void 0 || rawCfMetadata !== void 0;
 		const originalCfDescriptor = sourceCfDescriptor ?? Reflect.getOwnPropertyDescriptor(nextRequest, "cf");