vinext 1.2.1 → 1.3.0

package/dist/server/app-page-boundary-render.js

@@ -1,6 +1,7 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
+import { createArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
@@ -96,14 +97,19 @@ function createAppPageBoundaryRscPayload(options) {
 	const routeId = AppElementsWire.encodeRouteId(options.pathname, null);
 	const layoutEntries = createAppPageBoundaryLayoutEntries(options.route, options.layoutModules);
 	const sourcePageSegments = options.sourcePageSegments ?? options.route?.routeSegments;
+	const rootLayoutTreePath = layoutEntries[0]?.treePath ?? null;
 	return {
 		...AppElementsWire.createMetadataEntries({
 			interceptionContext: null,
 			layoutIds: layoutEntries.map((entry) => entry.id),
-			rootLayoutTreePath: layoutEntries[0]?.treePath ?? null,
+			rootLayoutTreePath,
 			routeId,
 			sourcePage: sourcePageSegments ? createAppPageSourcePage(sourcePageSegments) : null
 		}),
+		[AppElementsWire.keys.artifactCompatibility]: createArtifactCompatibilityEnvelope({
+			deploymentVersion: process.env.__VINEXT_BUILD_ID ?? null,
+			rootBoundaryId: rootLayoutTreePath
+		}),
 		[routeId]: options.element
 	};
 }
@@ -157,6 +163,7 @@ async function renderAppPageBoundaryElementResponse(options) {
 					isCacheCandidate: options.isCacheCandidate,
 					isEdgeRuntime: options.isEdgeRuntime,
 					middlewareHeaders: options.middlewareContext.headers,
+					preloadRoutePattern: options.route ? options.route.pattern : null,
 					navigationContext: options.getNavigationContext() ?? {
 						pathname,
 						searchParams: requestUrl.searchParams,

package/dist/server/app-page-cache-render.js

@@ -43,6 +43,7 @@ async function renderAppPageCacheArtifactsImpl(options, renderSpan) {
 			mirrorNextFlight: options.mirrorNextFlight,
 			isStaticGeneration: true,
 			isForceStatic: options.isForceStatic,
+			preloadRoutePattern: options.route.pattern,
 			onSsrError: options.onSsrError && options.isCapturedRscError ? createAppPageSsrErrorHandler((error) => {
 				recordAppPageRenderError(renderSpan, error);
 				return options.onSsrError?.(error);

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

@@ -149,6 +149,7 @@ async function runAppPageRevalidationContext(options, renderFn) {
 		currentFetchRevalidate: options.currentFetchRevalidate ?? null,
 		currentForceDynamicFetchDefault: options.dynamicConfig === "force-dynamic",
 		executionContext: getRequestExecutionContext(),
+		rootParams: options.rootParams ?? null,
 		unstableCacheRevalidation: "foreground"
 	});
 	const revalidation = runWithRequestContext(requestContext, () => runInWorkStoreScope(async () => {
@@ -388,6 +389,7 @@ async function dispatchAppPageInner(options) {
 					draftModeSecret: options.draftModeSecret,
 					dynamicConfig: revalidationDynamicConfig,
 					params: revalidationTarget.navigationParams,
+					rootParams: options.rootParams,
 					routePattern: revalidationTarget.route.pattern,
 					routeSegments: revalidationTarget.route.routeSegments,
 					setNavigationContext: options.setNavigationContext

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

@@ -497,7 +497,8 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 			isForceStatic: options.isForceStatic,
 			loadSsrHandler: options.loadSsrHandler,
 			navigationContext: options.getNavigationContext(),
-			rootParams: options.rootParams
+			rootParams: options.rootParams,
+			routePattern: options.routePattern
 		}) : void 0;
 		let requestCacheLifeForPrerender = null;
 		if (shouldWaitForAllReady) await settleCapturedRscRenderForCacheMetadata(capturedRscDataRef.value);
@@ -812,6 +813,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				reactMaxHeadersLength: options.reactMaxHeadersLength,
 				rootParams: options.rootParams,
 				pprFallbackShellSignal: options.pprFallbackShellSignal,
+				preloadRoutePattern: options.routePattern,
 				formState: options.formState ?? null,
 				rscStream: rscForResponse,
 				scriptNonce: options.scriptNonce,

package/dist/server/app-page-rsc-render-status.d.ts

@@ -31,6 +31,7 @@ type CreateAppPageRscRenderStatusResolverOptions = {
   loadSsrHandler: () => Promise<AppPageSsrHandler>;
   navigationContext: NavigationContext | null;
   rootParams?: RootParams;
+  routePattern: string;
 };
 /**
  * Resolve an RSC-only render's status once its Flight payload is complete.

package/dist/server/app-page-rsc-render-status.js

@@ -28,6 +28,7 @@ async function resolveAppPageRscRenderStatus(options) {
 			isForceStatic: options.isForceStatic,
 			isStaticGeneration: true,
 			onSsrError: () => void 0,
+			preloadRoutePattern: options.routePattern,
 			rootParams: options.rootParams
 		});
 	} catch (error) {

package/dist/server/app-page-search-params-observation.d.ts

@@ -1,15 +1,12 @@
 import { ThenableParams, ThenableParamsObserver } from "../shims/thenable-params.js";
 import { AppPageSearchParams } from "./app-page-head.js";
 //#region src/server/app-page-search-params-observation.d.ts
-type AppPageSearchParamsObservationOptions = {
-  observeReactPromiseStatus?: boolean;
-};
 type ClientPageSsrSearchParamsOptions = {
   isForceStatic?: boolean;
   isPprFallbackShell?: boolean;
 };
 export declare function createAppPageSearchParamsObserver(): ThenableParamsObserver;
-export declare function makeObservedAppPageSearchParamsThenable(pageSearchParams: AppPageSearchParams, options?: AppPageSearchParamsObservationOptions): ThenableParams<AppPageSearchParams>;
+export declare function makeObservedAppPageSearchParamsThenable(pageSearchParams: AppPageSearchParams): ThenableParams<AppPageSearchParams>;
 /**
  * The `searchParams` a client page receives during SSR (see
  * `shims/client-page-root.tsx`). Its RSC payload carries no query, so this is

package/dist/server/app-page-search-params-observation.js

@@ -9,17 +9,15 @@ function markAppPageSearchParamsAccess() {
 	markRenderRequestApiUsage("searchParams");
 }
 function createAppPageSearchParamsObserver() {
-	return { observeParamAccess() {
-		markAppPageSearchParamsAccess();
-	} };
+	return {
+		observeParamAccess() {
+			markAppPageSearchParamsAccess();
+		},
+		observeThenRead: throwIfStaticGenerationAccessError
+	};
 }
-function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {}) {
-	const observer = createAppPageSearchParamsObserver();
-	if (options.observeReactPromiseStatus === true) return makeThenableParams(pageSearchParams, {
-		...observer,
-		observeReactPromiseStatus: true
-	});
-	return makeThenableParams(pageSearchParams, observer);
+function makeObservedAppPageSearchParamsThenable(pageSearchParams) {
+	return makeThenableParams(pageSearchParams, createAppPageSearchParamsObserver());
 }
 /**
 * The `searchParams` a client page receives during SSR (see

package/dist/server/app-page-stream.d.ts

@@ -71,6 +71,8 @@ export type AppPageSsrHandler = {
     };
     /** Abort signal for a build-time PPR fallback-shell static render. */
     pprFallbackShellSignal?: AbortSignal;
+    /** Route whose client references load before the render; null for none. */
+    preloadRoutePattern?: string | null;
     /** When true, wait for the full React tree before emitting bytes. */
     waitForAllReady?: boolean;
     /** Render is producing a static/prerendered HTML artifact. */
@@ -128,6 +130,11 @@ type RenderAppPageHtmlStreamOptions = {
   };
   /** Abort signal for a build-time PPR fallback-shell static render. */
   pprFallbackShellSignal?: AbortSignal;
+  /**
+   * Route whose client references load before the render, or null for a
+   * render without a route. Undefined loads every client reference.
+   */
+  preloadRoutePattern?: string | null;
   /** When true, wait for the full React tree before emitting bytes. */
   waitForAllReady?: boolean;
   /** Render is producing a static/prerendered HTML artifact. */

package/dist/server/app-page-stream.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,

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

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-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.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");
@@ -21,7 +21,47 @@ function invokeAppComponent(component, props) {
 	if (candidate.$$typeof === REACT_LAZY && candidate._init) return invokeAppComponent(candidate._init(candidate._payload), props);
 	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);
+}
+/**
+* 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) {
+	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 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) {

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.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-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";
@@ -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;
 };

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;

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 = {

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");

package/dist/server/app-route-module-loader.js

@@ -1,4 +1,5 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
+import { shareIsolatePromise } from "./isolate-shared-promise.js";
 //#region src/server/app-route-module-loader.ts
 /**
 * Lazy route-module hydration for the App Router RSC entry.
@@ -63,7 +64,7 @@ async function hydrateInterceptModule(intercept, loader, field, loadingField) {
 	const cached = loadState?.[field];
 	if (cached != null) intercept[field] = cached;
 	if (!loader || intercept[field] != null) return;
-	const loading = loadState?.[loadingField] ?? runOutsideRequestScopes(loader).then((module) => {
+	const loading = loadState?.[loadingField] ?? shareIsolatePromise(runOutsideRequestScopes(loader).then((module) => {
 		intercept[field] = module;
 		if (loadState) {
 			loadState[field] = module;
@@ -73,7 +74,7 @@ async function hydrateInterceptModule(intercept, loader, field, loadingField) {
 	}).catch((error) => {
 		if (loadState) loadState[loadingField] = null;
 		throw error;
-	});
+	}));
 	if (loadState) loadState[loadingField] = loading;
 	intercept[field] = await loading;
 }
@@ -92,13 +93,13 @@ function loadAppInterceptLayouts(intercept) {
 	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
 	pushArrayLoads(loads, intercept.interceptLoadings, intercept.__loadInterceptLoadings);
 	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
-	const loading = Promise.all(loads).then(() => {
+	const loading = shareIsolatePromise(Promise.all(loads).then(() => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
 		return intercept.interceptLayouts ?? [];
 	}).catch((error) => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
 		throw error;
-	});
+	}));
 	if (loadState) loadState.interceptLayoutsLoading = loading;
 	return loading;
 }
@@ -143,14 +144,14 @@ function ensureAppRouteModulesLoaded(route) {
 		route.__loaded = true;
 		return route;
 	}
-	const loading = Promise.all(loads).then(() => {
+	const loading = shareIsolatePromise(Promise.all(loads).then(() => {
 		route.__loaded = true;
 		route.__loading = null;
 		return route;
 	}).catch((error) => {
 		route.__loading = null;
 		throw error;
-	});
+	}));
 	route.__loading = loading;
 	return loading;
 }

package/dist/server/app-route-tree.d.ts

@@ -0,0 +1,20 @@
+import { AppElements } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { ReactNode } from "react";
+//#region src/server/app-route-tree.d.ts
+/**
+ * Builds the App Router route tree after a sibling that the browser uses to
+ * write navigation history. Insertion effects run in tree order, so that
+ * sibling's effect runs before React mutates the route tree's DOM, like
+ * Next.js' HistoryUpdater.
+ *
+ * The server and the browser must render this same shape: a second child
+ * changes the useId values of everything below it, so SSR passes null in the
+ * sibling's place to keep hydrated ids matching.
+ */
+export declare function createAppRouteTree(options: {
+  elements: AppElements;
+  historyCommit: ReactNode;
+  routeId: string;
+}): ReactNode;
+//#endregion

package/dist/server/app-route-tree.js

@@ -0,0 +1,18 @@
+import { ElementsContext, Slot } from "../shims/slot.js";
+import { Fragment, createElement } from "react";
+//#region src/server/app-route-tree.ts
+/**
+* Builds the App Router route tree after a sibling that the browser uses to
+* write navigation history. Insertion effects run in tree order, so that
+* sibling's effect runs before React mutates the route tree's DOM, like
+* Next.js' HistoryUpdater.
+*
+* The server and the browser must render this same shape: a second child
+* changes the useId values of everything below it, so SSR passes null in the
+* sibling's place to keep hydrated ids matching.
+*/
+function createAppRouteTree(options) {
+	return createElement(Fragment, null, options.historyCommit, createElement(ElementsContext.Provider, { value: options.elements }, createElement(Slot, { id: options.routeId })));
+}
+//#endregion
+export { createAppRouteTree };