vinext 1.3.1 → 1.4.1

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

@@ -1,8 +1,10 @@
 import { AppMiddlewareContext } from "./app-middleware.js";
 import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 import { EdgeApiExecutionRuntime } from "./edge-api-runtime.js";
+import { RuntimePagesDataKind } from "./pages-route-data-kind.js";
 //#region src/server/app-pages-bridge.d.ts
 export type PagesEntry = {
+  getRuntimePageDataKind?: (url: string, request: Request) => RuntimePagesDataKind;
   handleApiRoute?: (request: Request, url: string, ctx: unknown, trustedRevalidateOrigin: string | undefined, edgeRuntime: EdgeApiExecutionRuntime, initialResponseHeaders?: Headers) => Promise<Response> | Response;
   matchApiRoute?: (url: string, request: Request) => PagesRouteMatch | null;
   matchPageRoute?: (url: string, request: Request) => PagesRouteMatch | null;
@@ -55,6 +57,8 @@ type RenderPagesFallbackOptions = {
   pathname?: string;
   pagesDataRequest?: Request | null;
   request: Request;
+  /** The shared cache entry answers every host; a request-time render is not stored. */
+  sharedAcrossHosts?: boolean;
   url: URL;
 };
 /**

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

@@ -1,6 +1,6 @@
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { beginRouteCacheability } from "../shims/cacheability-classification.js";
+import { beginRouteCacheability, markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
 import { mergeHeaders } from "./worker-utils.js";
 import { pagesRouteHasPriorityOverAppRoute } from "./hybrid-route-priority.js";
 //#region src/server/app-pages-bridge.ts
@@ -18,7 +18,7 @@ function applyPagesMiddlewareContext(response, middlewareContext) {
 * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
 */
 async function renderPagesFallback(options, dependencies) {
-	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, initialResponseHeaders, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
+	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, initialResponseHeaders, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, sharedAcrossHosts = false, url } = options;
 	const { loadPagesEntry, buildRequestHeaders, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
 	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
@@ -61,7 +61,11 @@ async function renderPagesFallback(options, dependencies) {
 	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);
+	if (pageMatch !== null) {
+		beginRouteCacheability("pages-page", pageMatch.route.pattern);
+		const runtimeDataKind = sharedAcrossHosts ? pagesEntry.getRuntimePageDataKind?.(pagesUrl, matchRequest) : void 0;
+		if (runtimeDataKind === "server" || runtimeDataKind === "initial") markRouteCacheabilityDynamic("getInitialProps render shares a cache entry across hosts");
+	}
 	const pagesRequest = claimPagesRequest();
 	const renderArgs = [
 		pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest,

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

@@ -17,16 +17,23 @@ export declare function isReactOwnedAppComponent(component: unknown): boolean;
  * 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>;
+/**
+ * Reports how a component's own render ended: `failure` holds what it threw
+ * or rejected with, after `mapError`. A suspension isn't an end, as React
+ * renders the component again.
+ */
+export type AppComponentSettledCallback = (failure?: {
+  error: unknown;
+}) => void;
 /**
  * `invokeAppComponent()`, with every error the component throws or rejects
  * with replaced by `mapError(error)`, including its CSS-wrapped inner one's.
+ * `onSettled` hears once how the component, or that inner one, ended.
  */
-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 invokeAppComponentMappingErrors(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, mapError: (error: unknown) => unknown, onSettled?: AppComponentSettledCallback): ReactNode | Promise<ReactNode>;
 export declare function createAppRenderDependency(): AppRenderDependency;
 export declare function createAppPageRenderDependency(): AppPageRenderDependency;
 export declare function isAppRenderSuspension(error: unknown): boolean;
 export declare function renderAfterAppDependencies(children: ReactNode, dependencies: readonly AppRenderDependency[]): ReactNode;
-export declare function renderAppComponentWithDependencyBarrier(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, dependency: AppRenderDependency): ReactNode;
+export declare function renderAppComponentWithDependencyBarrier(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, dependency: AppRenderDependency, mapError?: (error: unknown) => unknown, onSettled?: AppComponentSettledCallback): ReactNode;
 //#endregion

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

@@ -21,29 +21,74 @@ function isReactOwnedAppComponent(component) {
 * errors this call throws or rejects with.
 */
 function invokeAppComponent(component, props, mapError) {
+	return invokeAppComponentObserved(component, props, mapError, void 0);
+}
+/**
+* Like `invokeAppComponent()`. `onSettled` hears of a value returned
+* synchronously; the caller reports a promise result or a thrown error.
+*/
+function invokeAppComponentObserved(component, props, mapError, onSettled) {
 	const candidate = component;
-	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);
+	if (candidate.$$typeof === REACT_MEMO && candidate.type) return invokeAppComponentObserved(candidate.type, props, mapError, onSettled);
+	if (candidate.$$typeof === REACT_LAZY && candidate._init) return invokeAppComponentObserved(candidate._init(candidate._payload), props, mapError, onSettled);
+	if (candidate.$$typeof === REACT_FORWARD_REF && candidate.render) {
+		const result = candidate.render(props, void 0);
+		if (!isPromiseLike(result)) onSettled?.();
+		return result;
+	}
+	if (isReactOwnedAppComponent(candidate)) {
+		onSettled?.();
+		return createElement(candidate, props);
+	}
 	const result = candidate(props);
-	return isPromiseLike(result) ? result : invokeCssWrappedComponent(result, props, mapError);
+	return isPromiseLike(result) ? result : invokeCssWrappedComponent(result, props, mapError, onSettled);
 }
 /**
 * `invokeAppComponent()`, with every error the component throws or rejects
 * with replaced by `mapError(error)`, including its CSS-wrapped inner one's.
+* `onSettled` hears once how the component, or that inner one, ended.
 */
-function invokeAppComponentMappingErrors(component, props, mapError) {
+function invokeAppComponentMappingErrors(component, props, mapError, onSettled) {
+	const fail = (error) => {
+		if (isAppRenderSuspension(error)) return error;
+		const mapped = mapError(error);
+		onSettled?.({ error: mapped });
+		return mapped;
+	};
 	try {
-		const result = invokeAppComponent(component, props, mapError);
-		return isPromiseLike(result) ? Promise.resolve(result).catch((error) => {
-			throw mapError(error);
-		}) : result;
+		const result = invokeAppComponentObserved(component, props, mapError, onSettled);
+		return isPromiseLike(result) ? trackAppComponentResult(result, fail, onSettled) : result;
 	} catch (error) {
-		throw mapError(error);
+		throw fail(error);
 	}
 }
 /**
+* Records how `result` settles on the promise itself, as React's thenables
+* do, with `fail(error)` as a rejection's reason. Flight then reads that
+* outcome rather than tracking the promise, so the result reaches it in the
+* same tick as an unmapped one. A promise chained with `.then()` resolves a
+* tick later, which costs a large page about a tenth more render work.
+*/
+function trackAppComponentResult(result, fail, onSettled) {
+	const thenable = result;
+	if (thenable.status !== void 0) return Promise.resolve(result).then((value) => {
+		onSettled?.();
+		return value;
+	}, (error) => {
+		throw fail(error);
+	});
+	thenable.status = "pending";
+	thenable.then((value) => {
+		thenable.status = "fulfilled";
+		thenable.value = value;
+		onSettled?.();
+	}, (error) => {
+		thenable.status = "rejected";
+		thenable.reason = fail(error);
+	});
+	return thenable;
+}
+/**
 * 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.
@@ -67,28 +112,33 @@ function isElementOfProps(elementProps, props, defaultProps) {
 * 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 invokeCssWrappedComponent(result, props, mapError, onSettled) {
+	const wrapped = readCssWrappedComponent(result, props);
+	if (!wrapped) {
+		onSettled?.();
+		return result;
+	}
+	const { component, componentProps, css } = wrapped;
 	function CssWrappedComponent() {
-		return mapError ? invokeAppComponentMappingErrors(component, componentProps, mapError) : invokeAppComponent(component, componentProps);
+		return mapError ? invokeAppComponentMappingErrors(component, componentProps, mapError, onSettled) : 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) {
-	if (dependenciesByElementId.size === 0) return;
-	appElementRenderDependencies.set(elements, dependenciesByElementId);
-}
-function releaseAppElementRenderDependency(elements, elementId) {
-	appElementRenderDependencies.get(elements)?.get(elementId)?.release();
+/** The parts of `result`, if it's a CSS-wrapped export's element for `props`. */
+function readCssWrappedComponent(result, props) {
+	if (!isValidElement(result) || result.type !== Fragment || result.key !== null) return null;
+	const children = result.props.children;
+	if (!Array.isArray(children) || children.length !== 2) return null;
+	const [css, inner] = children;
+	if (!isValidElement(inner) || typeof inner.type !== "function" || inner.key !== null) return null;
+	const component = inner.type;
+	if (!isElementOfProps(inner.props, props, component.defaultProps)) return null;
+	return {
+		component,
+		componentProps: inner.props,
+		css
+	};
 }
 function createAppRenderDependency() {
 	let released = false;
@@ -130,17 +180,15 @@ function renderAfterAppDependencies(children, dependencies) {
 	}
 	return /* @__PURE__ */ jsx(AwaitAppRenderDependencies, {});
 }
-function renderAppComponentWithDependencyBarrier(component, props, dependency) {
+function renderAppComponentWithDependencyBarrier(component, props, dependency, mapError, onSettled) {
 	function AppComponentDependencyBarrier() {
 		try {
-			const result = invokeAppComponent(component, props);
-			if (isPromiseLike(result)) return Promise.resolve(result).then((resolvedResult) => {
-				dependency.release();
-				return resolvedResult;
-			}, (error) => {
-				dependency.release();
-				throw error;
-			});
+			const result = mapError ? invokeAppComponentMappingErrors(component, props, mapError, onSettled) : invokeAppComponent(component, props);
+			if (isPromiseLike(result)) {
+				const release = () => dependency.release();
+				result.then(release, release);
+				return result;
+			}
 			dependency.release();
 			return result;
 		} catch (error) {
@@ -151,4 +199,4 @@ function renderAppComponentWithDependencyBarrier(component, props, dependency) {
 	return createElement(AppComponentDependencyBarrier);
 }
 //#endregion
-export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, invokeAppComponentMappingErrors, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };
+export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, invokeAppComponentMappingErrors, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };

package/dist/server/app-request-stage-dispatch.js

@@ -44,7 +44,7 @@ async function dispatchAppRequestStage(request, ctx, dispatchResponseStage, opti
 			headRequest,
 			middlewareCookieOverlay: null,
 			prerenderDiscovery: options.prerenderDiscovery,
-			protocolVersion: 11,
+			protocolVersion: 13,
 			requestOrigin: new URL(request.url).origin,
 			scriptNonce: null,
 			staticFileSignalToken,

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

@@ -32,7 +32,7 @@ function handleRequestStage(request, env, ctx, dispatchResponseStage) {
 			callback: () => handleRequest(request, env, ctx, dispatchResponseStage, ctx?.assets).then((response) => applyCdnResponseIdentityHeaders(response, originalRequest)),
 			getStatus: (response) => response?.status,
 			headers: request.headers,
-			isRsc: url.pathname.endsWith(".rsc") || request.headers.get("RSC") === "1",
+			isRsc: request.headers.get("RSC") === "1",
 			method: request.method,
 			target: url.pathname + url.search
 		});

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

@@ -1,6 +1,6 @@
 import { isrCacheControl, resolveRouteExpireSeconds } from "./isr-cache.js";
-import { makeThenableParams } from "../shims/thenable-params.js";
 import { applyRouteHandlerMiddlewareContext, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
+import { makeThenableParams } from "../shims/thenable-params.js";
 import { markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { resolveAppRouteHandlerSpecialError } from "./app-route-handler-policy.js";
 import { completeAppRouteHandlerResponse, runAppRouteHandler, traceAppRouteHandlerExecution } from "./app-route-handler-execution.js";
@@ -57,7 +57,7 @@ async function readAppRouteHandlerCacheResponse(options) {
 								setHeadersAccessPhase: options.setHeadersAccessPhase
 							}) };
 						} catch (error) {
-							if (resolveAppRouteHandlerSpecialError(error, options.requestUrl)) return { specialError: error };
+							if (resolveAppRouteHandlerSpecialError(error)) return { specialError: error };
 							throw error;
 						}
 					});

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

@@ -1,21 +1,22 @@
 import { closeAfterResponse, createRequestContext, getRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
-import "../utils/protocol-headers.js";
+import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { reportRequestError } from "./instrumentation.js";
 import { beginRouteCacheability, getRouteCacheabilityDynamicReason } from "../shims/cacheability-classification.js";
 import { applyCdnResponseBuildIdentityHeaders } from "./cache-control.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
+import { coalesceOnDemandResponse } from "./isr-cache.js";
 import { markDynamicUsage } from "../shims/internal/headers-state.js";
 import { consumeDynamicUsage, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, setHeadersAccessPhase } from "../shims/headers.js";
 import { _drainPendingRevalidations } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 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 { applyRouteHandlerMiddlewareContext, finalizeRouteHandlerResponse } from "./app-route-handler-response.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation.js";
+import { makeThenableParams } from "../shims/thenable-params.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";
@@ -94,7 +95,8 @@ async function dispatchAppRouteHandlerImpl(options) {
 		headers: { Allow: allowHeaderForOptions }
 	}));
 	const resolvedHandlerFn = isAppRouteHandlerFunction(handlerFn) ? handlerFn : void 0;
-	const shouldReadRouteCache = options.bypassSharedCache !== true && revalidateSeconds !== null && !getRouteCacheabilityDynamicReason() && shouldReadAppRouteHandlerCache({
+	const isOnDemandRevalidate = isOnDemandRevalidateRequest(options.request.headers.get(PRERENDER_REVALIDATE_HEADER));
+	const isStoredRoute = options.bypassSharedCache !== true && revalidateSeconds !== null && !getRouteCacheabilityDynamicReason() && shouldReadAppRouteHandlerCache({
 		dynamicConfig: handler.dynamic,
 		handlerFn: resolvedHandlerFn,
 		isAutoHead,
@@ -104,12 +106,13 @@ async function dispatchAppRouteHandlerImpl(options) {
 		method,
 		revalidateSeconds
 	});
-	const revalidateReason = isOnDemandRevalidateRequest(options.request.headers.get("x-prerender-revalidate")) ? "on-demand" : shouldReadRouteCache && revalidateSeconds !== Infinity ? "stale" : void 0;
+	const shouldReadRouteCache = isStoredRoute && !isOnDemandRevalidate;
+	const revalidateReason = isOnDemandRevalidate ? "on-demand" : shouldReadRouteCache && revalidateSeconds !== Infinity ? "stale" : void 0;
 	const fetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
 	setCurrentFetchCacheMode(fetchCacheMode);
 	setCurrentFetchRevalidate(configuredRevalidateSeconds);
 	setCurrentForceDynamicFetchDefault(handler.dynamic === "force-dynamic");
-	let isRevalidation = false;
+	let isRevalidation = isStoredRoute && isOnDemandRevalidate;
 	if (shouldReadRouteCache && resolvedHandlerFn) {
 		const cachedRouteResponse = await readAppRouteHandlerCacheResponse({
 			basePath: options.basePath,
@@ -167,7 +170,7 @@ async function dispatchAppRouteHandlerImpl(options) {
 		if (cachedRouteResponse) return applyCdnResponseBuildIdentityHeaders(cachedRouteResponse);
 	}
 	if (resolvedHandlerFn) {
-		const response = await executeAppRouteHandler({
+		const handlerOptions = {
 			isRevalidation,
 			basePath: options.basePath,
 			bypassSharedCache: options.bypassSharedCache,
@@ -210,8 +213,10 @@ async function dispatchAppRouteHandlerImpl(options) {
 			revalidateReason,
 			routePattern: route.pattern,
 			setHeadersAccessPhase
-		});
-		return applyCdnResponseBuildIdentityHeaders(response);
+		};
+		const runHandler = async () => applyCdnResponseBuildIdentityHeaders(await executeAppRouteHandler(handlerOptions));
+		if (isOnDemandRevalidate && isStoredRoute) return coalesceOnDemandResponse(`${method}:${options.isrRouteKey(options.cleanPathname)}`, method, runHandler);
+		return runHandler();
 	}
 	return finalizeFrameworkResponse(new Response(null, { status: 405 }));
 }

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

@@ -1,6 +1,7 @@
 import { isFullyBufferedBody } from "./fully-buffered-response.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { frameworkTracer } from "./tracer.js";
+import { logRequestError } from "./request-error-log.js";
 import { getRouteCacheabilityCaptureOptions, getRouteCacheabilityDynamicReason, isRouteCacheabilityEvaluation, markRouteCacheabilityExplicitResponsePolicy, markRouteCacheabilityResponseBodyComplete, recordRouteCacheability } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, hasCdnResponsePolicy, hasExplicitNonCacheableResponsePolicy } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl } from "./isr-decision.js";
@@ -117,7 +118,7 @@ async function runAppRouteHandler(options) {
 		onDynamicAccess() {
 			options.markDynamicUsage();
 		},
-		requestMode: options.dynamicConfig === "force-static" || options.dynamicConfig === "error" ? options.dynamicConfig : "auto",
+		requestMode: options.dynamicConfig === "force-dynamic" || options.dynamicConfig === "force-static" || options.dynamicConfig === "error" ? options.dynamicConfig : "auto",
 		signal: options.requestSignal,
 		staticGenerationErrorMessage(expression) {
 			return getAppRouteStaticGenerationErrorMessage(options.routePattern, expression);
@@ -167,7 +168,7 @@ async function executeAppRouteHandlerImpl(options) {
 							})
 						};
 					} catch (error) {
-						if (resolveAppRouteHandlerSpecialError(error, options.request.url, { isAction: isPossibleAppRouteActionRequest(options.request) })) return {
+						if (resolveAppRouteHandlerSpecialError(error, { isAction: isPossibleAppRouteActionRequest(options.request) })) return {
 							kind: "special",
 							error
 						};
@@ -284,7 +285,8 @@ async function executeAppRouteHandlerImpl(options) {
 					console.error("[vinext] ISR route cache write error:", cacheErr);
 				}
 			})();
-			options.executionContext?.waitUntil(routeWritePromise);
+			if (options.revalidateReason === "on-demand") await routeWritePromise;
+			else options.executionContext?.waitUntil(routeWritePromise);
 		}
 		let finalized = applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(response, {
 			pendingCookies,
@@ -321,7 +323,11 @@ async function executeAppRouteHandlerImpl(options) {
 		const draftCookie = handlerDraftCookie ?? options.initialDraftModeCookie;
 		const shouldApplyDraftPolicy = (options.getActiveDraftModeState?.() ?? options.isDraftMode === true) || draftCookie != null;
 		if (handlerDraftCookie != null) markKnownDynamicAppRoute(options.routePattern);
-		const specialError = resolveAppRouteHandlerSpecialError(error, options.request.url, { isAction: isPossibleAppRouteActionRequest(options.request) });
+		const specialError = resolveAppRouteHandlerSpecialError(error, { isAction: isPossibleAppRouteActionRequest(options.request) });
+		if (specialError && options.consumeDynamicUsage()) recordRouteCacheability({
+			cacheable: false,
+			dynamicUsage: true
+		});
 		options.clearRequestContext();
 		if (specialError) {
 			if (specialError.kind === "redirect") return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(finalizeRouteHandlerResponse(new Response(null, {
@@ -334,7 +340,7 @@ async function executeAppRouteHandlerImpl(options) {
 			}), options.middlewareContext, middlewareMergeOptions), shouldApplyDraftPolicy);
 			return applyDraftModeCachePolicy(applyRouteHandlerMiddlewareContext(new Response(null, { status: specialError.statusCode }), options.middlewareContext, middlewareMergeOptions), shouldApplyDraftPolicy);
 		}
-		console.error("[vinext] Route handler error:", error);
+		logRequestError("[vinext] Route handler error:", error);
 		await options.reportRequestError(error, {
 			path: options.cleanPathname,
 			method: options.request.method,

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

@@ -64,6 +64,6 @@ export declare function shouldApplyAppRouteHandlerRevalidateHeader(options: Omit
  */
 export declare function shouldCompleteAppRouteHandlerResponse(options: AppRouteHandlerResponseCacheOptions): boolean;
 export declare function shouldWriteAppRouteHandlerCache(options: AppRouteHandlerResponseCacheOptions): boolean;
-export declare function resolveAppRouteHandlerSpecialError(error: unknown, requestUrl: string, options?: AppRouteHandlerSpecialErrorOptions): AppRouteHandlerSpecialError | null;
+export declare function resolveAppRouteHandlerSpecialError(error: unknown, options?: AppRouteHandlerSpecialErrorOptions): AppRouteHandlerSpecialError | null;
 //#endregion
 export { isPossibleAppRouteActionRequest };

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

@@ -1,5 +1,5 @@
-import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { buildRouteHandlerAllowHeader, collectRouteHandlerMethods } from "./app-route-handler-runtime.js";
 //#region src/server/app-route-handler-policy.ts
 function getAppRouteHandlerRevalidateSeconds(handler) {
@@ -53,13 +53,13 @@ function shouldCompleteAppRouteHandlerResponse(options) {
 function shouldWriteAppRouteHandlerCache(options) {
 	return options.isProduction && options.revalidateSeconds !== null && options.revalidateSeconds > 0 && options.dynamicConfig !== "force-dynamic" && !options.isDraftMode && !options.dynamicUsedInHandler && (options.method === "GET" || options.isAutoHead);
 }
-function resolveAppRouteHandlerSpecialError(error, requestUrl, options) {
+function resolveAppRouteHandlerSpecialError(error, options) {
 	if (!(error && typeof error === "object" && "digest" in error)) return null;
 	const digest = String(error.digest);
 	const redirect = parseNextRedirectDigest(digest);
 	if (redirect) return {
 		kind: "redirect",
-		location: new URL(redirect.url, requestUrl).toString(),
+		location: redirect.url,
 		statusCode: options?.isAction ? 303 : redirect.status
 	};
 	const httpError = parseNextHttpErrorDigest(digest);

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

@@ -5,8 +5,8 @@ import { markRouteCacheabilityExplicitResponsePolicy, recordRouteCacheability }
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { mergeMiddlewareResponseHeadersOntoResponse } from "./middleware-response-headers.js";
 import { markEdgeRouteHandlerLinkHeaders } from "./app-response-header-provenance.js";
+import { mergeMiddlewareResponseHeadersOntoResponse } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts
 const APP_ROUTE_REWRITE_ERROR = "NextResponse.rewrite() was used in a app route handler, this is not currently supported. Please remove the invocation to continue.";

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

@@ -21,7 +21,7 @@ type NextUrlDynamicAccess = "nextUrl.search" | "nextUrl.searchParams" | "nextUrl
 type HostDerivedNextUrlDynamicAccess = "nextUrl.protocol" | "nextUrl.username" | "nextUrl.password" | "nextUrl.host" | "nextUrl.hostname" | "nextUrl.port" | DomainLocaleNextUrlDynamicAccess;
 type DomainLocaleNextUrlDynamicAccess = "nextUrl.locale" | "nextUrl.defaultLocale" | "nextUrl.domainLocale";
 type AppRouteDynamicRequestAccess = RequestDynamicAccess | NextUrlDynamicAccess;
-type AppRouteRequestMode = "auto" | "force-static" | "error";
+type AppRouteRequestMode = "auto" | "force-dynamic" | "force-static" | "error";
 type TrackedAppRouteRequestOptions = {
   basePath?: string;
   i18n?: NextI18nConfig | null;

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

@@ -2,6 +2,7 @@ import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-r
 import { addBasePathToPathname } from "../utils/base-path.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
+import { throwIfInsideCacheScope } from "../shims/internal/headers-state.js";
 import { BUILT_IN_REQUEST_PROPERTIES } from "./app-route-request-built-ins.js";
 //#region src/server/app-route-handler-runtime.ts
 const BUILT_IN_REQUEST_PROPERTY_MAP = new Map(BUILT_IN_REQUEST_PROPERTIES.map((property) => [property.key, property]));
@@ -76,8 +77,14 @@ function buildNextConfig(options) {
 * 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.
+* abort once GC collects any of them, so the request stays reachable for as
+* long as the host signal is.
+*
+* The request must not follow the host signal itself, though. Undici registers
+* every Request in a FinalizationRegistry whose held value strongly references
+* the followed signal, so the registry would keep the host signal (the WeakMap
+* key) and therefore the request alive forever. It follows a relay instead,
+* which the host signal aborts through a strong listener.
 */
 const requestsByHostSignal = /* @__PURE__ */ new WeakMap();
 function retainWhileSignalLives(signal, request) {
@@ -85,6 +92,12 @@ function retainWhileSignalLives(signal, request) {
 	if (requests) requests.push(request);
 	else requestsByHostSignal.set(signal, [request]);
 }
+function followHostSignal(signal) {
+	const relay = new AbortController();
+	if (signal.aborted) relay.abort(signal.reason);
+	else signal.addEventListener("abort", () => relay.abort(signal.reason), { once: true });
+	return relay.signal;
+}
 function createForceStaticNextRequest(input, nextConfig, signal) {
 	const read = (key) => {
 		const descriptor = BUILT_IN_REQUEST_PROPERTY_MAP.get(key)?.descriptor;
@@ -138,7 +151,8 @@ function createTrackedAppRouteRequest(request, options = {}) {
 	let didAccessDynamicRequest = false;
 	const requestMode = options.requestMode ?? "auto";
 	const nextConfig = buildNextConfig(options);
-	const markDynamicAccess = (access) => {
+	const markDynamicAccess = (access, trackedByNext) => {
+		if (trackedByNext && requestMode !== "force-dynamic") throwIfInsideCacheScope(access);
 		didAccessDynamicRequest = true;
 		options.onDynamicAccess?.(access);
 	};
@@ -172,7 +186,7 @@ function createTrackedAppRouteRequest(request, options = {}) {
 	const wrapNextUrl = (nextUrl) => {
 		return new Proxy(nextUrl, { get(target, prop) {
 			if (isNextDynamicNextUrlProperty(prop) || isHostDerivedNextUrlProperty(prop)) {
-				markDynamicAccess(`nextUrl.${String(prop)}`);
+				markDynamicAccess(`nextUrl.${String(prop)}`, isNextDynamicNextUrlProperty(prop));
 				return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
 			}
 			if (prop === "clone") return () => wrapNextUrl(target.clone());
@@ -228,9 +242,10 @@ 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, options.signal) : requestWithOverrides instanceof NextRequest && sourceCfDescriptor?.configurable !== false && !options.signal ? requestWithOverrides : new NextRequest(requestWithOverrides, {
+		const signal = options.signal ? followHostSignal(options.signal) : void 0;
+		const nextRequest = requestMode === "force-static" ? createForceStaticNextRequest(requestWithOverrides, nextConfig, signal) : requestWithOverrides instanceof NextRequest && sourceCfDescriptor?.configurable !== false && !signal ? requestWithOverrides : new NextRequest(requestWithOverrides, {
 			nextConfig: nextConfig ?? void 0,
-			signal: options.signal
+			signal
 		});
 		if (options.signal) retainWhileSignalLives(options.signal, nextRequest);
 		const rawCfMetadata = sourceCfAccessor ? void 0 : sourceCfMetadata === void 0 ? Reflect.get(nextRequest, "cf", nextRequest) : sourceCfMetadata;
@@ -239,7 +254,7 @@ function createTrackedAppRouteRequest(request, options = {}) {
 		const accessCf = (read, forceStaticValue) => {
 			if (requestMode === "force-static") return forceStaticValue;
 			if (requestMode === "error") return throwStaticGenerationError("request.cf");
-			markDynamicAccess("request.cf");
+			markDynamicAccess("request.cf", false);
 			return read();
 		};
 		const controlledCfGetter = () => accessCf(sourceCfAccessor ? () => Reflect.apply(sourceCfAccessor, requestWithOverrides, []) : () => rawCfMetadata, void 0);
@@ -341,17 +356,19 @@ function createTrackedAppRouteRequest(request, options = {}) {
 						return proxiedNextUrl;
 					case "headers":
 					case "cookies":
-					case "ip":
-					case "geo":
 					case "url":
 					case "body":
 					case "blob":
-					case "bytes":
 					case "json":
 					case "text":
 					case "arrayBuffer":
 					case "formData":
-						markDynamicAccess(`request.${String(prop)}`);
+						markDynamicAccess(`request.${String(prop)}`, true);
+						return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
+					case "ip":
+					case "geo":
+					case "bytes":
+						markDynamicAccess(`request.${String(prop)}`, false);
 						return bindMethodIfNeeded(Reflect.get(target, prop, target), target);
 					case "clone": return cloneTrackedRequest;
 					default: return getTrackedRequestProperty(target, prop, receiver);

package/dist/server/app-router-entry.js

@@ -37,7 +37,7 @@ var app_router_entry_default = {
 				callback: async () => applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request),
 				getStatus: (response) => response?.status,
 				headers: request.headers,
-				isRsc: url.pathname.endsWith(".rsc") || request.headers.get("RSC") === "1",
+				isRsc: request.headers.get("RSC") === "1",
 				method: request.method,
 				target: url.pathname + url.search
 			});