vinext 1.0.1 → 1.1.0

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

@@ -21,11 +21,15 @@ export type AppPageCacheOutcomeMetric = Readonly<{
 type AppPageCacheOutcomeRecorder = (metric: AppPageCacheOutcomeMetric) => void;
 type AppPageCacheRenderResult = {
   cacheControl?: CacheControlMetadata;
+  /** Response headers stored with both entries, such as a redirect's `location`. */
+  headers?: Record<string, string>;
   html: string;
   htmlRenderObservation: RenderObservation;
   linkHeader?: string;
   rscData: ArrayBuffer;
   rscRenderObservation: RenderObservation;
+  /** The status of a render whose shell ended in a special error. */
+  status?: number;
   /**
    * The route-level revalidate of the route this render regenerated, or null
    * when it has none and the render's cacheLife sets it. Undefined keeps the
@@ -40,6 +44,7 @@ type BuildAppPageCachedResponseOptions = {
   cacheState: "HIT" | "STALE";
   expireSeconds?: number;
   isEdgeRuntime?: boolean;
+  isRoutePPREnabled?: boolean;
   isRscRequest: boolean;
   middlewareHeaders?: Headers | null;
   middlewareStatus?: number | null;

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

@@ -1,5 +1,5 @@
 import { VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
-import { VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
+import { VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER } from "./headers.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { decideIsr } from "./isr-decision.js";
 import { buildAppPageCacheValue, isrCacheControl, resolveRouteExpireSeconds } from "./isr-cache.js";
@@ -53,6 +53,10 @@ function buildAppPageCachedHeaders(options) {
 	if (options.params && Object.keys(options.params).length > 0) headers.set(VINEXT_PARAMS_HEADER, encodeURIComponent(JSON.stringify(options.params)));
 	if (options.mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
 	applyClientStaleTimeHeader(headers, options.staleTimeSeconds);
+	for (const [name, value] of Object.entries(options.storedHeaders ?? {})) {
+		if (name.toLowerCase() === "link") continue;
+		for (const item of Array.isArray(value) ? value : [value]) headers.append(name, item);
+	}
 	mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders ?? null);
 	if (options.linkHeader) {
 		if (Array.isArray(options.linkHeader)) for (const value of options.linkHeader) headers.append("Link", value);
@@ -88,8 +92,15 @@ function resolveRegenerationFailureCacheControl(previous) {
 		...previous.stale === void 0 ? {} : { stale: previous.stale }
 	};
 }
+function isRedirectStatus(status) {
+	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
 function buildAppPageCachedResponse(cachedValue, options) {
-	const status = options.middlewareStatus ?? (cachedValue.status || 200);
+	const storedStatus = cachedValue.status || 200;
+	const isRedirect = isRedirectStatus(storedStatus);
+	const isHttpErrorFallbackStatus = storedStatus === 401 || storedStatus === 403 || storedStatus === 404;
+	const replayStatus = options.isRscRequest && (isRedirect || options.isRoutePPREnabled === true) ? 200 : storedStatus;
+	const status = isRedirect || isHttpErrorFallbackStatus ? replayStatus : options.middlewareStatus ?? replayStatus;
 	const { cacheControl } = decideIsr({
 		cacheState: options.cacheState,
 		kind: "app-page",
@@ -108,17 +119,19 @@ function buildAppPageCachedResponse(cachedValue, options) {
 			middlewareHeaders: options.middlewareHeaders,
 			mountedSlotsHeader: options.mountedSlotsHeader,
 			params: options.params,
-			staleTimeSeconds
+			staleTimeSeconds,
+			storedHeaders: cachedValue.headers
 		});
 		if (options.renderedPathAndSearch) rscHeaders.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(options.renderedPathAndSearch));
 		applyRscCompatibilityIdHeader(rscHeaders);
 		applyRscDeploymentIdHeader(rscHeaders);
+		if (isHttpErrorFallbackStatus && status === storedStatus) rscHeaders.set(VINEXT_SPECIAL_ERROR_STATUS_HEADER, String(storedStatus));
 		return new Response(cachedValue.rscData, {
 			status,
 			headers: rscHeaders
 		});
 	}
-	if (typeof cachedValue.html !== "string" || cachedValue.html.length === 0) return null;
+	if (typeof cachedValue.html !== "string" || cachedValue.html.length === 0 && !isRedirect) return null;
 	const htmlHeaders = buildAppPageCachedHeaders({
 		cacheControl,
 		cacheState: options.cacheState,
@@ -126,7 +139,8 @@ function buildAppPageCachedResponse(cachedValue, options) {
 		isEdgeRuntime: options.isEdgeRuntime,
 		linkHeader: cachedValue.headers?.link,
 		middlewareHeaders: options.middlewareHeaders,
-		staleTimeSeconds
+		staleTimeSeconds,
+		storedHeaders: cachedValue.headers
 	});
 	const response = new Response(cachedValue.html, {
 		status,
@@ -218,6 +232,7 @@ async function readAppPageCacheResponse(options) {
 				cacheControl: cached?.value.cacheControl,
 				expireSeconds: options.expireSeconds,
 				isEdgeRuntime: options.isEdgeRuntime,
+				isRoutePPREnabled: options.isRoutePPREnabled,
 				isRscRequest: options.isRscRequest,
 				middlewareHeaders: options.middlewareHeaders,
 				middlewareStatus: options.middlewareStatus,
@@ -287,9 +302,13 @@ see more here https://nextjs.org/docs/messages/app-static-to-dynamic-error`);
 						return false;
 					}
 				};
-				if (!await store(rscKey, buildAppPageCacheValue("", revalidatedPage.rscData, 200, revalidatedPage.rscRenderObservation))) return;
+				const status = revalidatedPage.status ?? 200;
+				if (!await store(rscKey, buildAppPageCacheValue("", revalidatedPage.rscData, status, revalidatedPage.rscRenderObservation, revalidatedPage.headers))) return;
 				if (!options.isRscRequest) {
-					if (!await store(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, 200, revalidatedPage.htmlRenderObservation, revalidatedPage.linkHeader ? { link: revalidatedPage.linkHeader } : void 0))) return;
+					if (!await store(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, status, revalidatedPage.htmlRenderObservation, revalidatedPage.linkHeader ? {
+						...revalidatedPage.headers,
+						link: revalidatedPage.linkHeader
+					} : revalidatedPage.headers))) return;
 				}
 				options.isrDebug?.("regen complete", options.cleanPathname);
 			};
@@ -306,6 +325,7 @@ see more here https://nextjs.org/docs/messages/app-static-to-dynamic-error`);
 				cacheControl: cached.value.cacheControl,
 				expireSeconds: options.expireSeconds,
 				isEdgeRuntime: options.isEdgeRuntime,
+				isRoutePPREnabled: options.isRoutePPREnabled,
 				isRscRequest: options.isRscRequest,
 				middlewareHeaders: options.middlewareHeaders,
 				middlewareStatus: options.middlewareStatus,

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

@@ -142,6 +142,7 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
     observeMetadataSearchParamsAccess?: boolean;
     observePageSearchParamsAccess?: boolean;
     serveStreamingMetadata?: boolean;
+    placeStreamedMetadataInHead?: boolean;
   }) => Promise<AppPageElement>;
   clientReuseManifest?: ClientReuseManifestParseResult;
   cleanPathname: string;
@@ -221,13 +222,14 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   probeLayoutAt: (layoutIndex: number, layoutParamAccess?: AppLayoutParamAccessTracker) => unknown;
-  probePage: (searchParams?: URLSearchParams) => unknown;
   expireSeconds?: number;
   renderErrorBoundaryPage: (error: unknown, errorOrigin?: "rsc" | "ssr") => Promise<Response | null>;
   renderHttpAccessFallbackPage: (statusCode: number, opts: {
     boundaryComponent?: unknown;
     boundaryModule?: AppPageModule | null;
     intercept?: AppPageDispatchInterceptOptions | null;
+    /** The document may be stored, so it must not carry the request's query. */
+    isCacheCandidate?: boolean;
     layouts?: readonly AppPageModule[];
     matchedParams: AppPageParams;
   }, middlewareContext: AppPageMiddlewareContext | null) => Promise<Response | null>;
@@ -268,6 +270,12 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
     searchParams: URLSearchParams;
   }) => void;
   renderMode?: AppRscRenderMode;
+  /**
+   * Render the document whole before its first byte, with streamed metadata in
+   * `<head>`, as a background regeneration does. The adapter sets this for a
+   * render no client is waiting on, such as its regeneration or a warm-up.
+   */
+  renderWholeDocument?: boolean;
 };
 export declare function shouldReadAppPageCache(options: {
   isProgressiveActionRender: boolean;

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

@@ -5,27 +5,28 @@ import { VINEXT_INTERCEPTION_ID_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc
 import "./headers.js";
 import { beginRouteCacheability, isRouteCacheabilityIdentityProbe, isRouteCacheabilityProbe, markRouteCacheabilityPatternDynamic, readRouteCacheabilityState } from "../shims/cacheability-classification.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL } from "./app-rsc-render-mode.js";
-import { AppElementsWire } from "./app-elements-wire.js";
-import "./app-elements.js";
 import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersContext, isDraftModeRequest, peekDynamicUsage, peekRenderRequestApiUsage, runWithIsolatedDynamicUsage, setHeadersContext } from "../shims/headers.js";
 import { _captureRequestScopedCacheLifeAccessors } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground } from "../shims/fetch-cache.js";
 import { cacheabilityManifestPageState } from "./cacheability-manifest.js";
+import { isAppPageStaticEligible } from "./app-segment-config.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { getFrameworkLinkHeader } from "./app-response-header-provenance.js";
 import { resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildRscRedirectFlightStream } from "./app-rsc-redirect-flight.js";
-import { buildAppPageSpecialErrorResponse, probeAppPageThrownError, resolveAppPageSpecialError } from "./app-page-execution.js";
+import { buildAppPageSpecialErrorResponse, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
 import { resolveAppPageTraceOperation } from "./app-page-tracing.js";
 import { createAppPageTreePath } from "./app-page-route-wiring.js";
 import { traceResponseStart } from "./response-start-tracing.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
-import { isAppPageStaticEligible } from "./app-segment-config.js";
+import { createAppPageRscErrorTracker } from "./app-page-stream.js";
 import { resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule } from "./app-page-boundary.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
-import { createAppPageRscErrorTracker } from "./app-page-stream.js";
 import { createAppLayoutParamAccessTracker, isAppLayoutObservationUnsafeForStaticReuse } from "./app-layout-param-observation.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
 import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
@@ -255,7 +256,6 @@ async function dispatchAppPageInner(options) {
 	const pageSearchParams = shouldUseEmptySearchParams ? new URLSearchParams() : options.searchParams;
 	const layoutParamAccess = createAppLayoutParamAccessTracker();
 	const activeLoadingTreePositions = getActiveLoadingTreePositions(route);
-	const hasActiveLoadingBoundary = activeLoadingTreePositions.length > 0;
 	setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], route.routeSegments));
 	setCurrentFetchCacheMode(options.fetchCache ?? null);
 	setCurrentFetchRevalidate(currentRevalidateSeconds);
@@ -396,14 +396,16 @@ async function dispatchAppPageInner(options) {
 						isForceStatic: revalidationDynamicConfig === "force-static",
 						observeMetadataSearchParamsAccess: revalidationDynamicConfig !== "force-static",
 						observePageSearchParamsAccess: revalidationDynamicConfig !== "force-static",
-						serveStreamingMetadata: false
+						serveStreamingMetadata: placeGeneratedMetadataInBody,
+						placeStreamedMetadataInHead: true
 					});
 					const baseRevalidatedOnError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern, { revalidateReason: "stale" });
 					const baseRevalidatedOnSsrError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern, {
 						renderSource: "server-rendering",
 						revalidateReason: "stale"
 					});
-					revalidationRscErrorTracker = createAppPageRscErrorTracker(baseRevalidatedOnError);
+					const rscErrorTracker = createAppPageRscErrorTracker(baseRevalidatedOnError);
+					revalidationRscErrorTracker = rscErrorTracker;
 					const rendered = await renderAppPageCacheArtifacts({
 						basePath: options.basePath,
 						captureRscData: true,
@@ -416,14 +418,36 @@ async function dispatchAppPageInner(options) {
 						getNavigationContext: options.getNavigationContext,
 						loadSsrHandler: options.loadSsrHandler,
 						mountedSlotsHeader: options.mountedSlotsHeader,
+						mirrorNextFlight: () => rscErrorTracker.getCapturedSpecialError() !== null,
 						navigationParams: revalidationTarget.navigationParams,
-						isCapturedRscError: revalidationRscErrorTracker.isCapturedError,
-						onError: revalidationRscErrorTracker.onRenderError,
+						isCapturedRscError: rscErrorTracker.isCapturedError,
+						onError: rscErrorTracker.onRenderError,
 						onSsrError(error) {
 							reportedSsrRevalidationErrors.add(error);
 							return baseRevalidatedOnSsrError(error, void 0, void 0);
 						},
 						reactMaxHeadersLength: options.reactMaxHeadersLength,
+						async renderShellSpecialError(error) {
+							const specialError = resolveAppPageShellSpecialError(error, rscErrorTracker.getCapturedSpecialErrors(error));
+							if (!specialError) return null;
+							if (options.isRscRequest) {
+								if (specialError.fromMetadata === true) return null;
+								return {
+									headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath),
+									html: "",
+									status: specialError.statusCode
+								};
+							}
+							if (revalidationTarget.route !== route) return null;
+							const document = await renderPageSpecialError(options, specialError, false, revalidationTarget.interceptOpts, true);
+							if (document.status !== specialError.statusCode) return null;
+							return {
+								headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath),
+								html: await document.text(),
+								linkHeader: getFrameworkLinkHeader(document.headers) ?? void 0,
+								status: specialError.statusCode
+							};
+						},
 						renderToReadableStream: options.renderToReadableStream,
 						rootParams: options.rootParams,
 						route: revalidationTarget.route,
@@ -432,6 +456,7 @@ async function dispatchAppPageInner(options) {
 					});
 					options.clearRequestContext();
 					return {
+						headers: rendered.headers,
 						html: rendered.html,
 						htmlRenderObservation: rendered.htmlRenderObservation,
 						linkHeader: rendered.linkHeader,
@@ -440,6 +465,7 @@ async function dispatchAppPageInner(options) {
 						tags: rendered.tags,
 						cacheControl: rendered.cacheControl,
 						revalidateSeconds: revalidationRouteRevalidateSeconds,
+						status: rendered.status,
 						usedDynamicApi: rendered.usedDynamicApi
 					};
 				});
@@ -465,6 +491,7 @@ async function dispatchAppPageInner(options) {
 		if (dynamicParamsResponse) {
 			const renderedNotFound = await options.renderHttpAccessFallbackPage(404, { matchedParams: options.params }, options.middlewareContext);
 			const cachePolicy = {
+				dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 				isDraftMode,
 				isDynamicError,
 				isForceDynamic,
@@ -510,7 +537,8 @@ async function dispatchAppPageInner(options) {
 				isForceStatic: sourceDynamicConfig === "force-static",
 				observeMetadataSearchParamsAccess: sourceDynamicConfig !== "force-static",
 				observePageSearchParamsAccess: sourceDynamicConfig !== "force-static",
-				serveStreamingMetadata: placeGeneratedMetadataInBody
+				serveStreamingMetadata: placeGeneratedMetadataInBody,
+				placeStreamedMetadataInHead: options.renderWholeDocument === true
 			});
 		},
 		cleanPathname: options.cleanPathname,
@@ -565,19 +593,10 @@ async function dispatchAppPageInner(options) {
 				isForceStatic,
 				observeMetadataSearchParamsAccess: !isForceStatic,
 				observePageSearchParamsAccess: !isForceStatic,
-				serveStreamingMetadata: placeGeneratedMetadataInBody
+				serveStreamingMetadata: placeGeneratedMetadataInBody,
+				placeStreamedMetadataInHead: options.renderWholeDocument === true
 			});
 		},
-		async probePageSpecialError() {
-			if (hasActiveLoadingBoundary) return null;
-			const pageError = await probeAppPageThrownError({
-				probePage: () => options.probePage(pageSearchParams),
-				runWithSuppressedHookWarning(probe) {
-					return options.runWithSuppressedHookWarning(probe);
-				}
-			});
-			return resolveAppPageSpecialError(pageError);
-		},
 		renderErrorBoundaryPage(buildError) {
 			return options.renderErrorBoundaryPage(buildError);
 		},
@@ -645,7 +664,6 @@ async function dispatchAppPageInner(options) {
 			return requestCacheLife.peek();
 		},
 		handlerStart: options.handlerStart,
-		hasLoadingBoundary: hasActiveLoadingBoundary,
 		omitPendingDynamicCacheState: hasRequestSearchParams && !(isCacheCandidate && !options.isRscRequest),
 		formState: options.formState ?? null,
 		isProgressiveActionRender: options.isProgressiveActionRender === true,
@@ -657,7 +675,9 @@ async function dispatchAppPageInner(options) {
 		isStaticEligible,
 		isCacheCandidate,
 		isPrerender,
+		isRoutePPREnabled: options.pprRuntime !== void 0,
 		isSpeculativePrerender,
+		renderWholeDocument: options.renderWholeDocument === true && !options.isRscRequest,
 		isProduction: options.isProduction,
 		isRscRequest: options.isRscRequest,
 		traceOperation,
@@ -690,10 +710,6 @@ async function dispatchAppPageInner(options) {
 		probeLayoutAt(layoutIndex) {
 			return options.probeLayoutAt(layoutIndex, layoutParamAccess);
 		},
-		probePage() {
-			return options.probePage(pageSearchParams);
-		},
-		probePageBeforeRender: options.isRscRequest,
 		classification: {
 			getLayoutId(index) {
 				const treePosition = route.layoutTreePositions?.[index] ?? 0;
@@ -719,8 +735,8 @@ async function dispatchAppPageInner(options) {
 		renderLayoutSpecialError(specialError, layoutIndex) {
 			return renderLayoutSpecialError(options, specialError, layoutIndex, serveStreamingMetadata);
 		},
-		renderPageSpecialError(specialError) {
-			return renderPageSpecialError(options, specialError, serveStreamingMetadata, interceptResult.interceptOpts);
+		renderPageSpecialError(specialError, renderOptions) {
+			return renderPageSpecialError(options, specialError, serveStreamingMetadata, interceptResult.interceptOpts, renderOptions?.isCacheCandidate === true);
 		},
 		renderToReadableStream: options.renderToReadableStream,
 		hasCustomGlobalError: options.hasCustomGlobalError,
@@ -773,7 +789,7 @@ async function renderLayoutSpecialError(options, specialError, layoutIndex, serv
 		specialError
 	});
 }
-async function renderPageSpecialError(options, specialError, serveStreamingMetadata, intercept) {
+async function renderPageSpecialError(options, specialError, serveStreamingMetadata, intercept, isCacheCandidate = false) {
 	return buildAppPageSpecialErrorResponse({
 		basePath: options.basePath,
 		buildRscRedirectFlightStream: (rscOptions) => buildRscRedirectFlightStream({
@@ -802,6 +818,7 @@ async function renderPageSpecialError(options, specialError, serveStreamingMetad
 			const useLayoutAlignedBoundary = boundaryLayoutIndex !== null && (routeBoundaryModule === null || routeBoundaryModule === parentBoundaryModule);
 			const fallbackOptions = {
 				intercept,
+				...isCacheCandidate ? { isCacheCandidate } : {},
 				matchedParams: options.params
 			};
 			if (useLayoutAlignedBoundary && boundaryLayoutIndex !== null) {

package/dist/server/app-page-element-builder.d.ts

@@ -61,6 +61,13 @@ export type AppPagePageRequest<TModule extends AppPageModule = AppPageModule> =
   observeMetadataSearchParamsAccess?: boolean;
   /** Whether generated metadata may stream into the response body. */
   serveStreamingMetadata?: boolean;
+  /**
+   * Wait for streamed metadata in `<head>`, for a document rendered whole
+   * before it's written, such as a background regeneration. Next.js does this
+   * for every static or ISR render. Its errors still reach the route's
+   * boundaries through the outlet.
+   */
+  placeStreamedMetadataInHead?: boolean;
   /** Whether streamed render errors must be sanitized for client transport. */
   isProduction?: boolean;
 };

package/dist/server/app-page-element-builder.js

@@ -1,27 +1,27 @@
 import { isPromiseLike } from "../utils/promise.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
 import { createAppPageRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, renderAfterAppDependencies } from "./app-render-dependency.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
-import { matchRoutePattern } from "../routing/route-pattern.js";
+import { withUseCacheLayoutMarker, withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
-import { withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
-import { prepareAppPageHead, resolveActiveParallelRouteHeadInputs } from "./app-page-head.js";
-import { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
 import { sanitizeErrorForClient } from "./app-rsc-errors.js";
 import { resolveAppPageModuleTraceSegment, traceCreateComponentTree, traceGetLayoutOrPageModule } from "./app-page-tracing.js";
 import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath, resolveAppPageLoadingModuleAtOrAbove } from "./app-page-route-wiring.js";
+import { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs } from "./app-page-head.js";
 import { resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport } from "./app-page-http-access-fallback-metadata.js";
 import { ClientPageRoot } from "../shims/client-page-root.js";
 import "./app-rsc-route-matching.js";
 import { resolveAppPageParentHttpAccessBoundary } from "./app-page-boundary.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
+import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
+import { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
-import { Suspense, createElement } from "react";
+import { Suspense, cache, createElement } from "react";
 //#region src/server/app-page-element-builder.ts
 function resolveInterceptLayoutParams(branchSegments, layoutSegments, params) {
 	return resolveAppPageBranchParams(branchSegments, layoutSegments.length, params, layoutSegments);
@@ -60,7 +60,7 @@ function traceAppPageInterceptLayoutModules(modules, branchSegments, layoutSegme
 async function buildPageElements(options) {
 	const { route, params, routePath, displayPathname = routePath, pageRequest, globalErrorModule, rootNotFoundModule, rootForbiddenModule, rootUnauthorizedModule, metadataRoutes } = options;
 	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
-	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, serveStreamingMetadata, isProduction = process.env.NODE_ENV === "production" } = pageRequest;
+	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production" } = pageRequest;
 	const pageModule = route.page;
 	const isSiblingIntercept = opts?.interceptSlotKey === "__vinext_page_intercept" && !!opts?.interceptPage;
 	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
@@ -140,7 +140,7 @@ async function buildPageElements(options) {
 	} : null;
 	const parallelRoutes = [...primaryParallelRouteHeadInput ? [primaryParallelRouteHeadInput.head] : [], ...activeParallelRouteHeadInputs.map((input) => input.head)];
 	const metadataSearchParamsObserver = observeMetadataSearchParamsAccess ? createAppPageSearchParamsObserver() : void 0;
-	const preparedHead = prepareAppPageHead({
+	const headOptions = {
 		applyFileBasedMetadata: options.applyFileBasedMetadata,
 		basePath: options.basePath ?? "",
 		layoutModules: route.layouts,
@@ -153,15 +153,11 @@ async function buildPageElements(options) {
 		routeSegments: route.routeSegments ?? null,
 		searchParams,
 		searchParamsObserver: metadataSearchParamsObserver
-	});
-	const { hasDynamicMetadata, pageSearchParams } = preparedHead;
+	};
+	const hasDynamicMetadata = hasAppPageDynamicMetadata(headOptions);
+	const { pageSearchParams } = collectAppPageSearchParams(searchParams);
 	const streamGeneratedHead = serveStreamingMetadata ?? shouldServeStreamingMetadata(pageRequest.request.headers.get("user-agent") ?? "", options.htmlLimitedBots);
-	const metadataPlacement = hasDynamicMetadata && streamGeneratedHead ? "body" : "head";
-	const shouldDeferMetadata = metadataPlacement === "body";
-	const streamingMetadata = shouldDeferMetadata ? isProduction ? preparedHead.metadata.catch((error) => {
-		throw sanitizeErrorForClient(error, "production");
-	}) : preparedHead.metadata : null;
-	streamingMetadata?.catch(() => null);
+	const metadataPlacement = hasDynamicMetadata && streamGeneratedHead && !placeStreamedMetadataInHead ? "body" : "head";
 	const resolveNotFoundFallbackPlanOptions = () => {
 		const routeBoundaryModule = route.notFound;
 		const parentBoundary = resolveAppPageParentHttpAccessBoundary({
@@ -189,8 +185,6 @@ async function buildPageElements(options) {
 			routeSegments: route.routeSegments ?? null
 		};
 	};
-	let viewportErrorOutlet = null;
-	let metadataErrorOutlet = null;
 	const resolveMetadataErrorTags = async (error) => {
 		if (resolveAppPageSpecialError(error)?.kind !== "http-access-fallback") return null;
 		return resolveHttpAccessFallbackMetadata({
@@ -201,24 +195,19 @@ async function buildPageElements(options) {
 			routePath: route.pattern
 		}).catch(() => null);
 	};
-	const [resolvedMetadata, resolvedViewport] = await Promise.all([shouldDeferMetadata ? Promise.resolve(null) : preparedHead.metadata.catch((error) => {
-		metadataErrorOutlet = Promise.reject(isProduction ? sanitizeErrorForClient(error, "production") : error);
-		metadataErrorOutlet.catch(() => null);
-		return resolveMetadataErrorTags(error);
-	}), preparedHead.viewport.catch(async (error) => {
-		const specialError = resolveAppPageSpecialError(error);
-		viewportErrorOutlet = Promise.reject(isProduction ? sanitizeErrorForClient(error, "production") : error);
-		viewportErrorOutlet.catch(() => null);
-		return specialError?.kind === "http-access-fallback" ? resolveHttpAccessFallbackViewport(resolveNotFoundFallbackPlanOptions()).catch(() => ({})) : {};
-	})]);
-	const streamingMetadataTags = shouldDeferMetadata ? preparedHead.metadata.catch(resolveMetadataErrorTags) : null;
-	const streamingMetadataOutletInputs = [
-		streamingMetadata,
-		metadataErrorOutlet,
-		viewportErrorOutlet
-	].filter((promise) => promise !== null).map((promise) => Promise.resolve(promise));
-	const streamingMetadataOutlet = streamingMetadataOutletInputs.length > 0 ? Promise.all(streamingMetadataOutletInputs).then(() => null) : null;
-	streamingMetadataOutlet?.catch(() => null);
+	const toClientError = (error) => isProduction ? sanitizeErrorForClient(error, "production") : error;
+	const resolveHead = cache(() => {
+		const preparedHead = prepareAppPageHead(headOptions);
+		const outlet = Promise.all([preparedHead.metadata, preparedHead.viewport]).then(() => null, (error) => {
+			throw toClientError(error);
+		});
+		outlet.catch(() => null);
+		return {
+			metadata: preparedHead.metadata.catch(resolveMetadataErrorTags),
+			outlet,
+			viewport: preparedHead.viewport.catch((error) => resolveAppPageSpecialError(error)?.kind === "http-access-fallback" ? resolveHttpAccessFallbackViewport(resolveNotFoundFallbackPlanOptions()).catch(() => ({})) : {})
+		};
+	});
 	const pageProps = { params: makeThenableParams(effectiveParams) };
 	const pageTreePosition = (sourcePageSegments ?? route.routeSegments ?? []).length;
 	const hasPageLoadingBoundary = resolveAppPageLoadingModuleAtOrAbove(route, pageTreePosition) !== null || isSiblingIntercept && resolveAppPageLoadingModuleAtOrAbove({
@@ -299,7 +288,7 @@ async function buildPageElements(options) {
 				const LayoutComponent = traceGetLayoutOrPageModule(resolveInterceptLayoutTraceSegment(opts?.interceptBranchSegments, interceptLayoutSegments), () => layoutModule.default);
 				if (!LayoutComponent) continue;
 				const interceptLayoutParams = resolveInterceptLayoutParams(opts?.interceptBranchSegments ?? interceptLayoutSegments, interceptLayoutSegments, effectiveParams);
-				element = createElement(LayoutComponent, { params: makeThenableParams(interceptLayoutParams) }, element);
+				element = createElement(LayoutComponent, withUseCacheLayoutMarker(LayoutComponent, { params: makeThenableParams(interceptLayoutParams) }), element);
 			}
 		}
 		return element;
@@ -319,14 +308,10 @@ async function buildPageElements(options) {
 			matchedParams: params,
 			pageRenderDependency,
 			metadataPlacement,
-			resolvedMetadata,
+			resolveHead,
 			resolvedMetadataPathname: routePath,
-			resolvedViewport,
 			scriptNonce: options.scriptNonce,
-			streamingMetadata,
-			streamingMetadataOutlet,
 			streamingMetadataOutletSuspended: streamGeneratedHead,
-			streamingMetadataTags,
 			renderIdentity,
 			routePath,
 			semanticPageIdentity,

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

@@ -123,22 +123,25 @@ type ProbeAppPageLayoutsOptions = {
   /** When provided, enables per-layout static/dynamic classification. */
   classification?: LayoutClassificationOptions | null;
 };
-type ProbeAppPageComponentOptions = {
-  awaitAsyncResult: boolean;
-  onError: (error: unknown) => Promise<Response | null>;
-  probePage: () => unknown;
-  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
-};
-type ProbeAppPageThrownErrorOptions = {
-  probePage: () => unknown;
-  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
-};
 export declare function resolveAppPageSpecialError(error: unknown): AppPageSpecialError | null;
+/**
+ * Resolve the special error that rejected an SSR shell. An error from the RSC
+ * render reaches the shell decoded from its Flight digest, so whether
+ * generateMetadata() threw it comes from the errors the RSC render threw with
+ * that digest. When the page threw one too, the page's decides. An error a
+ * client component threw during SSR is the page's, since generateMetadata()
+ * runs only in the RSC render.
+ */
+export declare function resolveAppPageShellSpecialError(error: unknown, renderedSpecialErrors: readonly unknown[]): AppPageSpecialError | null;
+/**
+ * The response headers stored with a page's special-error entries: a
+ * redirect's own `location`, not the response's, which middleware may have
+ * replaced for this request.
+ */
+export declare function resolveAppPageSpecialErrorStoredHeaders(specialError: AppPageSpecialError, basePath: string | undefined): Record<string, string> | undefined;
 export declare function buildAppPageSpecialErrorResponse(options: BuildAppPageSpecialErrorResponseOptions): Promise<Response>;
 /** See `LayoutFlags` type docblock in app-elements.ts for lifecycle. */
 export declare function probeAppPageLayouts(options: ProbeAppPageLayoutsOptions): Promise<ProbeAppPageLayoutsResult>;
-export declare function probeAppPageComponent(options: ProbeAppPageComponentOptions): Promise<Response | null>;
-export declare function probeAppPageThrownError(options: ProbeAppPageThrownErrorOptions): Promise<unknown>;
 export declare function readAppPageBinaryStream(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
 export declare function bufferAppPageBinaryStream(stream: ReadableStream<Uint8Array>): Promise<ReadableStream<Uint8Array>>;
 export declare function teeAppPageRscStreamForCapture(stream: ReadableStream<Uint8Array>, shouldCapture: boolean): AppPageRscStreamCapture;