vinext 1.3.1 → 1.4.0

package/dist/server/app-page-route-wiring.d.ts

@@ -3,9 +3,7 @@ import { AppElements, AppElementsInterception, AppElementsSlotBinding } from "./
 import "./app-elements.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageParams } from "./app-page-boundary.js";
-import { ThenableParamsObserver } from "../shims/thenable-params.js";
 import { Metadata, Viewport } from "../shims/metadata.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppPageRenderDependency } from "./app-render-dependency.js";
 import { AppPageSemanticSegment, resolveAppPageChildSegments } from "./app-page-segment-state.js";
 import { AppPageRenderIdentity } from "./app-page-render-identity.js";
@@ -172,7 +170,6 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
    */
   renderElementWithMetadataOutlet?: ((metadataOutlet: ReactNode) => ReactNode) | null;
   globalErrorModule?: TErrorModule | null;
-  layoutParamAccess?: AppLayoutParamAccessTracker;
   makeThenableParams: MakeThenableParams;
   matchedParams: AppPageParams;
   metadataPlacement?: "body" | "head";
@@ -211,7 +208,7 @@ export type AppPageRouteHead = {
   /** `null` when resolution failed: like Next.js, the head then has no viewport tags. */
   viewport: Promise<Viewport | null>;
 };
-type MakeThenableParams = (params: AppPageParams, observer?: ThenableParamsObserver) => unknown;
+type MakeThenableParams = (params: AppPageParams) => unknown;
 type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule> = BuildAppPageRouteElementOptions<TModule, TErrorModule> & {
   interception?: AppElementsInterception | null;
   interceptionId?: string | null;
@@ -226,6 +223,13 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
    * still store the route tree, as a CDN would store Next.js's.
    */
   isUncacheableRender?: boolean;
+  /**
+   * Hashed segment identities of the layouts the navigating client holds (see
+   * app-mounted-layouts.ts). A render that can never be stored leaves out the
+   * outermost layouts it names, as Next.js renders only below where a
+   * navigation diverges from the client's router state.
+   */
+  mountedLayouts?: ReadonlySet<string> | null;
   mountedSlotIds?: ReadonlySet<string> | null;
   renderIdentity?: AppPageRenderIdentity;
   renderMode?: AppRscRenderMode;
@@ -246,9 +250,12 @@ export type AppPageTemplateEntry<TModule extends AppPageModule = AppPageModule>
   treePosition: number;
 };
 export declare function createAppPageTreePath(routeSegments: readonly string[] | null | undefined, treePosition: number): string;
-export declare function probeAppPageLayoutWithTracking<TModule extends AppPageModule>(options: {
+/**
+ * Renders the layout at `layoutIndex` with a placeholder for its children, so
+ * whatever it or a component it renders throws comes out.
+ */
+export declare function probeAppPageLayout<TModule extends AppPageModule>(options: {
   layoutIndex: number;
-  layoutParamAccess: AppLayoutParamAccessTracker | undefined;
   makeThenableParams: MakeThenableParams;
   matchedParams: AppPageParams;
   route: Pick<AppPageRouteWiringRoute<TModule>, "layoutTreePositions" | "layouts" | "routeSegments">;

package/dist/server/app-page-route-wiring.js

@@ -1,24 +1,26 @@
 import { APP_RSC_RENDER_MODE_PREFETCH_EMPTY, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "./app-rsc-render-mode.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { createInlineScriptTag, escapeHtmlAttr } from "./html.js";
-import { createAppRenderDependency, invokeAppComponentMappingErrors, isReactOwnedAppComponent, registerAppElementRenderDependencies, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier } from "./app-render-dependency.js";
-import { APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
+import { APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY, APP_STREAMING_METADATA_BODY_ID_PREFIX } from "./app-elements.js";
+import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
+import { hashMountedLayoutIdentity } from "./app-mounted-layouts.js";
+import { BfcacheChildrenBoundary, BfcacheSegmentBoundary, Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
+import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPageChildSegments, resolveAppPageSegmentStateKey, resolveAppPageTemplateStateKey } from "./app-page-segment-state.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { ErrorBoundary, ForbiddenBoundary, GlobalErrorBoundary, HttpAccessFallbackPassthrough, NotFoundBoundary, RedirectBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
-import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
-import DefaultForbidden from "../shims/default-forbidden.js";
-import DefaultNotFound from "../shims/default-not-found.js";
-import DefaultUnauthorized from "../shims/default-unauthorized.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { withUseCacheLayoutMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { MetadataHead, ViewportHead, renderMetadataToHtml } from "../shims/metadata.js";
-import { BfcacheSegmentBoundary, Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
+import { APP_PAGE_NOT_FOUND_BOUNDARY_ID, tagAppPageLayoutError, tagAppPageSlotError } from "./app-page-execution.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
+import DefaultForbidden from "../shims/default-forbidden.js";
+import DefaultNotFound from "../shims/default-not-found.js";
+import DefaultUnauthorized from "../shims/default-unauthorized.js";
 import { StreamedIconsInsertion } from "../shims/streamed-icons.js";
-import { APP_PAGE_NOT_FOUND_BOUNDARY_ID, tagAppPageSlotError } from "./app-page-execution.js";
-import { resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { createAppRenderDependency, invokeAppComponentMappingErrors, isReactOwnedAppComponent, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier } from "./app-render-dependency.js";
+import { createAppPageLayoutGate, registerAppPageLayoutGate } from "./app-page-layout-gate.js";
 import { probeReactServerSubtree } from "./app-page-probe.js";
-import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPageChildSegments, resolveAppPageSegmentStateKey, resolveAppPageTemplateStateKey } from "./app-page-segment-state.js";
 import { createAppPageSegmentPlan } from "./app-page-segment-plan.js";
 import { resolveAppPageModuleTraceSegment, traceGetLayoutOrPageModule } from "./app-page-tracing.js";
 import { Fragment, Suspense } from "react";
@@ -44,6 +46,21 @@ function createSlotLayoutElement(LayoutComponent, props, slotLayoutIndex, notFou
 	const SlotLayoutInvoker = () => invokeAppComponentMappingErrors(LayoutComponent, props, (error) => tagAppPageSlotError(error, slotLayoutIndex, notFoundBoundary));
 	return /* @__PURE__ */ jsx(SlotLayoutInvoker, {});
 }
+/**
+* A route layout, whose notFound(), forbidden() and unauthorized() are caught
+* above it: its own boundaries wrap only its `children`. The layout's index
+* tags what it throws, so the response's fallback finds that boundary from the
+* render. `onSettled` hears how the layout rendered.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/create-component-tree.tsx
+*/
+function createRouteLayoutElement(LayoutComponent, props, layoutIndex, dependency, onSettled) {
+	const mapError = (error) => tagAppPageLayoutError(error, layoutIndex);
+	if (dependency) return renderAppComponentWithDependencyBarrier(LayoutComponent, props, dependency, mapError, onSettled);
+	if (isReactOwnedAppComponent(LayoutComponent)) return /* @__PURE__ */ jsx(LayoutComponent, { ...props });
+	const RouteLayoutInvoker = () => invokeAppComponentMappingErrors(LayoutComponent, props, mapError, onSettled);
+	RouteLayoutInvoker.displayName = LayoutComponent.displayName ?? LayoutComponent.name;
+	return /* @__PURE__ */ jsx(RouteLayoutInvoker, {});
+}
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -55,37 +72,19 @@ function createAppPageTreePath(routeSegments, treePosition) {
 	if (treePathSegments.length === 0) return "/";
 	return `/${treePathSegments.join("/")}`;
 }
-function readFiniteRevalidateSeconds(module) {
-	const revalidate = module?.revalidate;
-	return typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0 ? revalidate : null;
-}
-function recordLayoutSkipObservationScope(options) {
-	options.layoutParamAccess?.recordLayoutParamScope(options.layoutId, resolveAppPageSegmentParamScopeKeys(options.routeSegments, options.treePosition));
-	const revalidateSeconds = readFiniteRevalidateSeconds(options.layoutModule);
-	if (revalidateSeconds !== null) options.layoutParamAccess?.recordLayoutFiniteRevalidate(options.layoutId, revalidateSeconds);
-}
-function probeAppPageLayoutWithTracking(options) {
+/**
+* Renders the layout at `layoutIndex` with a placeholder for its children, so
+* whatever it or a component it renders throws comes out.
+*/
+function probeAppPageLayout(options) {
 	const treePosition = options.route.layoutTreePositions?.[options.layoutIndex] ?? 0;
-	const treePath = createAppPageTreePath(options.route.routeSegments, treePosition);
-	const layoutId = AppElementsWire.encodeLayoutId(treePath);
-	const probe = () => {
-		const layoutModule = options.route.layouts[options.layoutIndex];
-		const LayoutComponent = getDefaultExport(layoutModule);
-		if (!LayoutComponent) return null;
-		recordLayoutSkipObservationScope({
-			layoutId,
-			layoutModule,
-			layoutParamAccess: options.layoutParamAccess,
-			routeSegments: options.route.routeSegments,
-			treePosition
-		});
-		const layoutParams = resolveAppPageSegmentParams(options.route.routeSegments, treePosition, options.matchedParams);
-		return probeReactServerSubtree(/* @__PURE__ */ jsx(LayoutComponent, {
-			...withUseCacheLayoutMarker(LayoutComponent, { params: options.makeThenableParams(layoutParams, options.layoutParamAccess?.createThenableParamsObserver(layoutId)) }),
-			children: APP_PAGE_LAYOUT_PROBE_CHILD
-		}));
-	};
-	return options.layoutParamAccess ? options.layoutParamAccess.runLayoutProbe(layoutId, probe) : probe();
+	const LayoutComponent = getDefaultExport(options.route.layouts[options.layoutIndex]);
+	if (!LayoutComponent) return null;
+	const layoutParams = resolveAppPageSegmentParams(options.route.routeSegments, treePosition, options.matchedParams);
+	return probeReactServerSubtree(/* @__PURE__ */ jsx(LayoutComponent, {
+		...withUseCacheLayoutMarker(LayoutComponent, { params: options.makeThenableParams(layoutParams) }),
+		children: APP_PAGE_LAYOUT_PROBE_CHILD
+	}));
 }
 function createAppPageLayoutEntries(route) {
 	return route.layouts.map((layoutModule, index) => {
@@ -426,8 +425,8 @@ function buildAppPageElements(options) {
 	const notFoundBoundaries = resolveAccessBoundaries(options.route.segmentNotFounds, options.route.segmentNotFoundTreePositions, (entry) => entry.notFoundModule, rootNotFoundModule ? null : DEFAULT_NOT_FOUND_COMPONENT);
 	const forbiddenBoundaries = resolveAccessBoundaries(options.route.segmentForbiddens, options.route.segmentForbiddenTreePositions, (entry) => entry.forbiddenModule, rootForbiddenModule ? null : DEFAULT_FORBIDDEN_COMPONENT);
 	const unauthorizedBoundaries = resolveAccessBoundaries(options.route.segmentUnauthorizeds, options.route.segmentUnauthorizedTreePositions, (entry) => entry.unauthorizedModule, rootUnauthorizedModule ? null : DEFAULT_UNAUTHORIZED_COMPONENT);
+	const layoutGate = createAppPageLayoutGate();
 	const layoutDependenciesByIndex = /* @__PURE__ */ new Map();
-	const renderDependenciesByElementId = /* @__PURE__ */ new Map();
 	const layoutDependenciesBefore = [];
 	const slotDependenciesByLayoutIndex = [];
 	const templateDependenciesById = /* @__PURE__ */ new Map();
@@ -488,6 +487,13 @@ function buildAppPageElements(options) {
 		templateEntries
 	});
 	const routeResetKey = segmentPlan.routeResetKey;
+	const skippedLayoutIds = /* @__PURE__ */ new Set();
+	if (options.mountedLayouts && options.isRscRequest === true && options.isUncacheableRender === true && renderMode === "navigation" && interception === null) for (const layoutEntry of layoutEntries) {
+		const identity = segmentPlan.bfcacheSegmentIdentities[layoutEntry.id];
+		if (identity === void 0) break;
+		if (!options.mountedLayouts.has(hashMountedLayoutIdentity(identity))) break;
+		skippedLayoutIds.add(layoutEntry.id);
+	}
 	const slotPlansByKey = new Map(segmentPlan.slots.map((slot) => [slot.key, slot]));
 	const resolveRouteSegmentResetKey = (treePosition) => resolveAppPageSegmentStateKey(routeSegments, treePosition, options.matchedParams);
 	const metadataEntries = AppElementsWire.createMetadataEntries({
@@ -530,10 +536,9 @@ function buildAppPageElements(options) {
 		if (layoutIndex !== void 0) {
 			const layoutEntry = layoutEntries[layoutIndex];
 			layoutDependenciesBefore[layoutIndex] = [...pageDependencies];
-			if (getDefaultExport(layoutEntry.layoutModule)) {
+			if (!skippedLayoutIds.has(layoutEntry.id) && getDefaultExport(layoutEntry.layoutModule)) {
 				const layoutDependency = createAppRenderDependency();
 				layoutDependenciesByIndex.set(layoutIndex, layoutDependency);
-				renderDependenciesByElementId.set(layoutEntry.id, layoutDependency);
 				pageDependencies.push(layoutDependency);
 			}
 			slotDependenciesByLayoutIndex[layoutIndex] = [...pageDependencies];
@@ -581,33 +586,29 @@ function buildAppPageElements(options) {
 	for (let index = 0; index < layoutEntries.length; index++) {
 		const layoutEntry = layoutEntries[index];
 		if (isPrefetchLoadingShell && !includesPrefetchTreePosition(layoutEntry.treePosition)) continue;
+		if (skippedLayoutIds.has(layoutEntry.id)) continue;
 		if (!layoutEntry.layoutModule) continue;
 		const layoutComponent = traceGetLayoutOrPageModule(resolveAppPageModuleTraceSegment(routeSegments, layoutEntry.treePosition), () => getDefaultExport(layoutEntry.layoutModule));
 		if (!layoutComponent) continue;
 		const layoutParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntry.treePosition, options.matchedParams);
-		recordLayoutSkipObservationScope({
-			layoutId: layoutEntry.id,
-			layoutModule: layoutEntry.layoutModule,
-			layoutParamAccess: options.layoutParamAccess,
-			routeSegments: options.route.routeSegments,
-			treePosition: layoutEntry.treePosition
-		});
-		const layoutProps = { params: options.makeThenableParams(layoutParams, options.layoutParamAccess?.createThenableParamsObserver(layoutEntry.id)) };
+		const layoutProps = { params: options.makeThenableParams(layoutParams) };
 		for (const slot of Object.values(options.route.slots ?? {})) {
 			const slotName = slot.name;
 			if ((slot.layoutIndex >= 0 ? slot.layoutIndex : layoutEntries.length - 1) !== index) continue;
 			layoutProps[slotName] = /* @__PURE__ */ jsx(ParallelSlot, { name: slotName });
 		}
 		const LayoutComponent = layoutComponent;
-		const layoutDependency = layoutDependenciesByIndex.get(index);
-		let layoutElement = layoutDependency ? renderAppComponentWithDependencyBarrier(LayoutComponent, withUseCacheLayoutMarker(LayoutComponent, {
+		const ancestorLoadingEntry = findNearestAncestorLoadingEntry(layoutEntry.treePosition);
+		const holdsResponse = !ancestorLoadingEntry && !isReactOwnedAppComponent(LayoutComponent);
+		if (holdsResponse) layoutGate.hold(layoutEntry.id, index);
+		let layoutElement = createRouteLayoutElement(LayoutComponent, withUseCacheLayoutMarker(LayoutComponent, {
 			...layoutProps,
 			children: /* @__PURE__ */ jsx(Children$1, {})
-		}), layoutDependency) : /* @__PURE__ */ jsx(LayoutComponent, {
-			...withUseCacheLayoutMarker(LayoutComponent, layoutProps),
-			children: /* @__PURE__ */ jsx(Children$1, {})
+		}), index, layoutDependenciesByIndex.get(index), holdsResponse ? (failure) => layoutGate.settle(layoutEntry.id, failure) : void 0);
+		layoutElement = /* @__PURE__ */ jsx(RedirectBoundary, {
+			resetKey: resolveRouteSegmentResetKey(layoutEntry.treePosition),
+			children: layoutElement
 		});
-		const ancestorLoadingEntry = findNearestAncestorLoadingEntry(layoutEntry.treePosition);
 		const ancestorLoadingComponent = getDefaultExport(ancestorLoadingEntry?.loadingModule);
 		if (ancestorLoadingComponent && ancestorLoadingEntry && isOutermostEntryBelowLoading(ancestorLoadingEntry.treePosition, layoutEntry.treePosition, "layout")) {
 			const AncestorLoadingComponent = ancestorLoadingComponent;
@@ -876,6 +877,7 @@ function buildAppPageElements(options) {
 		children: routeChildren
 	});
 	const renderedTreePositions = isPrefetchLoadingShell ? orderedTreePositions.filter(includesPrefetchTreePosition) : orderedTreePositions;
+	let childSegmentElementId = pageElementId;
 	for (let index = renderedTreePositions.length - 1; index >= 0; index--) {
 		const treePosition = renderedTreePositions[index];
 		const segmentResetKey = resolveRouteSegmentResetKey(treePosition);
@@ -947,9 +949,13 @@ function buildAppPageElements(options) {
 			children: layoutHasElement ? /* @__PURE__ */ jsx(Slot, {
 				id: layoutEntry.id,
 				parallelSlots: createAppPageParallelSlotEntries(layoutIndex, layoutEntries, options.route, getEffectiveSlotParams, resolveSlotOverride),
-				children: segmentChildren
+				children: /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+					id: childSegmentElementId,
+					children: segmentChildren
+				})
 			}) : segmentChildren
 		});
+		if (layoutHasElement) childSegmentElementId = layoutEntry.id;
 	}
 	const globalErrorComponent = getErrorBoundaryExport(options.globalErrorModule);
 	routeChildren = /* @__PURE__ */ jsx(GlobalErrorBoundary, {
@@ -965,9 +971,9 @@ function buildAppPageElements(options) {
 		createAppPageStreamingMetadataBody(streamingMetadataBodyId)
 	] });
 	elements[routeId] = pageRenderDependency ? renderAfterAppDependencies(routeElement, [pageRenderDependency]) : routeElement;
-	Object.assign(elements, metadataEntries, options.route.staticSiblings && options.route.staticSiblings.length > 0 ? { [APP_STATIC_SIBLINGS_KEY]: options.route.staticSiblings } : {}, shouldRenderPrefetchLoadingShell ? { [APP_PREFETCH_LOADING_SHELL_MARKER_KEY]: "LoadingBoundary" } : {});
-	registerAppElementRenderDependencies(elements, renderDependenciesByElementId);
+	Object.assign(elements, metadataEntries, options.route.staticSiblings && options.route.staticSiblings.length > 0 ? { [APP_STATIC_SIBLINGS_KEY]: options.route.staticSiblings } : {}, shouldRenderPrefetchLoadingShell ? { [APP_PREFETCH_LOADING_SHELL_MARKER_KEY]: "LoadingBoundary" } : {}, skippedLayoutIds.size > 0 ? { [APP_SKIPPED_LAYOUT_IDS_KEY]: [...skippedLayoutIds] } : {});
+	registerAppPageLayoutGate(elements, layoutGate);
 	return elements;
 }
 //#endregion
-export { buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments, resolveAppPageLoadingModuleAtOrAbove };
+export { buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage, createAppPageTreePath, probeAppPageLayout, resolveAppPageChildSegments, resolveAppPageLoadingModuleAtOrAbove };

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

@@ -1,7 +1,9 @@
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation.js";
 import { RootParams } from "../shims/root-params.js";
-import { AppPageSsrHandler } from "./app-page-stream.js";
+import { InitialNavigationCacheMetadata } from "./app-ssr-stream.js";
+import { AppPageFontData, AppPageSsrHandler } from "./app-page-stream.js";
+import { CdnAppPageDocument } from "../shims/cdn-cache.js";
 //#region src/server/app-page-rsc-render-status.d.ts
 /**
  * The status of a finished RSC render, as Next.js's static generation decides
@@ -10,6 +12,8 @@ import { AppPageSsrHandler } from "./app-page-stream.js";
  */
 export type AppPageRscRenderStatus = {
   kind: "page";
+  /** The page's document, when the resolver rendered one to store. */
+  document?: CdnAppPageDocument;
 } | {
   kind: "special-error";
   status: number;
@@ -22,9 +26,28 @@ export type AppPageRscRenderStatus = {
 {
   kind: "unstorable";
 };
+/** What the page's document renders with, as an HTML request renders it. */
+type AppPageRscRenderDocumentOptions = {
+  clientTraceMetadata?: readonly string[];
+  /**
+   * When the document's render is given up, as completed-response admission
+   * gives up a body it hasn't captured by its deadline.
+   */
+  deadlineAt?: number;
+  getFontData: () => AppPageFontData;
+  getInitialNavigationCacheMetadata: () => InitialNavigationCacheMetadata;
+  mirrorNextFlight: () => boolean;
+  onSsrError: (error: unknown) => unknown;
+  reactMaxHeadersLength?: number;
+};
 type CreateAppPageRscRenderStatusResolverOptions = {
   basePath?: string;
   capturedRscData: Promise<ArrayBuffer>;
+  /**
+   * Render the page's document from the payload, to be stored beside it.
+   * Without it, only a render that threw a special error renders its shell.
+   */
+  document?: AppPageRscRenderDocumentOptions;
   getCapturedSpecialError: () => unknown;
   getCapturedSpecialErrors: (error: unknown) => readonly unknown[];
   isForceStatic: boolean;
@@ -39,6 +62,9 @@ type CreateAppPageRscRenderStatusResolverOptions = {
  * a render that threw one renders the document's shell from the same payload,
  * as Next.js's static generation renders HTML beside RSC. Its server
  * components don't run again. A render without a special error is a 200.
+ *
+ * With `document`, every render renders its document from the payload, as
+ * Next.js keeps a page's document and RSC payload in one entry.
  */
 export declare function createAppPageRscRenderStatusResolver(options: CreateAppPageRscRenderStatusResolverOptions): () => Promise<AppPageRscRenderStatus>;
 /**

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

@@ -1,5 +1,8 @@
-import { resolveAppPageShellSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
-import { isAppSsrRenderResult } from "./app-page-stream.js";
+import { isRenderDynamicLatched } from "../shims/internal/headers-state.js";
+import "../shims/headers.js";
+import { readStreamAsText } from "../utils/text-stream.js";
+import { buildAppPageFontLinkHeader, resolveAppPageShellSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
+import { buildAppPageLinkHeader, isAppSsrRenderResult } from "./app-page-stream.js";
 //#region src/server/app-page-rsc-render-status.ts
 const PAGE_STATUS = { kind: "page" };
 /**
@@ -8,28 +11,109 @@ const PAGE_STATUS = { kind: "page" };
 * a render that threw one renders the document's shell from the same payload,
 * as Next.js's static generation renders HTML beside RSC. Its server
 * components don't run again. A render without a special error is a 200.
+*
+* With `document`, every render renders its document from the payload, as
+* Next.js keeps a page's document and RSC payload in one entry.
 */
 function createAppPageRscRenderStatusResolver(options) {
 	let status;
 	return () => status ??= resolveAppPageRscRenderStatus(options);
 }
 async function resolveAppPageRscRenderStatus(options) {
+	const deadlineAt = options.document?.deadlineAt;
+	if (deadlineAt === void 0) return renderAppPageRscRenderStatus(options);
+	const expired = new AbortController();
+	const remaining = deadlineAt - Date.now();
+	const timer = remaining > 0 ? setTimeout(() => expired.abort(), remaining) : void 0;
+	if (timer === void 0) expired.abort();
+	try {
+		return await unlessExpired(renderAppPageRscRenderStatus(options, expired.signal), expired.signal, () => {}) ?? expiredDocumentStatus(options);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** Settle with `promise`, or with `null` once `signal` aborts. */
+function unlessExpired(promise, signal, discard) {
+	if (!signal) return promise;
+	if (signal.aborted) {
+		promise.then(discard, () => {});
+		return Promise.resolve(null);
+	}
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			promise.then(discard, () => {});
+			resolve(null);
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			if (signal.aborted) discard(value);
+			else resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+/** Read the document, or cancel it and settle with `null` once `signal` aborts. */
+async function readDocumentHtml(stream, signal) {
+	if (!signal) return readStreamAsText(stream);
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	const chunks = [];
+	for (;;) {
+		const result = await unlessExpired(reader.read(), signal, () => {});
+		if (result === null) {
+			reader.cancel().catch(() => {});
+			return null;
+		}
+		if (result.done) break;
+		chunks.push(decoder.decode(result.value, { stream: true }));
+	}
+	chunks.push(decoder.decode());
+	return chunks.join("");
+}
+/**
+* A document given up at its deadline isn't stored. A render without a
+* special error is still a 200, but one with a special error needs its shell.
+*/
+function expiredDocumentStatus(options) {
+	return options.getCapturedSpecialError() === null ? PAGE_STATUS : { kind: "unstorable" };
+}
+async function renderAppPageRscRenderStatus(options, signal) {
 	const rscData = await options.capturedRscData;
-	if (options.getCapturedSpecialError() === null) return PAGE_STATUS;
+	const documentOptions = options.document;
+	if (!documentOptions && options.getCapturedSpecialError() === null) return PAGE_STATUS;
 	const ssrHandler = await options.loadSsrHandler();
+	if (signal?.aborted) return expiredDocumentStatus(options);
+	const fontData = documentOptions?.getFontData() ?? {
+		links: [],
+		preloads: [],
+		styles: []
+	};
+	const clientTraceMetadataMarker = documentOptions?.clientTraceMetadata && documentOptions.clientTraceMetadata.length > 0 ? crypto.randomUUID() : void 0;
 	let rendered;
 	try {
-		rendered = await ssrHandler.handleSsr(new Response(rscData).body, options.navigationContext, {
-			links: [],
-			preloads: [],
-			styles: []
-		}, {
+		rendered = await unlessExpired(ssrHandler.handleSsr(new Response(rscData).body, options.navigationContext, fontData, {
 			basePath: options.basePath,
 			isForceStatic: options.isForceStatic,
-			isStaticGeneration: true,
-			onSsrError: () => void 0,
 			preloadRoutePattern: options.routePattern,
-			rootParams: options.rootParams
+			rootParams: options.rootParams,
+			...documentOptions ? {
+				clientTraceMetadata: documentOptions.clientTraceMetadata,
+				clientTraceMetadataMarker,
+				getInitialNavigationCacheMetadata: documentOptions.getInitialNavigationCacheMetadata,
+				isCacheCandidate: true,
+				mirrorNextFlight: documentOptions.mirrorNextFlight,
+				onSsrError: documentOptions.onSsrError,
+				reactMaxHeadersLength: documentOptions.reactMaxHeadersLength,
+				signal
+			} : {
+				isStaticGeneration: true,
+				onSsrError: () => void 0
+			}
+		}), signal, (late) => {
+			(isAppSsrRenderResult(late) ? late.htmlStream : late).cancel().catch(() => {});
 		});
 	} catch (error) {
 		const specialError = resolveAppPageShellSpecialError(error, options.getCapturedSpecialErrors(error));
@@ -41,8 +125,32 @@ async function resolveAppPageRscRenderStatus(options) {
 			...headers ? { headers } : {}
 		};
 	}
-	(isAppSsrRenderResult(rendered) ? rendered.htmlStream : rendered).cancel().catch(() => {});
-	return PAGE_STATUS;
+	if (rendered === null) return expiredDocumentStatus(options);
+	const htmlStream = isAppSsrRenderResult(rendered) ? rendered.htmlStream : rendered;
+	if (!documentOptions) {
+		htmlStream.cancel().catch(() => {});
+		return PAGE_STATUS;
+	}
+	let html;
+	try {
+		html = await readDocumentHtml(htmlStream, signal);
+	} catch {
+		return PAGE_STATUS;
+	}
+	if (html === null) return expiredDocumentStatus(options);
+	if (isRenderDynamicLatched()) return PAGE_STATUS;
+	const linkHeader = buildAppPageLinkHeader(isAppSsrRenderResult(rendered) ? rendered.linkHeader : void 0, buildAppPageFontLinkHeader(fontData.preloads), documentOptions.reactMaxHeadersLength);
+	if (clientTraceMetadataMarker) {
+		const { stripClientTraceMetadataBlock } = await import("./client-trace-metadata.js");
+		html = stripClientTraceMetadataBlock(html, clientTraceMetadataMarker);
+	}
+	return {
+		kind: "page",
+		document: {
+			html,
+			...linkHeader ? { linkHeader } : {}
+		}
+	};
 }
 /**
 * The status Next.js sends an RSC request for a render with this status. Its

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

@@ -77,6 +77,8 @@ export type AppPageSsrHandler = {
     };
     /** Abort signal for a build-time PPR fallback-shell static render. */
     pprFallbackShellSignal?: AbortSignal;
+    /** Aborts a streaming render whose document is given up. */
+    signal?: AbortSignal;
     /** Route whose client references load before the render; null for none. */
     preloadRoutePattern?: string | null;
     /** When true, wait for the full React tree before emitting bytes. */

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

@@ -1,9 +1,9 @@
 import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import "./app-rsc-cache-busting.js";
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import "./app-rsc-cache-busting.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest } from "./next-error-digest.js";
 import { isAppRenderAbortError } from "./app-render-abort-error.js";

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

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

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

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

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

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