vinext 1.3.0 → 1.3.1

package/dist/server/app-page-http-access-fallback-metadata.js

@@ -1,7 +1,10 @@
+import { isStaticGenerationAccessError } from "../shims/internal/headers-state.js";
 import { mergeViewport, resolveModuleViewport } from "../shims/metadata.js";
+import { resolveAppPageSpecialError } from "./app-page-execution.js";
 import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { createAppMetadataModuleRoute } from "./app-metadata-tracing.js";
 import { resolveOrderedAppPageMetadata } from "./app-page-head.js";
+import { resolveAppPageParentHttpAccessBoundary } from "./app-page-boundary.js";
 //#region src/server/app-page-http-access-fallback-metadata.ts
 function isPresent(value) {
 	return value !== null && value !== void 0;
@@ -106,6 +109,78 @@ function resolveHttpAccessFallbackMetadata(options) {
 		sources: createHttpAccessFallbackMetadataPlan(options)
 	});
 }
+/**
+* The not-found head a route's own head falls back to. Like Next.js's
+* metadata tree, every HTTP access signal from generateMetadata() or
+* generateViewport() resolves through the not-found convention, whichever
+* signal the route's render threw.
+*/
+function createRouteNotFoundHeadPlanOptions(options) {
+	const { route } = options;
+	const routeSegments = route.routeSegments ?? [];
+	const layoutModules = route.layouts ?? [];
+	let boundaryModule = route.notFound ?? null;
+	let boundaryTreePosition = boundaryModule ? route.notFoundTreePosition : null;
+	if (!boundaryModule) {
+		const parentBoundary = resolveAppPageParentHttpAccessBoundary({
+			layoutIndex: layoutModules.length,
+			rootNotFoundModule: options.rootNotFoundModule,
+			routeNotFoundModules: route.notFounds,
+			statusCode: 404
+		});
+		boundaryModule = parentBoundary.module;
+		boundaryTreePosition = parentBoundary.layoutIndex === null ? null : route.layoutTreePositions?.[parentBoundary.layoutIndex];
+	}
+	return {
+		boundaryModule,
+		boundaryParams: boundaryModule && boundaryTreePosition != null ? resolveAppPageSegmentParams(routeSegments, boundaryTreePosition, options.params) : {},
+		boundaryRouteSegments: routeSegments.slice(0, boundaryTreePosition ?? 0),
+		errorConvention: "not-found",
+		layoutModules,
+		layoutTreePositions: route.layoutTreePositions,
+		parallelBranches: options.parallelBranches,
+		params: options.params,
+		primaryParallelBranch: options.primaryParallelBranch,
+		routeSegments: route.routeSegments ?? null
+	};
+}
+/**
+* Settle each branch of a route's head on its own, as Next.js's MetadataTree
+* and ViewportTree do: an HTTP access signal from generateMetadata() keeps the
+* resolved viewport and resolves the metadata through the not-found
+* convention, and the same holds the other way round. Any other error leaves
+* that branch empty; the route's render reports it where it renders.
+*
+* A `dynamic = "error"` access error leaves its branch empty too, but
+* `accessError` keeps it, whether the route's head or the not-found head it
+* recovers through threw it: Next.js fails such a render even where its
+* metadata trees drop the error, so a fallback without the route's outlet
+* rethrows it.
+*/
+function recoverAppPageRouteHead(head, options) {
+	const { resolvePlanOptions, ...metadataOptions } = options;
+	const settleEmpty = (error, empty) => ({
+		accessError: isStaticGenerationAccessError(error) ? error : null,
+		value: empty
+	});
+	const recover = (branch, recoverBranch, empty) => branch.then((value) => ({
+		accessError: null,
+		value
+	}), (error) => resolveAppPageSpecialError(error)?.kind === "http-access-fallback" ? recoverBranch().then((value) => ({
+		accessError: null,
+		value
+	}), (recoveryError) => settleEmpty(recoveryError, empty)) : settleEmpty(error, empty));
+	const metadata = recover(head.metadata, () => resolveHttpAccessFallbackMetadata({
+		...metadataOptions,
+		...resolvePlanOptions()
+	}), null);
+	const viewport = recover(head.viewport, () => resolveHttpAccessFallbackViewport(resolvePlanOptions()), null);
+	return {
+		accessError: Promise.all([metadata, viewport]).then(([metadataResult, viewportResult]) => metadataResult.accessError ?? viewportResult.accessError),
+		metadata: metadata.then((result) => result.value),
+		viewport: viewport.then((result) => result.value)
+	};
+}
 async function resolveHttpAccessFallbackViewport(options) {
 	let accumulatedViewport = Promise.resolve(mergeViewport([]));
 	for (const source of createHttpAccessFallbackPlan(options, "snapshot")) {
@@ -118,4 +193,4 @@ async function resolveHttpAccessFallbackViewport(options) {
 	return accumulatedViewport;
 }
 //#endregion
-export { createHttpAccessFallbackMetadataPlan, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport };
+export { createHttpAccessFallbackMetadataPlan, createRouteNotFoundHeadPlanOptions, recoverAppPageRouteHead, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport };

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

@@ -6,4 +6,5 @@ type ResolveAppPageMethodResponseOptions = {
   request: Pick<Request, "headers" | "method">;
 };
 export declare function resolveAppPageMethodResponse(options: ResolveAppPageMethodResponseOptions): Response | null;
-//#endregion
+//#endregion
+export {};

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

@@ -27,4 +27,5 @@ type ProbeAppPageBeforeRenderOptions = {
   classification?: LayoutClassificationOptions | null;
 };
 export declare function probeAppPageBeforeRender(options: ProbeAppPageBeforeRenderOptions): Promise<ProbeAppPageBeforeRenderResult>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-page-render-identity.d.ts

@@ -19,4 +19,5 @@ export type AppPageRenderIdentity = {
   targetMatchedPathname: string;
 };
 export declare function createAppPageRenderIdentity(input: AppPageRenderIdentityInput): AppPageRenderIdentity;
-//#endregion
+//#endregion
+export {};

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

@@ -29,6 +29,11 @@ type AppPageSpecialErrorRenderOptions = {
    * candidate's render it must not carry the request's query.
    */
   isCacheCandidate?: boolean;
+  /**
+   * The page's own document, in which parallel slot boundaries caught the
+   * error, to send in place of a fallback page.
+   */
+  caughtDocument?: Response;
 };
 type PreparedAppPageElement = {
   element: AppPageRenderableElement;
@@ -160,4 +165,5 @@ type RenderAppPageLifecycleOptions = RenderAppPageLifecycleOptionsBase & ({
  */
 export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, probeCacheLife?: AppPageRequestCacheLife | null): Response;
 export declare function renderAppPageLifecycle(options: RenderAppPageLifecycleOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

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

@@ -1,16 +1,17 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { bindRequestContext } from "../shims/unified-request-context.js";
 import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER } from "./headers.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { isRouteCacheabilityEvaluation, recordRouteCacheabilityClientTraceMetadataMarker } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, isCdnResponsePolicyHeader } from "./cache-control.js";
+import "./app-rsc-render-mode.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
 import { isRenderDynamicLatched, markDynamicUsage } from "../shims/internal/headers-state.js";
 import { peekDynamicUsage, runWithDetachedDynamicUsage } from "../shims/headers.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVersion } from "./artifact-compatibility.js";
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
@@ -19,19 +20,19 @@ import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js
 import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { copyLinkHeaderProvenance, getFrameworkLinkHeader } from "./app-response-header-provenance.js";
 import { applyClientStaleTimeHeader, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy, resolveUncacheableCacheControl } from "./app-page-response.js";
-import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
+import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
 import { probeAppPageBeforeRender } from "./app-page-probe.js";
 import { hasDigest } from "./app-rsc-errors.js";
 import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
 import { traceResponseStartWithCompletion } from "./response-start-tracing.js";
 import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget, buildRenderObservation, buildRenderRequestApiObservations, createStaticLayoutArtifactReuseDecision } from "./cache-proof.js";
-import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
-import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
-import { createAppPageRscRenderStatusResolver } from "./app-page-rsc-render-status.js";
-import { finalizeAppPageCacheabilityEvaluationResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache-finalizer.js";
 import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
 import { appendRscCompletionMetadata } from "./rsc-completion-metadata.js";
+import { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { getStaticLayoutObservationSkipRejection } from "./app-layout-param-observation.js";
+import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
+import { createAppPageRscRenderStatusResolver } from "./app-page-rsc-render-status.js";
+import { finalizeAppPageCacheabilityEvaluationResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache-finalizer.js";
 import { createClientReuseSkipTransportPlan, crossCheckClientReuseManifestEntryWithCache } from "./skip-cache-proof.js";
 //#region src/server/app-page-render.ts
 function buildResponseTiming(options) {
@@ -115,6 +116,18 @@ function resolveAppPageCacheWriteRevalidateSeconds(options) {
 	if (options.revalidateSeconds === null && (options.isForceStatic || options.isDynamicError)) return Infinity;
 	return options.revalidateSeconds;
 }
+/**
+* A loading-shell prefetch without a loading boundary that can never be stored
+* renders only the route tree (see buildAppPageElements), so no layout runs and
+* none is probed. Next.js runs no layout for its no-loading prefetch either.
+*/
+function isRouteTreeOnlyLoadingShell(options) {
+	if (options.renderMode !== "prefetch-loading-shell") return false;
+	if (options.isCacheCandidate === true) return false;
+	if (!isAppElementsRecord(options.element)) return false;
+	const routeId = options.element[AppElementsWire.keys.route];
+	return typeof routeId === "string" && options.element[routeId] === null;
+}
 function readRootBoundaryId(element) {
 	const rootLayoutTreePath = element[AppElementsWire.keys.rootLayout];
 	return typeof rootLayoutTreePath === "string" ? rootLayoutTreePath : null;
@@ -390,7 +403,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		return dynamicUsageObserved;
 	};
 	const probeOutcome = await runWithDetachedDynamicUsage(() => probeAppPageBeforeRender({
-		skipProbes: options.pprFallbackShellSignal !== void 0,
+		skipProbes: options.pprFallbackShellSignal !== void 0 || isRouteTreeOnlyLoadingShell(options),
 		layoutCount: options.layoutCount,
 		probeLayoutAt(layoutIndex) {
 			return options.probeLayoutAt(layoutIndex);
@@ -825,10 +838,11 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				isForceStatic: options.isForceStatic,
 				isCacheCandidate: isCacheCandidateHtmlRender,
 				onSsrError: createAppPageSsrErrorHandler(onSsrError, rscErrorTracker.isCapturedError),
-				mirrorNextFlight: () => rscErrorTracker.getCapturedSpecialError() !== null
+				mirrorNextFlight: () => rscErrorTracker.getCapturedSpecialError() !== null,
+				resolveCaughtNotFoundBoundaries: (error) => resolveAppPageCaughtNotFoundBoundaries(error, rscErrorTracker.getCapturedSpecialErrors(error))
 			});
 		},
-		async renderSpecialErrorResponse(specialError) {
+		async renderSpecialErrorResponse(specialError, caughtDocument) {
 			shellSpecialError = specialError;
 			const mayPrerender = mayPrerenderShellSpecialError();
 			if (mayStoreShellSpecialError() || mayPrerender) await settleCapturedRscRenderForCacheMetadata(capturedRscDataRef.value, peekRenderDynamicUsage);
@@ -836,7 +850,18 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				dynamicUsed: consumeRenderDynamicUsage(),
 				redirectMetadata: specialError.kind === "redirect" ? readPrerenderCacheMetadata() : null
 			};
-			return options.renderPageSpecialError(specialError, { isCacheCandidate: isCacheCandidateHtmlRender });
+			return options.renderPageSpecialError(specialError, {
+				isCacheCandidate: isCacheCandidateHtmlRender,
+				...caughtDocument ? { caughtDocument: buildAppPageHtmlDocumentResponse(caughtDocument.htmlStream, {
+					clearRequestContext: options.clearRequestContext,
+					fontLinkHeader,
+					isEdgeRuntime: options.isEdgeRuntime,
+					middlewareHeaders: null,
+					reactLinkHeader: caughtDocument.linkHeader,
+					reactMaxHeadersLength: options.reactMaxHeadersLength,
+					status: specialError.statusCode
+				}) } : {}
+			});
 		},
 		resolveSpecialError(error) {
 			return resolveAppPageShellSpecialError(error, rscErrorTracker.getCapturedSpecialErrors(error));

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

@@ -66,8 +66,11 @@ type AppPageInterceptMatch<TPage = unknown> = {
   interceptLoadings?: readonly unknown[] | null;
   interceptLoadingTreePositions?: readonly number[] | null;
   interceptNotFoundBranchSegments?: readonly string[] | null;
+  interceptNotFounds?: readonly unknown[] | null;
+  interceptNotFoundTreePositions?: readonly number[] | null;
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptNotFounds?: readonly (() => Promise<unknown>)[] | null;
   matchedParams: AppPageParams;
   sourceMatchedParams?: AppPageParams;
   page: TPage;
@@ -75,6 +78,15 @@ type AppPageInterceptMatch<TPage = unknown> = {
   notFound?: unknown;
   __loadNotFound?: (() => Promise<unknown>) | null;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[] | null;
+  interceptForbiddenTreePositions?: readonly number[] | null;
+  __loadInterceptForbiddens?: readonly (() => Promise<unknown>)[] | null;
+  interceptUnauthorizeds?: readonly unknown[] | null;
+  interceptUnauthorizedTreePositions?: readonly number[] | null;
+  __loadInterceptUnauthorizeds?: readonly (() => Promise<unknown>)[] | null;
+  interceptErrors?: readonly unknown[] | null;
+  interceptErrorTreePositions?: readonly number[] | null;
+  __loadInterceptErrors?: readonly (() => Promise<unknown>)[] | null;
   __loadState?: {
     page: TPage;
     pageLoading: Promise<TPage> | null;
@@ -140,4 +152,5 @@ export declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage,
 export declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts>>;
 export declare function resolveAppPageIntercept<TRoute, TPage, TInterceptOpts, TElement>(options: ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement>): Promise<ResolveAppPageInterceptResult<TInterceptOpts>>;
 export declare function buildAppPageElement<TElement>(options: BuildAppPageElementOptions<TElement>): Promise<BuildAppPageElementResult<TElement>>;
-//#endregion
+//#endregion
+export {};

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

@@ -283,7 +283,7 @@ async function resolveAppPageInterceptState(options) {
 	if (!intercept) return { kind: "none" };
 	await loadAppInterceptPage(intercept);
 	await loadAppInterceptNotFound(intercept);
-	if (intercept.__loadInterceptLayouts || intercept.__loadInterceptLoadings) await loadAppInterceptLayouts(intercept);
+	if (intercept.__loadInterceptLayouts || intercept.__loadInterceptLoadings || intercept.__loadInterceptNotFounds || intercept.__loadInterceptForbiddens || intercept.__loadInterceptUnauthorizeds || intercept.__loadInterceptErrors) await loadAppInterceptLayouts(intercept);
 	const sourceRoute = await options.getSourceRoute(intercept.sourceRouteIndex);
 	if (!sourceRoute) return { kind: "none" };
 	if (sourceRoute === options.currentRoute) return {

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

@@ -45,6 +45,8 @@ export type AppPageRouteWiringSlot<TModule extends AppPageModule = AppPageModule
   ownerTreePosition?: number | null;
   notFound?: TModule | null;
   notFoundTreePosition?: number | null;
+  notFounds?: readonly (TModule | null | undefined)[] | null;
+  notFoundTreePositions?: readonly number[] | null;
   page?: TModule | null;
   routeSegments?: readonly string[] | null;
   /**
@@ -77,6 +79,17 @@ export type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModul
   unauthorized?: TModule | null;
   unauthorizedTreePosition?: number | null;
   unauthorizeds?: readonly (TModule | null | undefined)[] | null;
+  /**
+   * Every segment's not-found, forbidden and unauthorized file, with or
+   * without a layout, aligned with the matching tree positions. Without them,
+   * only the files beside a layout wrap the tree.
+   */
+  segmentNotFounds?: readonly (TModule | null | undefined)[] | null;
+  segmentNotFoundTreePositions?: readonly number[] | null;
+  segmentForbiddens?: readonly (TModule | null | undefined)[] | null;
+  segmentForbiddenTreePositions?: readonly number[] | null;
+  segmentUnauthorizeds?: readonly (TModule | null | undefined)[] | null;
+  segmentUnauthorizedTreePositions?: readonly number[] | null;
   routeSegments?: readonly string[];
   childrenRouteSegments?: readonly string[] | null;
   /**
@@ -113,6 +126,23 @@ export type AppPageSlotOverride<TModule extends AppPageModule = AppPageModule> =
   layoutModules?: readonly (TModule | null | undefined)[] | null;
   loadingModules?: readonly (TModule | null | undefined)[] | null;
   loadingTreePositions?: readonly number[] | null;
+  /**
+   * Rendered beside the override's page, inside the slot's boundaries, as
+   * Next.js renders a page's MetadataOutlet in the page's own segment.
+   */
+  metadataOutlet?: ReactNode;
+  /** The intercepting route's not-found.tsx files and their branch tree positions. */
+  notFoundModules?: readonly (TModule | null | undefined)[] | null;
+  notFoundTreePositions?: readonly number[] | null;
+  /** The intercepting route's forbidden.tsx files and their branch tree positions. */
+  forbiddenModules?: readonly (TModule | null | undefined)[] | null;
+  forbiddenTreePositions?: readonly number[] | null;
+  /** The intercepting route's unauthorized.tsx files and their branch tree positions. */
+  unauthorizedModules?: readonly (TModule | null | undefined)[] | null;
+  unauthorizedTreePositions?: readonly number[] | null;
+  /** The intercepting route's error.tsx files and their branch tree positions. */
+  errorModules?: readonly (AppPageErrorModule | null | undefined)[] | null;
+  errorTreePositions?: readonly number[] | null;
   /**
    * The page module to render for this slot. Optional — when omitted, the
    * slot's existing `page` is used (e.g. when the override only changes the
@@ -135,6 +165,12 @@ export type AppPageLayoutEntry<TModule extends AppPageModule = AppPageModule, TE
 };
 type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule> = {
   element: ReactNode;
+  /**
+   * Builds the page element around the head's error outlet, in place of
+   * `element`, for a page whose own boundaries must catch its
+   * generateMetadata() errors, such as a sibling intercepting route's.
+   */
+  renderElementWithMetadataOutlet?: ((metadataOutlet: ReactNode) => ReactNode) | null;
   globalErrorModule?: TErrorModule | null;
   layoutParamAccess?: AppLayoutParamAccessTracker;
   makeThenableParams: MakeThenableParams;
@@ -154,7 +190,11 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
   rootNotFoundModule?: TModule | null;
   rootUnauthorizedModule?: TModule | null;
   route: AppPageRouteWiringRoute<TModule, TErrorModule>;
-  createPageElement?: (component: AppPageComponent, props: Readonly<Record<string, unknown>>) => ReactNode;
+  createPageElement?: (component: AppPageComponent, props: Readonly<Record<string, unknown>>,
+  /** For a parallel slot's page or default: the layout that renders the slot. */
+  slotLayoutIndex?: number,
+  /** The id of the slot's own not-found boundary that catches its notFound(). */
+  slotNotFoundBoundary?: string) => ReactNode;
   pageRenderDependency?: AppPageRenderDependency | null;
   searchParams?: unknown;
   slotOverrides?: Readonly<Record<string, AppPageSlotOverride<TModule>>> | null;
@@ -168,7 +208,8 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
 export type AppPageRouteHead = {
   metadata: Promise<Metadata | null>;
   outlet: Promise<null>;
-  viewport: Promise<Viewport>;
+  /** `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 BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule> = BuildAppPageRouteElementOptions<TModule, TErrorModule> & {
@@ -176,6 +217,15 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
   interceptionId?: string | null;
   interceptionContext?: string | null;
   isRscRequest?: boolean;
+  /**
+   * The render can never be stored and, in production, is never sent with
+   * static cache headers (see app-page-dispatch.ts), so a loading-shell
+   * prefetch without a loading boundary may skip its layouts. A render that
+   * may be stored keeps them, so a layout's dynamic API read still keeps it
+   * out of the cache. An explicit CDN cache policy on a dynamic route can
+   * still store the route tree, as a CDN would store Next.js's.
+   */
+  isUncacheableRender?: boolean;
   mountedSlotIds?: ReadonlySet<string> | null;
   renderIdentity?: AppPageRenderIdentity;
   renderMode?: AppRscRenderMode;