vinext 1.4.1 → 1.4.2

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

@@ -116,24 +116,6 @@ export type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModu
   htmlLimitedBots?: string;
   scriptNonce?: string;
 };
-type AppPageNavigationParamModule = {
-  default?: unknown;
-};
-type AppPageNavigationParamSlot = {
-  default?: AppPageNavigationParamModule | null;
-  page?: AppPageNavigationParamModule | null;
-  slotPatternParts?: readonly string[] | null;
-  slotParamNames?: readonly string[] | null;
-};
-type AppPageNavigationParamRoute = {
-  params?: readonly string[] | null;
-  slots?: Readonly<Record<string, AppPageNavigationParamSlot>> | null;
-};
-type AppPageNavigationParamInterceptOptions = {
-  interceptPage?: unknown;
-  interceptParams?: AppPageParams | null;
-  interceptSlotKey?: string | null;
-};
 /**
  * Build the App Router element tree for a matched route.
  *
@@ -151,6 +133,15 @@ type AppPageNavigationParamInterceptOptions = {
  * {@link https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/create-metadata.tsx|create-metadata.tsx}.
  */
 export declare function buildPageElements<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule>(options: BuildPageElementsOptions<TModule, TErrorModule>): Promise<AppElements>;
+/**
+ * The state key of each segment a sibling intercept's levels retain, from the
+ * app root down to the segment its element renders, so its Activity lists key
+ * like Next.js's for the intercepting route: the marker segment carries its
+ * marker, and a dynamic marker segment keys per value. The intercepting
+ * route's own layouts and boundaries render inside its page element, so the
+ * levels stop above the first of them.
+ */
+export declare function resolveSiblingInterceptSegmentKeys(sourcePageSegments: readonly string[] | null | undefined, routeSegments: readonly string[] | null | undefined, opts: AppPageInterceptOptions | null | undefined, routeParams: AppPageParams, interceptParams: AppPageParams): readonly string[] | null;
 export declare const APP_PAGE_INTERCEPTION_MARKER_TRAVERSALS: readonly [{
   readonly prefix: "(...)";
   readonly levels: number;
@@ -172,7 +163,5 @@ export declare const APP_PAGE_INTERCEPTION_MARKER_TRAVERSALS: readonly [{
  */
 export declare function resolveInterceptedSlotIdentitySegments(sourcePageSegments: readonly string[] | null | undefined, slotKey: string): readonly AppPageSemanticSegment[] | null;
 export declare function resolveInterceptedSlotSegments(sourcePageSegments: readonly string[] | null | undefined, slotKey: string): readonly string[] | null;
-export declare function resolveSlotParamOverrides(route: AppPageNavigationParamRoute, routePath: string): Readonly<Record<string, AppPageParams>> | null;
-export declare function resolveAppPageNavigationParams(route: AppPageNavigationParamRoute, routeParams: AppPageParams, routePath: string, opts?: AppPageNavigationParamInterceptOptions | null): AppPageParams;
 //#endregion
 export type { AppPageErrorModule, AppPageRouteWiringRoute };

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

@@ -1,9 +1,8 @@
 import { isPromiseLike } from "../utils/promise.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
-import { matchRoutePattern } from "../routing/route-pattern.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
+import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey, resolveAppPageSemanticSegmentStateKey } from "./app-page-segment-state.js";
 import { ErrorBoundary, ForbiddenBoundary, NotFoundBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
 import { withUseCacheLayoutMarker, withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
@@ -12,15 +11,16 @@ import { createAppPageMetadataSearchParamsObserver, makeObservedAppPageSearchPar
 import { resolveAppPageBranchParams } from "./app-page-params.js";
 import { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveInterceptLayoutsBesidePage, slotInterceptKeepsSourceHead } from "./app-page-head.js";
 import { createRouteNotFoundHeadPlanOptions, recoverAppPageRouteHead } from "./app-page-http-access-fallback-metadata.js";
-import { ClientPageRoot } from "../shims/client-page-root.js";
 import "./app-rsc-route-matching.js";
+import { resolveSlotParamOverrides } from "./app-page-navigation-params.js";
 import { createAppPageRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, renderAfterAppDependencies } from "./app-render-dependency.js";
 import { sanitizeErrorForClient } from "./app-rsc-errors.js";
 import { resolveAppPageModuleTraceSegment, traceCreateComponentTree, traceGetLayoutOrPageModule } from "./app-page-tracing.js";
 import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath, resolveAppPageLoadingModuleAtOrAbove } from "./app-page-route-wiring.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
-import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
+import { ClientPageRoot } from "../shims/client-page-root.js";
+import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
 import { Fragment, Suspense, cache, createElement } from "react";
 //#region src/server/app-page-element-builder.ts
 /**
@@ -429,6 +429,7 @@ async function buildPageElements(options) {
 			routePath,
 			semanticPageIdentity,
 			semanticInterceptionTargetRouteId: opts?.interceptTargetRouteGraphId ?? null,
+			siblingInterceptSegmentKeys: isSiblingIntercept ? resolveSiblingInterceptSegmentKeys(sourcePageSegments, route.routeSegments, opts, params, effectiveParams) : null,
 			sourcePageSegments,
 			rootNotFoundModule: rootNotFoundModule ?? null,
 			rootForbiddenModule: rootForbiddenModule ?? null,
@@ -487,6 +488,37 @@ function buildSlotOverrides(route, routeParams, routePath, opts, interceptMetada
 	}
 	return Object.keys(overrides).length > 0 ? overrides : null;
 }
+/**
+* The state key of each segment a sibling intercept's levels retain, from the
+* app root down to the segment its element renders, so its Activity lists key
+* like Next.js's for the intercepting route: the marker segment carries its
+* marker, and a dynamic marker segment keys per value. The intercepting
+* route's own layouts and boundaries render inside its page element, so the
+* levels stop above the first of them.
+*/
+function resolveSiblingInterceptSegmentKeys(sourcePageSegments, routeSegments, opts, routeParams, interceptParams) {
+	if (!sourcePageSegments || !routeSegments) return null;
+	const markerIndex = sourcePageSegments.findIndex((segment) => APP_PAGE_INTERCEPTION_MARKER_TRAVERSALS.some(({ prefix }) => segment.startsWith(prefix)));
+	if (markerIndex < 0) return null;
+	if (routeSegments.length !== markerIndex || routeSegments.some((segment, index) => segment !== sourcePageSegments[index])) return null;
+	const branchTreePositions = [
+		...(opts?.interceptLayouts ?? []).flatMap((layoutModule, index) => layoutModule?.default ? [opts?.interceptLayoutSegments?.[index]?.length ?? 0] : []),
+		...opts?.interceptLoadingTreePositions ?? [],
+		...opts?.interceptNotFoundTreePositions ?? [],
+		...opts?.interceptForbiddenTreePositions ?? [],
+		...opts?.interceptUnauthorizedTreePositions ?? [],
+		...opts?.interceptErrorTreePositions ?? []
+	];
+	const segmentCount = Math.max(markerIndex, Math.min(sourcePageSegments.length, markerIndex + Math.min(...branchTreePositions) - 1));
+	return sourcePageSegments.slice(0, segmentCount).map((segment, index) => {
+		const marker = index === markerIndex ? APP_PAGE_INTERCEPTION_MARKER_TRAVERSALS.find(({ prefix }) => segment.startsWith(prefix)) : void 0;
+		return resolveAppPageSemanticSegmentStateKey({
+			marker: marker?.prefix ?? null,
+			paramSource: "route",
+			segment: marker ? segment.slice(marker.prefix.length) : segment
+		}, index < markerIndex ? routeParams : interceptParams);
+	});
+}
 const APP_PAGE_INTERCEPTION_MARKER_TRAVERSALS = [
 	{
 		prefix: "(...)",
@@ -581,49 +613,5 @@ function resolveInterceptedSlotSegments(sourcePageSegments, slotKey) {
 	routeSegments.push(...sourcePageSegments.slice(markerIndex + 1).filter(isVisibleInterceptedSlotSegment));
 	return routeSegments;
 }
-function resolveSlotParamOverrides(route, routePath) {
-	const overrides = {};
-	const slots = route.slots;
-	if (slots) {
-		let urlParts = null;
-		const routeParamSet = collectParamNameSet(route.params);
-		for (const [slotKey, slot] of Object.entries(slots)) {
-			const patternParts = slot.slotPatternParts;
-			const paramNames = slot.slotParamNames;
-			if (!patternParts || patternParts.length === 0) continue;
-			if (paramNames && paramNames.every((name) => routeParamSet.has(name))) continue;
-			if (urlParts === null) urlParts = routePath.split("/").filter(Boolean);
-			const matched = matchRoutePattern(urlParts, patternParts);
-			if (!matched) continue;
-			overrides[slotKey] = matched;
-		}
-	}
-	return Object.keys(overrides).length > 0 ? overrides : null;
-}
-function mergeAppPageParams(target, source) {
-	for (const [key, value] of Object.entries(source)) target[key] = value;
-}
-function isDefaultExportModule(module) {
-	return typeof module === "object" && module !== null;
-}
-function hasDefaultExport(module) {
-	if (!isDefaultExportModule(module)) return false;
-	return module?.default !== null && module?.default !== void 0;
-}
-function resolveAppPageNavigationParams(route, routeParams, routePath, opts) {
-	const navigationParams = { ...routeParams };
-	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
-	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
-		const isInterceptedSlot = opts?.interceptSlotKey === slotKey && opts.interceptSlotKey !== "__vinext_page_intercept" && hasDefaultExport(opts.interceptPage);
-		if (!isInterceptedSlot && !hasDefaultExport(slot.page) && !hasDefaultExport(slot.default)) continue;
-		mergeAppPageParams(navigationParams, isInterceptedSlot ? opts?.interceptParams ?? routeParams : slotParamOverrides?.[slotKey] ?? routeParams);
-	}
-	return navigationParams;
-}
-function collectParamNameSet(params) {
-	const set = /* @__PURE__ */ new Set();
-	if (params) for (const name of params) set.add(name);
-	return set;
-}
 //#endregion
-export { APP_PAGE_INTERCEPTION_MARKER_TRAVERSALS, buildPageElements, resolveAppPageNavigationParams, resolveInterceptedSlotIdentitySegments, resolveInterceptedSlotSegments, resolveSlotParamOverrides };
+export { APP_PAGE_INTERCEPTION_MARKER_TRAVERSALS, buildPageElements, resolveInterceptedSlotIdentitySegments, resolveInterceptedSlotSegments, resolveSiblingInterceptSegmentKeys };

package/dist/server/app-page-intercept-segment-config.d.ts

@@ -0,0 +1,56 @@
+import { FetchCacheMode } from "../shims/fetch-cache-state.js";
+import "../shims/fetch-cache.js";
+//#region src/server/app-page-intercept-segment-config.d.ts
+type SegmentModule = Record<string, unknown>;
+type AppPageInterceptSegmentConfigSlot = {
+  configLayouts?: readonly (SegmentModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
+  default?: SegmentModule | null;
+  layout?: SegmentModule | null;
+  layoutIndex?: number;
+  name?: string;
+  ownerTreePosition?: number | null;
+  page?: SegmentModule | null;
+  routeSegments?: readonly string[] | null;
+};
+/** The parts of the route an interception renders under that its config reads. */
+export type AppPageInterceptSegmentConfigRoute = {
+  layouts?: readonly (SegmentModule | null | undefined)[];
+  layoutTreePositions?: readonly number[];
+  routeSegments?: readonly string[];
+  slots?: Readonly<Record<string, AppPageInterceptSegmentConfigSlot>> | null;
+};
+/** The parts of the interception's options its config reads. */
+export type AppPageInterceptSegmentConfigOptions = {
+  interceptBranchSegments?: readonly string[] | null;
+  interceptLayoutSegments?: readonly (readonly string[])[] | null;
+  interceptLayouts?: readonly unknown[] | null;
+  interceptPage?: unknown;
+  interceptSlotKey: string;
+  interceptSourcePageSegments?: readonly string[] | null;
+};
+export type AppPageInterceptSegmentConfig = {
+  dynamicConfig: string | undefined;
+  dynamicStaleTimeSeconds: number | undefined;
+  fetchCacheMode: FetchCacheMode | null;
+  /** Whether any segment of the interception exports `generateStaticParams`. */
+  hasAnyGenerateStaticParams: boolean;
+  /** Whether one sits at or below the interception's last dynamic segment. */
+  hasGenerateStaticParams: boolean;
+  /** Whether the interception's own segments choose the edge runtime. */
+  isEdgeRuntime: boolean;
+  isStaticEligible: boolean;
+  isStaticGenerationEdgeRuntime: boolean;
+  revalidateSeconds: number | null;
+};
+/**
+ * Next.js renders an interception as its own route, whose loader tree holds
+ * the owner's layouts and the intercepting page, never the source's page, so
+ * its segment config comes from those modules alone. A sibling intercept's
+ * branch takes the children position below its owner folder; a slot
+ * intercept's branch takes its slot, beside the other slots of the owner's
+ * layouts, and children renders the owner's default.
+ */
+export declare function resolveAppPageInterceptSegmentConfig(route: AppPageInterceptSegmentConfigRoute, interceptOpts: AppPageInterceptSegmentConfigOptions): AppPageInterceptSegmentConfig;
+//#endregion
+export {};

package/dist/server/app-page-intercept-segment-config.js

@@ -0,0 +1,90 @@
+import { collectAppPageStaticGenerationRuntimes, collectAppPageStaticParamsWalkSegments, hasAppPageGenerateStaticParamsAtLastDynamicSegment, isAppPageStaticEligible, isEdgeRuntime, resolveAppPageSegmentConfig, resolveAppPageStaticGenerationRuntime } from "./app-segment-config.js";
+import { SIBLING_PAGE_INTERCEPT_SLOT_KEY } from "./app-rsc-route-matching.js";
+//#region src/server/app-page-intercept-segment-config.ts
+/**
+* Next.js renders an interception as its own route, whose loader tree holds
+* the owner's layouts and the intercepting page, never the source's page, so
+* its segment config comes from those modules alone. A sibling intercept's
+* branch takes the children position below its owner folder; a slot
+* intercept's branch takes its slot, beside the other slots of the owner's
+* layouts, and children renders the owner's default.
+*/
+function resolveAppPageInterceptSegmentConfig(route, interceptOpts) {
+	const routeLayouts = route.layouts ?? [];
+	const routeSegments = route.routeSegments ?? [];
+	const isSiblingIntercept = interceptOpts.interceptSlotKey === SIBLING_PAGE_INTERCEPT_SLOT_KEY;
+	const interceptedSlot = isSiblingIntercept ? void 0 : route.slots?.[interceptOpts.interceptSlotKey];
+	const branchSegments = interceptOpts.interceptBranchSegments ?? [];
+	const interceptLayouts = interceptOpts.interceptLayouts ?? [];
+	const interceptLayoutPositions = (interceptOpts.interceptLayoutSegments ?? []).map((segments) => segments.length);
+	const ownerPosition = isSiblingIntercept ? interceptOpts.interceptSourcePageSegments ? interceptOpts.interceptSourcePageSegments.length - branchSegments.length : routeSegments.length : interceptedSlot?.ownerTreePosition ?? route.layoutTreePositions?.[interceptedSlot?.layoutIndex ?? -1] ?? routeSegments.length;
+	const ownerLayoutIndexes = routeLayouts.flatMap((_, index) => (route.layoutTreePositions?.[index] ?? 0) <= ownerPosition ? [index] : []);
+	const ownerLayouts = ownerLayoutIndexes.map((index) => routeLayouts[index]);
+	const ownerLayoutPositions = ownerLayoutIndexes.map((index) => route.layoutTreePositions?.[index] ?? 0);
+	const ownerSegments = routeSegments.slice(0, ownerPosition);
+	const page = interceptOpts.interceptPage;
+	const retainedBranches = Object.entries(route.slots ?? {}).flatMap(([slotKey, slot]) => slotKey !== interceptOpts.interceptSlotKey && (slot.ownerTreePosition ?? route.layoutTreePositions?.[slot.layoutIndex ?? 0] ?? 0) <= ownerPosition ? [{
+		configLayouts: slot.page ? slot.configLayouts : null,
+		configLayoutTreePositions: slot.page ? slot.configLayoutTreePositions : null,
+		isDefault: !slot.page,
+		layout: slot.page ? slot.layout : null,
+		name: slot.name,
+		ownerTreePosition: slot.ownerTreePosition,
+		page: slot.page ?? slot.default,
+		routeSegments: slot.routeSegments
+	}] : []);
+	const tree = isSiblingIntercept ? {
+		layouts: [...ownerLayouts, ...interceptLayouts],
+		layoutTreePositions: [...ownerLayoutPositions, ...interceptLayoutPositions.map((position) => ownerPosition + position)],
+		page,
+		parallelBranches: retainedBranches,
+		routeSegments: [...ownerSegments, ...branchSegments]
+	} : {
+		layouts: ownerLayouts,
+		layoutTreePositions: ownerLayoutPositions,
+		page: null,
+		parallelBranches: [...retainedBranches, {
+			configLayouts: interceptLayouts,
+			configLayoutTreePositions: interceptLayoutPositions,
+			layout: interceptedSlot?.layout,
+			name: interceptedSlot?.name,
+			ownerTreePosition: ownerPosition,
+			page,
+			routeSegments: branchSegments
+		}],
+		routeSegments: ownerSegments
+	};
+	const config = resolveAppPageSegmentConfig({
+		layouts: [
+			...ownerLayouts,
+			...isSiblingIntercept ? [] : [interceptedSlot?.layout],
+			...interceptLayouts
+		],
+		page,
+		parallelBranches: retainedBranches,
+		parallelPages: retainedBranches.map((branch) => branch.page)
+	});
+	const walkSegments = collectAppPageStaticParamsWalkSegments(tree);
+	const hasGenerateStaticParams = hasAppPageGenerateStaticParamsAtLastDynamicSegment(tree);
+	const isDynamicRoute = walkSegments.some((segment) => segment.dynamic);
+	const isStaticGenerationEdgeRuntime = isEdgeRuntime(resolveAppPageStaticGenerationRuntime(collectAppPageStaticGenerationRuntimes(tree)));
+	return {
+		dynamicConfig: config.dynamicConfig,
+		dynamicStaleTimeSeconds: config.dynamicStaleTimeSeconds,
+		fetchCacheMode: config.fetchCache ?? null,
+		hasAnyGenerateStaticParams: walkSegments.some((segment) => segment.generateStaticParams),
+		hasGenerateStaticParams,
+		isEdgeRuntime: isEdgeRuntime(config.runtime),
+		isStaticEligible: isAppPageStaticEligible({
+			dynamicConfig: config.dynamicConfig,
+			hasGenerateStaticParams,
+			isDynamicRoute,
+			isStaticGenerationEdgeRuntime,
+			revalidateSeconds: config.revalidateSeconds
+		}),
+		isStaticGenerationEdgeRuntime,
+		revalidateSeconds: config.revalidateSeconds
+	};
+}
+//#endregion
+export { resolveAppPageInterceptSegmentConfig };

package/dist/server/app-page-navigation-params.d.ts

@@ -0,0 +1,23 @@
+import { AppPageParams } from "./app-page-boundary.js";
+//#region src/server/app-page-navigation-params.d.ts
+export type AppPageNavigationParamSlot = {
+  __loadDefault?: unknown;
+  __loadPage?: unknown;
+  default?: unknown;
+  page?: unknown;
+  slotPatternParts?: readonly string[] | null;
+  slotParamNames?: readonly string[] | null;
+};
+type AppPageNavigationParamRoute = {
+  params?: readonly string[] | null;
+  slots?: Readonly<Record<string, AppPageNavigationParamSlot>> | null;
+};
+type AppPageNavigationParamInterceptOptions = {
+  interceptPage?: unknown;
+  interceptParams?: AppPageParams | null;
+  interceptSlotKey?: string | null;
+};
+export declare function resolveSlotParamOverrides(route: AppPageNavigationParamRoute, routePath: string): Readonly<Record<string, AppPageParams>> | null;
+export declare function resolveAppPageNavigationParams(route: AppPageNavigationParamRoute, routeParams: AppPageParams, routePath: string, opts?: AppPageNavigationParamInterceptOptions | null): AppPageParams;
+//#endregion
+export {};

package/dist/server/app-page-navigation-params.js

@@ -0,0 +1,49 @@
+import { matchRoutePattern } from "../routing/route-pattern.js";
+import "./app-rsc-route-matching.js";
+//#region src/server/app-page-navigation-params.ts
+function resolveSlotParamOverrides(route, routePath) {
+	const overrides = {};
+	const slots = route.slots;
+	if (slots) {
+		let urlParts = null;
+		const routeParamSet = collectParamNameSet(route.params);
+		for (const [slotKey, slot] of Object.entries(slots)) {
+			const patternParts = slot.slotPatternParts;
+			const paramNames = slot.slotParamNames;
+			if (!patternParts || patternParts.length === 0) continue;
+			if (paramNames && paramNames.every((name) => routeParamSet.has(name))) continue;
+			if (urlParts === null) urlParts = routePath.split("/").filter(Boolean);
+			const matched = matchRoutePattern(urlParts, patternParts);
+			if (!matched) continue;
+			overrides[slotKey] = matched;
+		}
+	}
+	return Object.keys(overrides).length > 0 ? overrides : null;
+}
+function mergeAppPageParams(target, source) {
+	for (const [key, value] of Object.entries(source)) target[key] = value;
+}
+function isDefaultExportModule(module) {
+	return typeof module === "object" && module !== null;
+}
+function hasDefaultExport(module) {
+	if (!isDefaultExportModule(module)) return false;
+	return module?.default !== null && module?.default !== void 0;
+}
+function resolveAppPageNavigationParams(route, routeParams, routePath, opts) {
+	const navigationParams = { ...routeParams };
+	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
+	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
+		const isInterceptedSlot = opts?.interceptSlotKey === slotKey && opts.interceptSlotKey !== "__vinext_page_intercept" && hasDefaultExport(opts.interceptPage);
+		if (!isInterceptedSlot && !hasDefaultExport(slot.page) && !hasDefaultExport(slot.default) && !slot.__loadPage && !slot.__loadDefault) continue;
+		mergeAppPageParams(navigationParams, isInterceptedSlot ? opts?.interceptParams ?? routeParams : slotParamOverrides?.[slotKey] ?? routeParams);
+	}
+	return navigationParams;
+}
+function collectParamNameSet(params) {
+	const set = /* @__PURE__ */ new Set();
+	if (params) for (const name of params) set.add(name);
+	return set;
+}
+//#endregion
+export { resolveAppPageNavigationParams, resolveSlotParamOverrides };

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

@@ -150,9 +150,12 @@ type RenderAppPageLifecycleOptions = RenderAppPageLifecycleOptionsBase & ({
  * static, draft mode, `force-dynamic`, `revalidate = 0`, or a dynamic API read
  * before the response left the render. Responses that leave the render before
  * its response policy, such as error boundaries and special errors, get the
- * same header as the normal render.
+ * same header as the normal render. One not yet known dynamic is never stored
+ * either, and its body can still reach a dynamic API after its headers leave,
+ * so it is sent like a dynamic render (see resolveUnstoredEarlyResponseCacheControl
+ * for the responses that aren't).
  */
-export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, requestCacheLife?: AppPageRequestCacheLife | null): Response;
+export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isPrerender" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, requestCacheLife?: AppPageRequestCacheLife | null): Response;
 export declare function renderAppPageLifecycle(options: RenderAppPageLifecycleOptions): Promise<Response>;
 //#endregion
 export {};

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

@@ -24,10 +24,10 @@ import { appendRscCompletionMetadata } from "./rsc-completion-metadata.js";
 import { isBailoutToCSRError } from "../shims/navigation-errors.js";
 import { applyClientStaleTimeHeader, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy, resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
+import { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { getAppPageLayoutGate } from "./app-page-layout-gate.js";
 import { hasDigest } from "./app-rsc-errors.js";
 import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
-import { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.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";
@@ -70,11 +70,14 @@ function applyRequestCacheLife(options) {
 * static, draft mode, `force-dynamic`, `revalidate = 0`, or a dynamic API read
 * before the response left the render. Responses that leave the render before
 * its response policy, such as error boundaries and special errors, get the
-* same header as the normal render.
+* same header as the normal render. One not yet known dynamic is never stored
+* either, and its body can still reach a dynamic API after its headers leave,
+* so it is sent like a dynamic render (see resolveUnstoredEarlyResponseCacheControl
+* for the responses that aren't).
 */
 function applyIneligibleRouteCachePolicy(response, options, requestCacheLife = null) {
-	const cacheControl = resolveEarlyResponseCacheControl(options);
 	const isRscRedirect = options.isRscRequest && response.headers.has("X-Vinext-Rsc-Redirect");
+	const cacheControl = resolveEarlyResponseCacheControl(options) ?? (isRscRedirect ? null : resolveUnstoredEarlyResponseCacheControl(response, options));
 	if (!cacheControl) {
 		const staleTimeSeconds = isRscRedirect ? resolveClientStaleTimeSeconds(requestCacheLife) : void 0;
 		if (staleTimeSeconds === void 0) return response;
@@ -108,6 +111,17 @@ function resolveEarlyResponseCacheControl(options) {
 	const ignoresDynamicUsage = (options.isForceStatic || options.isDynamicError) && (options.revalidateSeconds === null || options.revalidateSeconds === Infinity);
 	return options.revalidateSeconds === 0 || !ignoresDynamicUsage && (options.peekDynamicUsage?.() ?? peekDynamicUsage()) ? uncacheable : null;
 }
+/**
+* The normal render can still become a cache entry, so it sends its pending
+* policy until the stream proves it static. An early response never does, and
+* nothing checks it again, so one with a body takes the never-cache header
+* unless it already carries a policy, such as middleware's. A force-static or
+* dynamic = "error" render can't read the request, and dev and the build's
+* prerender, which reads `no-store` as a dynamic render, keep no policy.
+*/
+function resolveUnstoredEarlyResponseCacheControl(response, options) {
+	return options.isProduction && options.isPrerender !== true && !options.isForceStatic && !options.isDynamicError && response.body !== null && !response.headers.has("cache-control") ? NEVER_CACHE_CONTROL : null;
+}
 function resolveAppPageCacheWriteRevalidateSeconds(options) {
 	if (!options.isStaticEligible) return null;
 	if (options.revalidateSeconds === null && (options.isForceStatic || options.isDynamicError)) return Infinity;

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

@@ -100,6 +100,25 @@ type AppPageInterceptMatch<TPage = unknown> = {
   targetPatternParts?: readonly string[];
   targetRouteGraphId?: string | null;
 };
+export type AppPageInterceptState<TRoute, TPage> = {
+  kind: "none";
+} | {
+  kind: "current-route";
+  intercept: AppPageInterceptMatch<TPage>;
+} | {
+  kind: "source-route";
+  intercept: AppPageInterceptMatch<TPage>;
+  sourceRoute: TRoute;
+};
+type AppPageInterceptStateLookup<TRoute, TPage> = {
+  cleanPathname: string;
+  currentRoute: TRoute;
+  findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  /** The state this request already resolved, which is then reused. */
+  interceptState?: AppPageInterceptState<TRoute, TPage>;
+  isRscRequest: boolean;
+};
 type ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts> = {
   cleanPathname: string;
   currentParams: AppPageParams;
@@ -107,6 +126,7 @@ type ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOp
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
   getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  interceptState?: AppPageInterceptState<TRoute, TPage>;
   isRscRequest: boolean;
   toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
 };
@@ -128,10 +148,11 @@ type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
   getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  interceptState?: AppPageInterceptState<TRoute, TPage>;
   isRscRequest: boolean;
   resolveNavigationParams: (route: TRoute, params: AppPageParams, pathname: string, interceptOpts: TInterceptOpts) => AppPageParams;
-  renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
-  resolveSearchParams?: (route: TRoute, searchParams: URLSearchParams) => Awaitable<URLSearchParams>;
+  renderInterceptResponse: (route: TRoute, element: TElement, navigationParams: AppPageParams) => Promise<Response> | Response;
+  resolveSearchParams?: (route: TRoute, searchParams: URLSearchParams, interceptOpts: TInterceptOpts) => Awaitable<URLSearchParams>;
   searchParams: URLSearchParams;
   setNavigationContext: (context: {
     params: AppPageParams;
@@ -146,6 +167,7 @@ type ResolveAppPageInterceptResult<TInterceptOpts> = {
 };
 export declare function resolveAppPageGenerateStaticParamsSources(options: ResolveAppPageGenerateStaticParamsSourcesOptions): GenerateStaticParamsSource[];
 export declare function validateAppPageDynamicParams(options: ValidateAppPageDynamicParamsOptions): Promise<Response | null>;
+export declare function resolveAppPageInterceptState<TRoute, TPage>(options: AppPageInterceptStateLookup<TRoute, TPage>): Promise<AppPageInterceptState<TRoute, TPage>>;
 export declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>>;
 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>>;

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

@@ -278,6 +278,7 @@ async function validateAppPageDynamicParams(options) {
 	return null;
 }
 async function resolveAppPageInterceptState(options) {
+	if (options.interceptState) return options.interceptState;
 	if (!options.isRscRequest) return { kind: "none" };
 	const intercept = options.findIntercept(options.cleanPathname);
 	if (!intercept) return { kind: "none" };
@@ -301,10 +302,9 @@ async function resolveAppPageInterceptionRerenderTarget(options) {
 		cleanPathname: options.cleanPathname,
 		currentRoute: options.currentRoute,
 		findIntercept: options.findIntercept,
-		getRouteParamNames: options.getRouteParamNames,
 		getSourceRoute: options.getSourceRoute,
-		isRscRequest: options.isRscRequest,
-		toInterceptOpts: options.toInterceptOpts
+		interceptState: options.interceptState,
+		isRscRequest: options.isRscRequest
 	});
 	if (interceptState.kind === "source-route") {
 		const sourceMatchedParams = interceptState.intercept.sourceMatchedParams ?? interceptState.intercept.matchedParams;
@@ -333,10 +333,9 @@ async function resolveAppPageIntercept(options) {
 		cleanPathname: options.cleanPathname,
 		currentRoute: options.currentRoute,
 		findIntercept: options.findIntercept,
-		getRouteParamNames: options.getRouteParamNames,
 		getSourceRoute: options.getSourceRoute,
-		isRscRequest: options.isRscRequest,
-		toInterceptOpts: options.toInterceptOpts
+		interceptState: options.interceptState,
+		isRscRequest: options.isRscRequest
 	});
 	if (interceptState.kind === "source-route") {
 		const renderRoute = interceptState.sourceRoute;
@@ -346,17 +345,18 @@ async function resolveAppPageIntercept(options) {
 			...sourceMatchedParams,
 			...interceptState.intercept.matchedParams
 		};
-		const renderSearchParams = options.resolveSearchParams ? await options.resolveSearchParams(renderRoute, options.searchParams) : options.searchParams;
+		const renderSearchParams = options.resolveSearchParams ? await options.resolveSearchParams(renderRoute, options.searchParams, interceptOpts) : options.searchParams;
 		const renderParams = pickRouteParams(sourceMatchedParams, options.getRouteParamNames(interceptState.sourceRoute));
+		const resolvedNavigationParams = options.resolveNavigationParams(renderRoute, navigationParams, options.cleanPathname, interceptOpts);
 		options.setNavigationContext({
-			params: options.resolveNavigationParams(renderRoute, navigationParams, options.cleanPathname, interceptOpts),
+			params: resolvedNavigationParams,
 			pathname: options.cleanPathname,
 			searchParams: renderSearchParams
 		});
 		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, renderSearchParams);
 		return {
 			interceptOpts: void 0,
-			response: await options.renderInterceptResponse(renderRoute, interceptElement)
+			response: await options.renderInterceptResponse(renderRoute, interceptElement, resolvedNavigationParams)
 		};
 	}
 	return {
@@ -385,4 +385,4 @@ async function buildAppPageElement(options) {
 	}
 }
 //#endregion
-export { buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };
+export { buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptState, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };

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

@@ -35,6 +35,8 @@ export type AppPageRouteWiringSlot<TModule extends AppPageModule = AppPageModule
   configLayouts?: readonly (TModule | null | undefined)[] | null;
   configLayoutTreePositions?: readonly number[] | null;
   error?: TErrorModule | null;
+  errors?: readonly (TErrorModule | null | undefined)[] | null;
+  errorTreePositions?: readonly number[] | null;
   layout?: TModule | null;
   layoutIndex: number;
   loading?: TModule | null;
@@ -99,6 +101,8 @@ export type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModul
     id: string;
     ownerTreePath: string;
     state: AppElementsSlotBinding["state"];
+    /** A slot sub-route whose children its route segments don't describe. */
+    synthetic?: boolean;
   } | null;
   /**
    * Static sibling segment names at each dynamic URL level for this route. Used
@@ -241,6 +245,12 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
     sourceRouteGraphId: string;
   }> | null;
   semanticInterceptionTargetRouteId?: string | null;
+  /**
+   * A sibling intercept's segment state keys, app root first, down to the
+   * segment its page element renders. Its BFCache segment levels follow these
+   * rather than the source route's segments.
+   */
+  siblingInterceptSegmentKeys?: readonly string[] | null;
   sourcePageSegments?: readonly string[] | null;
 };
 export type AppPageTemplateEntry<TModule extends AppPageModule = AppPageModule> = {