vinext 1.3.0 → 1.4.0

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

@@ -15,14 +15,78 @@ 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) {
+	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);
-	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);
+	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);
+	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, onSettled) {
+	const fail = (error) => {
+		if (isAppRenderSuspension(error)) return error;
+		const mapped = mapError(error);
+		onSettled?.({ error: mapped });
+		return mapped;
+	};
+	try {
+		const result = invokeAppComponentObserved(component, props, mapError, onSettled);
+		return isPromiseLike(result) ? trackAppComponentResult(result, fail, onSettled) : result;
+	} catch (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
@@ -48,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) {
-	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 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;
@@ -111,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) {
@@ -132,4 +199,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, 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.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-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-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-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.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,22 +1,23 @@
 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 { buildPageCacheTags } from "./implicit-tags.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";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.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.d.ts

@@ -104,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

@@ -167,7 +167,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 +284,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 +322,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, {

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.d.ts

@@ -26,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,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

@@ -39,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

@@ -76,8 +76,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 +91,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;
@@ -228,9 +240,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;

package/dist/server/app-route-module-loader.d.ts

@@ -43,6 +43,14 @@ type LazyLoadableIntercept = {
   __loadInterceptLayouts?: LazyModuleLoaderArray | null;
   interceptLoadings?: readonly unknown[] | null;
   __loadInterceptLoadings?: LazyModuleLoaderArray | null;
+  interceptNotFounds?: readonly unknown[] | null;
+  __loadInterceptNotFounds?: LazyModuleLoaderArray | null;
+  interceptForbiddens?: readonly unknown[] | null;
+  __loadInterceptForbiddens?: LazyModuleLoaderArray | null;
+  interceptUnauthorizeds?: readonly unknown[] | null;
+  __loadInterceptUnauthorizeds?: LazyModuleLoaderArray | null;
+  interceptErrors?: readonly unknown[] | null;
+  __loadInterceptErrors?: LazyModuleLoaderArray | null;
   __loadState?: {
     page?: unknown;
     pageLoading?: Promise<unknown> | null;
@@ -60,6 +68,7 @@ type LazyLoadableSlot = {
   loadings?: readonly unknown[];
   error?: unknown;
   notFound?: unknown;
+  notFounds?: readonly unknown[];
   __loadPage?: LazyModuleThunk | null;
   __loadDefault?: LazyModuleThunk | null;
   __loadLayout?: LazyModuleThunk | null;
@@ -68,6 +77,7 @@ type LazyLoadableSlot = {
   __loadLoadings?: LazyModuleLoaderArray | null;
   __loadError?: LazyModuleThunk | null;
   __loadNotFound?: LazyModuleThunk | null;
+  __loadNotFounds?: LazyModuleLoaderArray | null;
   /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];
 };
@@ -82,6 +92,9 @@ export type LazyLoadableRoute = {
   notFounds?: unknown[];
   forbiddens?: unknown[];
   unauthorizeds?: unknown[];
+  segmentNotFounds?: unknown[];
+  segmentForbiddens?: unknown[];
+  segmentUnauthorizeds?: unknown[];
   loading?: unknown;
   error?: unknown;
   notFound?: unknown;
@@ -101,6 +114,9 @@ export type LazyLoadableRoute = {
   __loadNotFounds?: LazyModuleLoaderArray | null;
   __loadForbiddens?: LazyModuleLoaderArray | null;
   __loadUnauthorizeds?: LazyModuleLoaderArray | null;
+  __loadSegmentNotFounds?: LazyModuleLoaderArray | null;
+  __loadSegmentForbiddens?: LazyModuleLoaderArray | null;
+  __loadSegmentUnauthorizeds?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
   __loadError?: LazyModuleThunk | null;
   __loadNotFound?: LazyModuleThunk | null;
@@ -123,4 +139,5 @@ export declare function loadAppInterceptLayouts(intercept: LazyLoadableIntercept
  * `null`/`undefined` routes and on eager routes that have no lazy thunks.
  */
 export declare function ensureAppRouteModulesLoaded<TRoute extends LazyLoadableRoute>(route: TRoute | null | undefined): TRoute | Promise<TRoute>;
-//#endregion
+//#endregion
+export {};

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

@@ -92,6 +92,10 @@ function loadAppInterceptLayouts(intercept) {
 	const loads = [];
 	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
 	pushArrayLoads(loads, intercept.interceptLoadings, intercept.__loadInterceptLoadings);
+	pushArrayLoads(loads, intercept.interceptNotFounds, intercept.__loadInterceptNotFounds);
+	pushArrayLoads(loads, intercept.interceptForbiddens, intercept.__loadInterceptForbiddens);
+	pushArrayLoads(loads, intercept.interceptUnauthorizeds, intercept.__loadInterceptUnauthorizeds);
+	pushArrayLoads(loads, intercept.interceptErrors, intercept.__loadInterceptErrors);
 	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
 	const loading = shareIsolatePromise(Promise.all(loads).then(() => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
@@ -130,6 +134,9 @@ function ensureAppRouteModulesLoaded(route) {
 	pushArrayLoads(loads, route.notFounds, route.__loadNotFounds);
 	pushArrayLoads(loads, route.forbiddens, route.__loadForbiddens);
 	pushArrayLoads(loads, route.unauthorizeds, route.__loadUnauthorizeds);
+	pushArrayLoads(loads, route.segmentNotFounds, route.__loadSegmentNotFounds);
+	pushArrayLoads(loads, route.segmentForbiddens, route.__loadSegmentForbiddens);
+	pushArrayLoads(loads, route.segmentUnauthorizeds, route.__loadSegmentUnauthorizeds);
 	for (const slot of Object.values(route.slots ?? {})) {
 		pushFieldLoad(loads, slot, "page", slot.__loadPage);
 		pushFieldLoad(loads, slot, "default", slot.__loadDefault);
@@ -139,6 +146,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushArrayLoads(loads, slot.loadings, slot.__loadLoadings);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
 		pushFieldLoad(loads, slot, "notFound", slot.__loadNotFound);
+		pushArrayLoads(loads, slot.notFounds, slot.__loadNotFounds);
 	}
 	if (loads.length === 0) {
 		route.__loaded = true;

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

@@ -39,4 +39,5 @@ export type PrefetchInliningConfig = false | {
 };
 export declare function isRouteTreePrefetchRequest(request: Request): boolean;
 export declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-cache-busting.d.ts

@@ -1,5 +1,5 @@
-import { VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { AppRscStateFingerprintInput } from "./app-rsc-state-fingerprint.js";
 //#region src/server/app-rsc-cache-busting.d.ts
 /**
@@ -13,10 +13,10 @@ export declare const VINEXT_RSC_BUILD_ID_HEADER = "X-Vinext-RSC-Build-Id";
 export declare const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
 export declare const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
 type CreateRscRequestHeadersOptions = {
-  clientReuseManifestHeader?: string | null;
   interceptionContext?: string | null;
   interceptionId?: string | null;
   mountedSlotsHeader?: string | null;
+  mountedLayoutsHeader?: string | null;
   includePrefetchHeader?: boolean;
   renderMode?: AppRscRenderMode;
   fetchPriority?: "auto" | "high" | "low";

package/dist/server/app-rsc-cache-busting.js

@@ -1,5 +1,5 @@
 import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
-import { NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER } from "./headers.js";
+import { NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_MOUNTED_LAYOUTS_HEADER } from "./headers.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { applyDeploymentIdHeader, getDeploymentId } from "../utils/deployment-id.js";
@@ -183,7 +183,7 @@ function createRscRequestHeaders(options = {}) {
 	if (options.interceptionContext !== void 0 && options.interceptionContext !== null) headers.set(VINEXT_INTERCEPTION_CONTEXT_HEADER, options.interceptionContext);
 	if (options.interceptionId !== void 0 && options.interceptionId !== null) headers.set(VINEXT_INTERCEPTION_ID_HEADER, options.interceptionId);
 	if (options.mountedSlotsHeader !== void 0 && options.mountedSlotsHeader !== null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
-	if (options.clientReuseManifestHeader !== void 0 && options.clientReuseManifestHeader !== null) headers.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, options.clientReuseManifestHeader);
+	if (options.mountedLayoutsHeader !== void 0 && options.mountedLayoutsHeader !== null) headers.set(VINEXT_MOUNTED_LAYOUTS_HEADER, options.mountedLayoutsHeader);
 	const renderMode = options.renderMode ?? "navigation";
 	if (renderMode !== "navigation") headers.set(VINEXT_RSC_RENDER_MODE_HEADER, renderMode);
 	return headers;
@@ -199,8 +199,8 @@ function canonicalizePrewarmableRscRequestHeaders(headers) {
 	headers.delete(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER);
 	headers.delete(NEXT_ROUTER_STATE_TREE_HEADER);
 	headers.delete(NEXT_URL_HEADER);
+	headers.delete(VINEXT_MOUNTED_LAYOUTS_HEADER);
 	headers.delete(VINEXT_RSC_STATE_FINGERPRINT_HEADER);
-	headers.delete(VINEXT_CLIENT_REUSE_MANIFEST_HEADER);
 	return true;
 }
 /**
@@ -214,8 +214,8 @@ function canonicalizeLoadingShellRscRequestHeaders(headers) {
 	headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
 	headers.delete(NEXT_ROUTER_STATE_TREE_HEADER);
 	headers.delete(NEXT_URL_HEADER);
+	headers.delete(VINEXT_MOUNTED_LAYOUTS_HEADER);
 	headers.delete(VINEXT_RSC_STATE_FINGERPRINT_HEADER);
-	headers.delete(VINEXT_CLIENT_REUSE_MANIFEST_HEADER);
 	return true;
 }
 const RSC_REQUEST_URL_BASE = "http://vinext.local";

package/dist/server/app-rsc-error-handler.d.ts

@@ -20,7 +20,9 @@ export type AppRenderErrorContextOverrides = {
  * the incoming Web `Request`, wires it into a `createRscOnErrorHandler` call,
  * and binds the configured `reportRequestError` reporter.
  *
- * Pure factory: takes all deps explicitly — no closure over module-level state.
+ * Takes all deps explicitly. The only module-level state is the set of errors
+ * each request already logged, keyed weakly by its `Request`.
  */
 export declare function createAppRscOnErrorHandler(reportRequestError: ReportRequestError, request: Request, pathname: string, routePath: string, overrides?: AppRenderErrorContextOverrides): (error: unknown) => string | undefined;
-//#endregion
+//#endregion
+export {};