vinext 1.3.1 → 1.4.1

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

@@ -2,14 +2,14 @@ import { VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-v
 import { NEXT_CACHE_TAGS_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyPrerenderCacheLifeHeader } from "./prerender-cache-life-header.js";
 import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 //#region src/server/app-page-response.ts
 function applyTimingHeader(headers, timing) {
 	if (!timing) return;
-	const handlerStart = Math.round(timing.handlerStart);
+	const handlerStart = Math.round(Date.now() - (performance.now() - timing.handlerStart));
 	const compileMs = timing.compileEnd !== void 0 ? Math.round(timing.compileEnd - timing.handlerStart) : -1;
 	const renderMs = timing.responseKind === "html" && timing.renderEnd !== void 0 && timing.compileEnd !== void 0 ? Math.round(timing.renderEnd - timing.compileEnd) : -1;
 	headers.set(VINEXT_TIMING_HEADER, `${handlerStart},${compileMs},${renderMs}`);

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,27 @@
 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 { createBfcacheChildSegmentStateKey } from "./bfcache-identity.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 +47,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 +73,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 +426,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 +488,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 +537,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 +587,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;
@@ -875,7 +877,20 @@ function buildAppPageElements(options) {
 		fallback: pageErrorComponent,
 		children: routeChildren
 	});
-	const renderedTreePositions = isPrefetchLoadingShell ? orderedTreePositions.filter(includesPrefetchTreePosition) : orderedTreePositions;
+	const firstLayoutWithElementTreePosition = layoutEntries.find((entry) => getDefaultExport(entry.layoutModule) !== null)?.treePosition;
+	const keepsSegmentLevelLists = String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && firstLayoutWithElementTreePosition !== void 0 && !options.route.childrenSlot && options.semanticPageIdentity === void 0;
+	const spineTreePositions = keepsSegmentLevelLists ? Array.from(/* @__PURE__ */ new Set([...orderedTreePositions, ...Array.from({ length: Math.max(0, routeSegments.length - firstLayoutWithElementTreePosition) }, (_, offset) => firstLayoutWithElementTreePosition + 1 + offset)])).sort((left, right) => left - right) : orderedTreePositions;
+	const renderedTreePositions = isPrefetchLoadingShell ? spineTreePositions.filter(includesPrefetchTreePosition) : spineTreePositions;
+	const firstLayoutBelowShell = keepsSegmentLevelLists && isPrefetchLoadingShell ? layoutEntries.find((entry) => !includesPrefetchTreePosition(entry.treePosition) && getDefaultExport(entry.layoutModule) !== null) : void 0;
+	let childSegmentElementId = firstLayoutBelowShell?.id ?? pageElementId;
+	let childSegmentTreePosition = firstLayoutBelowShell?.treePosition ?? routeSegments.length + 1;
+	const retainChildSegment = (treePosition, children) => treePosition === childSegmentTreePosition - 1 ? /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+		id: childSegmentElementId,
+		children
+	}) : /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+		stateKey: createBfcacheChildSegmentStateKey(resolveAppPageTemplateStateKey(routeSegments, treePosition, options.matchedParams)),
+		children
+	});
 	for (let index = renderedTreePositions.length - 1; index >= 0; index--) {
 		const treePosition = renderedTreePositions[index];
 		const segmentResetKey = resolveRouteSegmentResetKey(treePosition);
@@ -925,11 +940,12 @@ function buildAppPageElements(options) {
 				children: segmentChildren
 			}, String(process.env.__NEXT_CACHE_COMPONENTS) === "true" ? void 0 : templateStateKey);
 		}
+		const layoutHasElement = layoutEntry !== void 0 && getDefaultExport(layoutEntry.layoutModule) !== null;
+		if (keepsSegmentLevelLists && !layoutHasElement && treePosition > firstLayoutWithElementTreePosition && treePosition < childSegmentTreePosition) segmentChildren = retainChildSegment(treePosition, segmentChildren);
 		if (!layoutEntry) {
 			routeChildren = segmentChildren;
 			continue;
 		}
-		const layoutHasElement = getDefaultExport(layoutEntry.layoutModule) !== null;
 		const layoutIndex = layoutIndicesByTreePosition.get(treePosition) ?? -1;
 		const segmentMap = { children: resolveAppPageLayoutSegmentProviderSegments(options.route.childrenRouteSegments ?? routeSegments, layoutEntry.treePosition, options.matchedParams) };
 		for (const [slotKey, slot] of Object.entries(options.route.slots ?? {})) {
@@ -947,9 +963,16 @@ function buildAppPageElements(options) {
 			children: layoutHasElement ? /* @__PURE__ */ jsx(Slot, {
 				id: layoutEntry.id,
 				parallelSlots: createAppPageParallelSlotEntries(layoutIndex, layoutEntries, options.route, getEffectiveSlotParams, resolveSlotOverride),
-				children: segmentChildren
+				children: keepsSegmentLevelLists ? retainChildSegment(treePosition, segmentChildren) : /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+					id: childSegmentElementId,
+					children: segmentChildren
+				})
 			}) : segmentChildren
 		});
+		if (layoutHasElement) {
+			childSegmentElementId = layoutEntry.id;
+			childSegmentTreePosition = treePosition;
+		}
 	}
 	const globalErrorComponent = getErrorBoundaryExport(options.globalErrorModule);
 	routeChildren = /* @__PURE__ */ jsx(GlobalErrorBoundary, {
@@ -965,9 +988,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. */
@@ -94,10 +96,13 @@ export type AppPageSsrHandler = {
     /** Mirror inline Flight chunks into Next.js's `self.__next_f` transport, or start
      *  mirroring once a function returns true. */
     mirrorNextFlight?: boolean | (() => boolean);
-    /** When true, an SSR-phase-only shell render error resolves to the
-     *  default `__next_error__` error-document shell (with the original
-     *  flight payload and bootstrap) instead of rejecting. See handleSsr. */
+    /** When true, a shell render error other than a redirect, HTTP access
+     *  fallback or bail-out resolves to the default `__next_error__`
+     *  error-document shell (with the original flight payload and
+     *  bootstrap) instead of rejecting. See handleSsr. */
     fallbackToErrorDocumentOnShellError?: boolean;
+    /** Whether the RSC render threw the given shell error. See handleSsr. */
+    isServerComponentError?: (error: unknown) => boolean;
     /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
     resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
     dynamicStaleTimeSeconds?: number;
@@ -151,8 +156,11 @@ type RenderAppPageHtmlStreamOptions = {
   isForceStatic?: boolean;
   /** Production render that may be stored under a query-free key. */
   isCacheCandidate?: boolean;
-  /** Override the default shell-error recovery decision passed to handleSsr. */
+  /** Whether handleSsr answers a shell error with the error document. Off by
+   *  default: a boundary render that fails keeps rejecting. */
   fallbackToErrorDocumentOnShellError?: boolean;
+  /** Whether the RSC render threw the given shell error. See handleSsr. */
+  isServerComponentError?: (error: unknown) => boolean;
   /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
   resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
   /** Dev-only: original server error to surface in the browser overlay. */
@@ -162,10 +170,6 @@ type RenderAppPageHtmlStreamOptions = {
   /** Mirror inline Flight chunks into Next.js's `self.__next_f` transport, or start
    *  mirroring once a function returns true. */
   mirrorNextFlight?: boolean | (() => boolean);
-  /** True when the app supplies a custom global-error.tsx. Disables the
-   *  default error-document shell fallback so SSR shell errors keep driving
-   *  the server-rendered global-error boundary re-render. */
-  hasCustomGlobalError?: boolean;
 };
 type RenderAppPageHtmlResponseOptions = {
   clearRequestContext: () => void;

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";
@@ -86,7 +86,8 @@ async function renderAppPageHtmlStream(options) {
 		initialDevServerError: options.initialDevServerError,
 		onSsrError: options.onSsrError,
 		mirrorNextFlight: options.mirrorNextFlight,
-		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError ?? (options.waitForAllReady !== true && options.hasCustomGlobalError === false),
+		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError,
+		isServerComponentError: options.isServerComponentError,
 		resolveCaughtNotFoundBoundaries: options.resolveCaughtNotFoundBoundaries,
 		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 		getInitialNavigationCacheMetadata: options.getInitialNavigationCacheMetadata