vinext 1.3.1 → 1.4.0

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

@@ -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.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.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-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,8 @@ 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

package/dist/server/app-rsc-error-handler.js

@@ -3,12 +3,14 @@ import "./app-rsc-vary.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { createRscOnErrorHandler } from "./app-rsc-errors.js";
 //#region src/server/app-rsc-error-handler.ts
+const loggedErrorsByRequest = /* @__PURE__ */ new WeakMap();
 /**
 * Build a per-request RSC error handler that extracts request metadata from
 * 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`.
 */
 function createAppRscOnErrorHandler(reportRequestError, request, pathname, routePath, overrides) {
 	const requestHeaders = Object.fromEntries(request.headers.entries());
@@ -24,9 +26,15 @@ function createAppRscOnErrorHandler(reportRequestError, request, pathname, route
 		renderSource: overrides?.renderSource ?? (request.headers.get("RSC") === "1" || new URL(request.url).pathname.endsWith(".rsc") ? "react-server-components-payload" : "react-server-components"),
 		revalidateReason: isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate")) ? "on-demand" : overrides?.revalidateReason
 	};
+	let loggedErrors = loggedErrorsByRequest.get(request);
+	if (!loggedErrors) {
+		loggedErrors = /* @__PURE__ */ new WeakSet();
+		loggedErrorsByRequest.set(request, loggedErrors);
+	}
 	return createRscOnErrorHandler({
 		attachDigest: errorContext.renderSource !== "server-rendering",
 		errorContext,
+		loggedErrors,
 		reportRequestError(error, info, context) {
 			reportRequestError(error, info, context);
 		},

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

@@ -15,6 +15,14 @@ type RscErrorReporter = (error: unknown, requestInfo: RscRequestInfo, errorConte
 type CreateRscOnErrorHandlerOptions = {
   attachDigest?: boolean;
   errorContext: RscErrorContext | null;
+  /**
+   * The errors this request already logged, shared by its handlers so an error
+   * reaching more than one, such as in the RSC and then the SSR pass, is logged
+   * once. Like Next.js, a digest alone does not mean an error was logged: user
+   * code can set its own. Request-scoped, as a failed module evaluation throws
+   * the same error on every request. Defaults to this handler's own.
+   */
+  loggedErrors?: WeakSet<object>;
   nodeEnv?: string;
   reportRequestError: RscErrorReporter;
   requestInfo: RscRequestInfo | null;

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

@@ -63,6 +63,13 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 }
 function createRscOnErrorHandler(options) {
 	let loggedPrerenderErrors;
+	const loggedErrors = options.loggedErrors ?? /* @__PURE__ */ new WeakSet();
+	const wasLogged = (error) => {
+		if (typeof error !== "object" && typeof error !== "function" || error === null) return false;
+		if (loggedErrors.has(error)) return true;
+		loggedErrors.add(error);
+		return false;
+	};
 	return (error) => {
 		const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
 		const reportableError = error && typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
@@ -87,7 +94,7 @@ function createRscOnErrorHandler(options) {
 				const route = options.requestInfo?.path ?? options.errorContext?.routePath ?? "<unknown>";
 				console.error(`[vinext] Error prerendering route ${JSON.stringify(route)}:`, reportableError);
 			}
-		} else if (nodeEnv !== "production" && !thrownHasDigest) console.error("[vinext] Server render error:", properError);
+		} else if (!(reportableError !== error && thrownHasDigest) && !wasLogged(reportableError)) console.error("[vinext] Server render error:", properError);
 		return digest;
 	};
 }

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

@@ -1,14 +1,13 @@
 import { VinextCacheabilityProbeMode } from "./multi-stage.js";
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { ImageConfig } from "./image-optimization.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
 import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
-import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
-import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
 import { PagesRouteDataKind } from "./pages-route-data-kind.js";
+import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
 import { TrustedPrerenderState } from "./prerender-route-params.js";
 import { AppRouteTreePrefetchRoute, PrefetchInliningConfig } from "./app-route-tree-prefetch.js";
 import { DispatchAppWorkerResponseStage, RenderAppWorkerResponseStageLocally } from "./app-worker-stages.js";
@@ -52,7 +51,6 @@ type AppRscRouteMatch<TRoute> = {
 type DispatchMatchedPageOptions<TRoute> = {
   bypassInterceptionContextCache: boolean;
   cachePathname: string;
-  clientReuseManifest: ClientReuseManifestParseResult;
   cleanPathname: string;
   displayPathname: string;
   formState: ReactFormState | null;
@@ -170,7 +168,7 @@ type RenderPagesFallbackOptions = {
       pattern: string;
     };
   } | null;
-  dispatchPagesResponseStage?: (request: Request, resourceKind: "api" | "page", dataKind?: PagesRouteDataKind, hasRequestAwareDocument?: boolean) => Promise<Response>;
+  dispatchPagesResponseStage?: (request: Request, resourceKind: "api" | "page", dataKind?: PagesRouteDataKind, hasRequestAwareDocument?: boolean, runsInitialProps?: boolean) => Promise<Response>;
   isDataRequest?: boolean;
   isRscRequest: boolean;
   initialResponseHeaders?: Headers;
@@ -179,6 +177,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;
 };
 type NavigationContextValue = {