vinext 1.4.1 → 1.4.3

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
@@ -216,11 +220,7 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
   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.
+   * static cache headers (see app-page-dispatch.ts).
    */
   isUncacheableRender?: boolean;
   /**
@@ -232,6 +232,12 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
   mountedLayouts?: ReadonlySet<string> | null;
   mountedSlotIds?: ReadonlySet<string> | null;
   renderIdentity?: AppPageRenderIdentity;
+  /**
+   * The render has no PPR (see app-page-dispatch.ts), so a loading-shell
+   * prefetch without a loading boundary sends only the route tree. Without it,
+   * the layouts render, as Next.js renders them with isRoutePPREnabled.
+   */
+  routeTreeOnlyPrefetchShell?: boolean;
   renderMode?: AppRscRenderMode;
   routePath: string;
   semanticPageIdentity?: Readonly<{
@@ -241,6 +247,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> = {

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

@@ -514,7 +514,7 @@ function buildAppPageElements(options) {
 		[pageElementId]: null,
 		[routeId]: null
 	};
-	if (isPrefetchLoadingShell && !shouldRenderPrefetchLoadingShell && options.isUncacheableRender === true) return {
+	if (isPrefetchLoadingShell && !shouldRenderPrefetchLoadingShell && options.routeTreeOnlyPrefetchShell === true) return {
 		...metadataEntries,
 		...options.route.staticSiblings && options.route.staticSiblings.length > 0 ? { [APP_STATIC_SIBLINGS_KEY]: options.route.staticSiblings } : {},
 		[pageElementId]: null,
@@ -669,9 +669,11 @@ function buildAppPageElements(options) {
 			branchAccessBoundaries.set(treePosition, entries);
 		}
 		const branchErrors = /* @__PURE__ */ new Map();
-		if (overrideOrPageComponent && hasSlotTreeOverride) for (const [index, errorModule] of (slotOverride?.errorModules ?? []).entries()) {
+		const slotErrorModules = !overrideOrPageComponent ? void 0 : hasSlotTreeOverride ? slotOverride?.errorModules : slot.errors;
+		const slotErrorTreePositions = hasSlotTreeOverride ? slotOverride?.errorTreePositions : slot.errorTreePositions;
+		for (const [index, errorModule] of (slotErrorModules ?? []).entries()) {
 			const component = getErrorBoundaryExport(errorModule);
-			const treePosition = slotOverride?.errorTreePositions?.[index];
+			const treePosition = slotErrorTreePositions?.[index];
 			if (component && treePosition !== void 0) branchErrors.set(treePosition, component);
 		}
 		const resolveSlotNotFoundBoundary = (treePosition) => {
@@ -753,12 +755,6 @@ function buildAppPageElements(options) {
 		])).filter((treePosition) => !prefetchSlotLoadingEntry || !isOwnedAtRoutePrefetchCutoff && treePosition <= prefetchSlotLoadingEntry.treePosition).sort((left, right) => left - right);
 		for (let index = branchTreePositions.length - 1; index >= 0; index--) {
 			const treePosition = branchTreePositions[index];
-			const nestedBfcacheSegment = nestedBfcacheSegments.find((segment) => segment.treePosition === treePosition);
-			if (nestedBfcacheSegment) slotElement = /* @__PURE__ */ jsx(BfcacheSegmentBoundary, {
-				id: nestedBfcacheSegment.id,
-				stateKey: nestedBfcacheSegment.stateKey,
-				children: slotElement
-			});
 			const loadingComponents = prefetchSlotLoadingEntry ? [] : branchLoadings.get(treePosition) ?? [];
 			for (let loadingIndex = loadingComponents.length - 1; loadingIndex >= 0; loadingIndex--) {
 				const LoadingComponent = loadingComponents[loadingIndex];
@@ -786,6 +782,12 @@ function buildAppPageElements(options) {
 				fallback: SegmentErrorComponent,
 				children: slotElement
 			});
+			const nestedBfcacheSegment = nestedBfcacheSegments.find((segment) => segment.treePosition === treePosition);
+			if (nestedBfcacheSegment) slotElement = /* @__PURE__ */ jsx(BfcacheSegmentBoundary, {
+				id: nestedBfcacheSegment.id,
+				stateKey: nestedBfcacheSegment.stateKey,
+				children: slotElement
+			});
 			const layoutEntriesAtPosition = branchLayouts.get(treePosition) ?? [];
 			for (let layoutIndex = layoutEntriesAtPosition.length - 1; layoutIndex >= 0; layoutIndex--) {
 				const layoutEntry = layoutEntriesAtPosition[layoutIndex];
@@ -878,17 +880,19 @@ function buildAppPageElements(options) {
 		children: routeChildren
 	});
 	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 siblingInterceptSegmentKeys = options.siblingInterceptSegmentKeys ?? null;
+	const keepsSegmentLevelLists = String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && firstLayoutWithElementTreePosition !== void 0 && !options.route.childrenSlot?.synthetic && (options.semanticPageIdentity === void 0 || siblingInterceptSegmentKeys !== null);
+	const spineSegmentCount = siblingInterceptSegmentKeys?.length ?? routeSegments.length;
+	const spineTreePositions = keepsSegmentLevelLists ? Array.from(/* @__PURE__ */ new Set([...orderedTreePositions, ...Array.from({ length: Math.max(0, spineSegmentCount - 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;
+	let childSegmentTreePosition = firstLayoutBelowShell?.treePosition ?? spineSegmentCount + 1;
 	const retainChildSegment = (treePosition, children) => treePosition === childSegmentTreePosition - 1 ? /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
 		id: childSegmentElementId,
 		children
 	}) : /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
-		stateKey: createBfcacheChildSegmentStateKey(resolveAppPageTemplateStateKey(routeSegments, treePosition, options.matchedParams)),
+		stateKey: createBfcacheChildSegmentStateKey(siblingInterceptSegmentKeys ? JSON.stringify(siblingInterceptSegmentKeys.slice(0, treePosition + 1)) : resolveAppPageTemplateStateKey(routeSegments, treePosition, options.matchedParams)),
 		children
 	});
 	for (let index = renderedTreePositions.length - 1; index >= 0; index--) {
@@ -977,8 +981,10 @@ function buildAppPageElements(options) {
 	const globalErrorComponent = getErrorBoundaryExport(options.globalErrorModule);
 	routeChildren = /* @__PURE__ */ jsx(GlobalErrorBoundary, {
 		fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+		wrapsGlobalErrorBoundary: globalErrorComponent !== null,
 		children: globalErrorComponent ? /* @__PURE__ */ jsx(ErrorBoundary, {
 			fallback: globalErrorComponent,
+			isGlobalErrorBoundary: true,
 			children: routeChildren
 		}) : routeChildren
 	});

package/dist/server/app-page-segment-plan.js

@@ -1,7 +1,7 @@
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { createNestedBfcacheSlotSegmentId, deriveBfcacheSegmentIdentity } from "./bfcache-identity.js";
-import { resolveAppPageRouteStateKey, resolveAppPageSemanticSegmentStateKey, resolveAppPageTemplateStateKey } from "./app-page-segment-state.js";
+import { APP_PAGE_DEFAULT_SEGMENT_KEY, APP_PAGE_SEGMENT_KEY, resolveAppPageRouteStateKey, resolveAppPageSemanticSegmentStateKey, resolveAppPageTemplateStateKey } from "./app-page-segment-state.js";
 //#region src/server/app-page-segment-plan.ts
 function requireGraphSequenceId(ids, index, kind) {
 	const id = ids[index];
@@ -118,6 +118,14 @@ function createAppPageSegmentPlan(options) {
 					treePosition
 				});
 			}
+			if (semanticSegments.length > 0) {
+				const leafKey = slotBinding.state === "default" ? APP_PAGE_DEFAULT_SEGMENT_KEY : APP_PAGE_SEGMENT_KEY;
+				semanticSegments.push({
+					identityKey: JSON.stringify([...boundSegmentKeys, leafKey]),
+					stateKey: leafKey,
+					treePosition: branchSegments.length
+				});
+			}
 		}
 		const includedInPayload = options.includeSlot(ownerTreePosition, targetTreePosition);
 		const graphId = graphIds ? graphIds.slots[slotKey] : slot.id ?? slotId;

package/dist/server/app-page-segment-state.d.ts

@@ -1,8 +1,17 @@
 import { AppPageParams } from "./app-page-boundary.js";
 //#region src/server/app-page-segment-state.d.ts
 export declare const APP_PAGE_SEGMENT_KEY = "__PAGE__";
+export declare const APP_PAGE_DEFAULT_SEGMENT_KEY = "__DEFAULT__";
 export declare function isAppPageRouteGroupSegment(segment: string): boolean;
 export declare function canonicalizeAppPageParams(params: AppPageParams): void;
+/**
+ * Rebinds segment state keys and BFCache identities resolved with one set of
+ * params to another. Keys are JSON arrays of segment keys, nested to any
+ * depth, so each whole segment key is compared with the param tokens
+ * `resolveSingleSegmentStateKey` produced for the learned params; only those
+ * whose value differs are replaced. Returns null when no token changes.
+ */
+export declare function createAppPageSegmentStateKeyRebinder(fromParams: AppPageParams, toParams: AppPageParams): ((stateKey: string) => string) | null;
 export declare function resolveAppPageChildSegments(routeSegments: readonly string[], treePosition: number, params: AppPageParams): string[];
 export declare function resolveAppPageSegmentStateKey(routeSegments: readonly string[], treePosition: number, params: AppPageParams): string;
 /**

package/dist/server/app-page-segment-state.js

@@ -1,6 +1,7 @@
 import { isCatchAllSegment, isOptionalCatchAllSegment } from "../routing/utils.js";
 //#region src/server/app-page-segment-state.ts
 const APP_PAGE_SEGMENT_KEY = "__PAGE__";
+const APP_PAGE_DEFAULT_SEGMENT_KEY = "__DEFAULT__";
 function isDynamicSegment(segment) {
 	return segment.startsWith("[") && segment.endsWith("]") && !segment.includes(".");
 }
@@ -49,6 +50,58 @@ function resolveSingleSegmentStateKey(segment, params) {
 	if (!param) return segment;
 	return `${param.name}|${formatSegmentStateParamValue(param, params, segment)}|${param.type}`;
 }
+const SEGMENT_PARAM_TYPES = [
+	"d",
+	"c",
+	"oc"
+];
+function formatSegmentParamPattern(param) {
+	if (param.type === "oc") return `[[...${param.name}]]`;
+	if (param.type === "c") return `[...${param.name}]`;
+	return `[${param.name}]`;
+}
+/**
+* Rebinds segment state keys and BFCache identities resolved with one set of
+* params to another. Keys are JSON arrays of segment keys, nested to any
+* depth, so each whole segment key is compared with the param tokens
+* `resolveSingleSegmentStateKey` produced for the learned params; only those
+* whose value differs are replaced. Returns null when no token changes.
+*/
+function createAppPageSegmentStateKeyRebinder(fromParams, toParams) {
+	const tokens = /* @__PURE__ */ new Map();
+	for (const name of /* @__PURE__ */ new Set([...Object.keys(fromParams), ...Object.keys(toParams)])) for (const type of SEGMENT_PARAM_TYPES) {
+		const param = {
+			name,
+			type
+		};
+		const fallbackSegment = formatSegmentParamPattern(param);
+		const from = formatSegmentStateParamValue(param, fromParams, fallbackSegment);
+		const to = formatSegmentStateParamValue(param, toParams, fallbackSegment);
+		if (from !== to) tokens.set(`${name}|${from}|${type}`, `${name}|${to}|${type}`);
+	}
+	if (tokens.size === 0) return null;
+	const rebind = (stateKey) => {
+		const token = tokens.get(stateKey);
+		if (token !== void 0) return token;
+		if (!stateKey.startsWith("[")) return stateKey;
+		let parts;
+		try {
+			parts = JSON.parse(stateKey);
+		} catch {
+			return stateKey;
+		}
+		if (!Array.isArray(parts)) return stateKey;
+		let changed = false;
+		const rebound = parts.map((part) => {
+			if (typeof part !== "string") return part;
+			const next = rebind(part);
+			if (next !== part) changed = true;
+			return next;
+		});
+		return changed ? JSON.stringify(rebound) : stateKey;
+	};
+	return rebind;
+}
 function resolveAppPageChildSegments(routeSegments, treePosition, params) {
 	const rawSegments = routeSegments.slice(treePosition);
 	const resolvedSegments = [];
@@ -104,4 +157,4 @@ function resolveAppPageTemplateStateKey(routeSegments, treePosition, params) {
 	return statePath.length > 0 ? JSON.stringify(statePath) : "";
 }
 //#endregion
-export { APP_PAGE_SEGMENT_KEY, canonicalizeAppPageParams, isAppPageRouteGroupSegment, resolveAppPageChildSegments, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey, resolveAppPageSemanticSegmentStateKey, resolveAppPageTemplateStateKey };
+export { APP_PAGE_DEFAULT_SEGMENT_KEY, APP_PAGE_SEGMENT_KEY, canonicalizeAppPageParams, createAppPageSegmentStateKeyRebinder, isAppPageRouteGroupSegment, resolveAppPageChildSegments, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey, resolveAppPageSemanticSegmentStateKey, resolveAppPageTemplateStateKey };

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

@@ -57,6 +57,12 @@ type RenderPagesFallbackOptions = {
   pathname?: string;
   pagesDataRequest?: Request | null;
   request: Request;
+  /**
+   * The basePath `request.url` still carries. The page renderer receives the
+   * URL without it, as in the Pages Router pipeline, so `req.url` and `asPath`
+   * leave it out like Next.js.
+   */
+  requestBasePath?: string;
   /** The shared cache entry answers every host; a request-time render is not stored. */
   sharedAcrossHosts?: boolean;
   url: URL;