vinext 0.1.7 → 0.1.8

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

@@ -1,6 +1,6 @@
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { mergeMetadataEntries, mergeViewport, postProcessMetadata, resolveModuleMetadata as resolveModuleMetadata$1, resolveModuleViewport } from "../shims/metadata.js";
-import { resolveAppPageSegmentParams } from "./app-page-params.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { tagAppPageMetadataError } from "./app-page-execution.js";
 //#region src/server/app-page-head.ts
 /**
@@ -24,23 +24,44 @@ async function resolveModuleMetadata(...args) {
 }
 function resolveActiveParallelRouteHeadInputs(options) {
 	return Object.entries(options.slots ?? {}).map(([slotKey, slot]) => {
-		if (options.interceptSlotKey === slotKey && options.interceptPage) return {
-			layoutModules: options.interceptLayouts ?? [],
-			pageModule: options.interceptPage,
-			params: options.interceptParams ?? options.params,
-			routeSegments: options.routeSegments
-		};
+		const ownerTreePosition = options.layoutTreePositions?.[slot.layoutIndex ?? 0] ?? 0;
+		const ownerParams = resolveAppPageSegmentParams(options.routeSegments, ownerTreePosition, options.params);
+		if (options.interceptSlotKey === slotKey && options.interceptPage) {
+			const interceptLayouts = options.interceptLayouts ?? [];
+			return {
+				layoutModules: [slot.layout, ...interceptLayouts].filter(isPresent),
+				layoutParams: [...slot.layout ? [ownerParams] : [], ...interceptLayouts.filter(isPresent).map((_, index) => {
+					const segments = options.interceptLayoutSegments?.[index] ?? [];
+					return {
+						...ownerParams,
+						...resolveParallelLayoutParams(options.interceptBranchSegments ?? segments, segments.length, options.interceptParams ?? options.params)
+					};
+				})],
+				layoutTreePositions: [...slot.layout ? [0] : [], ...interceptLayouts.filter(isPresent).map(() => options.routeSegments.length)],
+				pageModule: options.interceptPage,
+				params: options.interceptParams ?? options.params,
+				routeSegments: options.routeSegments
+			};
+		}
 		return {
-			layoutModules: slot.layout ? [slot.layout] : [],
+			layoutModules: [slot.layout, ...slot.configLayouts ?? []].filter(isPresent),
+			layoutParams: [...slot.layout ? [ownerParams] : [], ...(slot.configLayoutTreePositions ?? []).map((treePosition) => ({
+				...ownerParams,
+				...resolveParallelLayoutParams(slot.routeSegments ?? options.routeSegments, treePosition, options.slotParams?.[slotKey] ?? options.params)
+			}))],
+			layoutTreePositions: [...slot.layout ? [0] : [], ...slot.configLayoutTreePositions ?? []],
 			pageModule: slot.page,
-			params: options.params,
-			routeSegments: options.routeSegments
+			params: options.slotParams?.[slotKey] ?? options.params,
+			routeSegments: slot.routeSegments ?? options.routeSegments
 		};
 	});
 }
 function isPresent(value) {
 	return value !== null && value !== void 0;
 }
+function resolveParallelLayoutParams(routeSegments, treePosition, params) {
+	return resolveAppPageBranchParams(routeSegments, treePosition, params);
+}
 function hasGenerateMetadata(module) {
 	return typeof module?.generateMetadata === "function";
 }
@@ -111,7 +132,7 @@ async function resolveLayoutViewport(layoutInputs, params, routeSegments) {
 		return resolveModuleViewport(layoutInput.module, layoutParams);
 	}));
 }
-async function resolveParallelRouteHead(parallelRoute, fallbackParams, fallbackRouteSegments, pageSearchParams, parent) {
+async function resolveParallelRouteHead(parallelRoute, fallbackParams, fallbackRouteSegments, pageSearchParams, parent, searchParamsObserver) {
 	const params = parallelRoute.params ?? fallbackParams;
 	const routeSegments = parallelRoute.routeSegments ?? fallbackRouteSegments;
 	const metadataResults = [];
@@ -119,13 +140,15 @@ async function resolveParallelRouteHead(parallelRoute, fallbackParams, fallbackR
 	const metadataSources = [];
 	let accumulatedMetadata = parent;
 	const layoutModules = [...parallelRoute.layoutModules ?? [], parallelRoute.layoutModule].filter(isPresent);
+	const layoutTreePositions = parallelRoute.layoutTreePositions ?? [];
+	const layoutParams = parallelRoute.layoutParams ?? [];
 	const hasDynamicMetadata = layoutModules.some(hasGenerateMetadata) || hasGenerateMetadata(parallelRoute.pageModule);
-	const layoutViewportPromises = layoutModules.map((layoutModule) => resolveModuleViewport(layoutModule, params));
-	const pageViewportPromise = parallelRoute.pageModule ? resolveModuleViewport(parallelRoute.pageModule, params) : Promise.resolve(null);
+	const layoutViewportPromises = layoutModules.map((layoutModule, index) => resolveModuleViewport(layoutModule, layoutParams[index] ?? resolveParallelLayoutParams(routeSegments, layoutTreePositions[index] ?? 0, params)));
+	const pageViewportPromise = parallelRoute.pageModule ? resolveModuleViewport(parallelRoute.pageModule, params, pageSearchParams, searchParamsObserver) : Promise.resolve(null);
 	for (const layoutViewportPromise of layoutViewportPromises) layoutViewportPromise.catch(() => null);
 	pageViewportPromise.catch(() => null);
-	for (const layoutModule of layoutModules) {
-		const layoutMetadata = await resolveModuleMetadata(layoutModule, params, void 0, accumulatedMetadata);
+	for (const [index, layoutModule] of layoutModules.entries()) {
+		const layoutMetadata = await resolveModuleMetadata(layoutModule, layoutParams[index] ?? resolveParallelLayoutParams(routeSegments, layoutTreePositions[index] ?? 0, params), void 0, accumulatedMetadata);
 		metadataResults.push(layoutMetadata);
 		metadataSources.push({
 			metadata: layoutMetadata,
@@ -137,7 +160,7 @@ async function resolveParallelRouteHead(parallelRoute, fallbackParams, fallbackR
 		}
 	}
 	if (parallelRoute.pageModule) {
-		const pageMetadata = await resolveModuleMetadata(parallelRoute.pageModule, params, pageSearchParams, accumulatedMetadata);
+		const pageMetadata = await resolveModuleMetadata(parallelRoute.pageModule, params, pageSearchParams, accumulatedMetadata, searchParamsObserver);
 		metadataResults.push(pageMetadata);
 		metadataSources.push({
 			metadata: pageMetadata,
@@ -170,9 +193,9 @@ async function resolveAppPageHeadInner(options) {
 	layoutMetadataResultsForParent.catch(() => null);
 	const pageParentPromise = layoutMetadataResultsForParent.then((metadataResults) => metadataResults.length > 0 ? mergeMetadataEntries(metadataResults.map((metadata) => ({ metadata }))) : {});
 	pageParentPromise.catch(() => null);
-	const pageMetadataPromise = options.pageModule ? resolveModuleMetadata(options.pageModule, options.params, pageSearchParams, pageParentPromise) : Promise.resolve(null);
-	const pageViewportPromise = options.pageModule ? resolveModuleViewport(options.pageModule, options.params) : Promise.resolve(null);
-	const parallelRouteHeadPromise = Promise.all((options.parallelRoutes ?? []).map((parallelRoute) => resolveParallelRouteHead(parallelRoute, options.params, routeSegments, pageSearchParams, pageParentPromise)));
+	const pageMetadataPromise = options.pageModule ? resolveModuleMetadata(options.pageModule, options.params, pageSearchParams, pageParentPromise, options.searchParamsObserver) : Promise.resolve(null);
+	const pageViewportPromise = options.pageModule ? resolveModuleViewport(options.pageModule, options.params, pageSearchParams, options.searchParamsObserver) : Promise.resolve(null);
+	const parallelRouteHeadPromise = Promise.all((options.parallelRoutes ?? []).map((parallelRoute) => resolveParallelRouteHead(parallelRoute, options.params, routeSegments, pageSearchParams, pageParentPromise, options.searchParamsObserver)));
 	const [layoutMetadataResults, layoutViewportResults, pageMetadata, pageViewport, parallelRouteHeads] = await Promise.all([
 		layoutMetadataPromise,
 		layoutViewportPromise,
@@ -205,9 +228,8 @@ async function resolveAppPageHeadInner(options) {
 	const metadataSources = createMetadataSources(layoutMetadataResults, routeSegments, layoutSourcePositions, pageMetadata, Boolean(options.pageModule));
 	metadataSources.push(...parallelMetadataSources);
 	let metadata = resolvedMetadataBase;
-	if (options.metadataRoutes.length > 0) try {
-		const { applyFileBasedMetadata } = await import("./file-based-metadata.js");
-		metadata = await applyFileBasedMetadata(resolvedMetadataBase, options.routePath, options.params, options.metadataRoutes, {
+	if (options.applyFileBasedMetadata && options.metadataRoutes.length > 0) try {
+		metadata = await options.applyFileBasedMetadata(resolvedMetadataBase, options.routePath, options.params, options.metadataRoutes, {
 			routeSegments,
 			metadataSources,
 			basePath: options.basePath ?? ""

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

@@ -4,5 +4,6 @@ import { AppPageParams } from "./app-page-boundary.js";
 declare function getAppPageSegmentParamName(segment: string): string | null;
 declare function resolveAppPageSegmentParamScopeKeys(routeSegments: readonly string[] | null | undefined, treePosition: number): readonly string[];
 declare function resolveAppPageSegmentParams(routeSegments: readonly string[] | null | undefined, treePosition: number, matchedParams: AppPageParams): AppPageParams;
+declare function resolveAppPageBranchParams(branchSegments: readonly string[], treePosition: number, matchedParams: AppPageParams, scopedSegments?: readonly string[]): AppPageParams;
 //#endregion
-export { getAppPageSegmentParamName, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };
+export { getAppPageSegmentParamName, resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };

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

@@ -35,5 +35,12 @@ function resolveAppPageSegmentParams(routeSegments, treePosition, matchedParams)
 	}
 	return segmentParams;
 }
+function resolveAppPageBranchParams(branchSegments, treePosition, matchedParams, scopedSegments = branchSegments) {
+	const branchParamNames = new Set(branchSegments.map(getAppPageSegmentParamName).filter((name) => name !== null));
+	const scopedParams = {};
+	for (const [name, value] of Object.entries(matchedParams)) if (!branchParamNames.has(name)) scopedParams[name] = value;
+	Object.assign(scopedParams, resolveAppPageSegmentParams(scopedSegments, treePosition, matchedParams));
+	return scopedParams;
+}
 //#endregion
-export { getAppPageSegmentParamName, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };
+export { getAppPageSegmentParamName, resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };

package/dist/server/app-page-ppr-runtime.d.ts

@@ -0,0 +1,7 @@
+import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.js";
+import { AppPageDispatchRoute, AppPagePprRuntime } from "./app-page-dispatch.js";
+
+//#region src/server/app-page-ppr-runtime.d.ts
+declare const appPagePprRuntime: AppPagePprRuntime<AppPageDispatchRoute>;
+//#endregion
+export { appPagePprRuntime, createAppPprFallbackShells };

package/dist/server/app-page-ppr-runtime.js

@@ -0,0 +1,70 @@
+import { beginPprFallbackShellFinalRender, createPprFallbackShellState, getPprFallbackShellState, runWithPprFallbackShellState } from "../shims/ppr-fallback-shell.js";
+import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.js";
+import { hasSearchParams, shouldReadAppPageCache } from "./app-page-dispatch.js";
+//#region src/server/app-page-ppr-runtime.ts
+function classifyPprFallbackShellEligibility(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) {
+	if (options.renderedConcreteUrlPaths?.has(options.cleanPathname) === true) return { kind: "skip-known-pregenerated-route" };
+	const fallbackShells = options.pprFallbackCacheShells;
+	if (!fallbackShells || fallbackShells.length === 0) return { kind: "skip-no-fallback-shells" };
+	if (options.isRscRequest) return { kind: "skip-rsc-request" };
+	if (options.request.method !== "GET") return { kind: "skip-non-get" };
+	if (!isForceStatic && hasSearchParams(options.searchParams)) return { kind: "skip-search-params" };
+	if (!shouldReadAppPageCache({
+		isDraftMode,
+		isForceDynamic,
+		isProgressiveActionRender: options.isProgressiveActionRender === true,
+		isProduction: options.isProduction,
+		isRscRequest: false,
+		revalidateSeconds: currentRevalidateSeconds,
+		scriptNonce: options.scriptNonce
+	})) return { kind: "skip-cache-disabled" };
+	return {
+		kind: "probe-fallback-shells",
+		fallbackShells
+	};
+}
+async function probePprFallbackShellCache(options, fallbackShells, currentRevalidateSeconds) {
+	const { readAppPageFallbackShellCacheResponse } = await import("./app-page-cache.js");
+	const { rewriteAppPprFallbackShellHtmlNavigation } = await import("./app-ppr-fallback-shell.js");
+	for (const fallbackShell of fallbackShells) {
+		const fallbackShellResponse = await readAppPageFallbackShellCacheResponse({
+			clearRequestContext: options.clearRequestContext,
+			expireSeconds: options.expireSeconds,
+			fallbackPathname: fallbackShell.pathname,
+			isEdgeRuntime: options.isEdgeRuntime,
+			isrDebug: options.isrDebug,
+			isrGet: options.isrGet,
+			isrHtmlKey: options.isrHtmlKey,
+			middlewareHeaders: options.middlewareContext.headers,
+			middlewareStatus: options.middlewareContext.status,
+			revalidateSeconds: currentRevalidateSeconds ?? 0,
+			rewriteHtml(html) {
+				return rewriteAppPprFallbackShellHtmlNavigation({
+					html,
+					params: options.params,
+					pathname: options.cleanPathname,
+					searchParams: options.searchParams
+				});
+			}
+		});
+		if (fallbackShellResponse) return fallbackShellResponse;
+	}
+	return null;
+}
+const appPagePprRuntime = {
+	beginFinalRender: beginPprFallbackShellFinalRender,
+	getState: getPprFallbackShellState,
+	run(shell, fn) {
+		return runWithPprFallbackShellState(createPprFallbackShellState(shell), fn);
+	},
+	async tryServe(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) {
+		const decision = classifyPprFallbackShellEligibility(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic);
+		return decision.kind === "probe-fallback-shells" ? probePprFallbackShellCache(options, decision.fallbackShells, currentRevalidateSeconds) : null;
+	},
+	async warm(options) {
+		const { warmPprFallbackShellCaches } = await import("./app-ppr-fallback-shell-render.js");
+		await warmPprFallbackShellCaches(options);
+	}
+};
+//#endregion
+export { appPagePprRuntime, createAppPprFallbackShells };

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

@@ -119,6 +119,7 @@ type ProbeAppPageBeforeRenderResult = {
 };
 type ProbeAppPageBeforeRenderOptions = {
   hasLoadingBoundary: boolean;
+  probePageBeforeRender?: boolean;
   skipProbes?: boolean;
   layoutCount: number;
   probeLayoutAt: (layoutIndex: number) => unknown;

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

@@ -252,7 +252,7 @@ async function probeAppPageBeforeRender(options) {
 			layoutFlags
 		};
 	}
-	if (options.hasLoadingBoundary) return {
+	if (options.hasLoadingBoundary || options.probePageBeforeRender === false) return {
 		response: null,
 		layoutFlags
 	};

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

@@ -37,6 +37,7 @@ type RenderAppPageLifecycleOptions = {
   cleanPathname: string;
   clearRequestContext: () => void;
   consumeDynamicUsage: () => boolean;
+  peekDynamicUsage?: () => boolean;
   consumeRenderObservationState?: () => AppPageRenderObservationState; /** Read and clear any invalid dynamic usage error recorded during render (dev-only). */
   consumeInvalidDynamicUsageError?: () => unknown;
   createRscOnErrorHandler: (pathname: string, routePath: string) => AppPageBoundaryOnError;
@@ -60,6 +61,8 @@ type RenderAppPageLifecycleOptions = {
   isProgressiveActionRender?: boolean;
   isPrerender?: boolean;
   isProduction: boolean;
+  probePageBeforeRender?: boolean;
+  omitPendingDynamicCacheState?: boolean;
   isRscRequest: boolean;
   isrDebug?: AppPageDebugLogger;
   isrHtmlKey: (pathname: string) => string;
@@ -81,7 +84,7 @@ type RenderAppPageLifecycleOptions = {
   expireSeconds?: number;
   formState?: ReactFormState | null;
   revalidateSeconds: number | null;
-  renderErrorBoundaryResponse: (error: unknown) => Promise<Response | null>;
+  renderErrorBoundaryResponse: (error: unknown, errorOrigin: "rsc" | "ssr") => Promise<Response | null>;
   renderLayoutSpecialError: (specialError: AppPageSpecialError, layoutIndex: number) => Promise<Response>;
   renderPageSpecialError: (specialError: AppPageSpecialError) => Promise<Response>;
   renderToReadableStream: (element: ReactNode | AppOutgoingElements, options: {

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

@@ -248,8 +248,11 @@ function wrapRscResponseForDevErrorReporting(response, consumeInvalidDynamicUsag
 	});
 }
 async function renderAppPageLifecycle(options) {
+	const configuredProbePageBeforeRender = options.probePageBeforeRender ?? options.isRscRequest;
+	const probePageBeforeRender = options.isRscRequest || configuredProbePageBeforeRender && !(options.peekDynamicUsage?.() ?? false);
 	const preRenderResult = await probeAppPageBeforeRender({
 		hasLoadingBoundary: options.hasLoadingBoundary,
+		probePageBeforeRender,
 		skipProbes: options.pprFallbackShellSignal !== void 0,
 		layoutCount: options.layoutCount,
 		probeLayoutAt(layoutIndex) {
@@ -430,7 +433,8 @@ async function renderAppPageLifecycle(options) {
 			if (!options.isProduction) renderEnd = performance.now();
 		},
 		renderErrorBoundaryResponse(error) {
-			return options.renderErrorBoundaryResponse(rscErrorTracker.getCapturedError() ?? error);
+			const capturedRscError = rscErrorTracker.getCapturedError();
+			return options.renderErrorBoundaryResponse(capturedRscError ?? error, capturedRscError === null ? "ssr" : "rsc");
 		},
 		async renderHtmlStream() {
 			const ssrHandler = await options.loadSsrHandler();
@@ -462,7 +466,7 @@ async function renderAppPageLifecycle(options) {
 	if (!htmlStream) throw new Error("[vinext] Expected an HTML stream when no fallback response was returned");
 	const linkHeader = buildAppPageLinkHeader(htmlRender.linkHeader, fontLinkHeader, options.reactMaxHeadersLength);
 	if (options.isPrerender === true) await htmlRender.metadataReady;
-	if (options.hasLoadingBoundary) {
+	if (options.hasLoadingBoundary || !probePageBeforeRender) {
 		const captured = rscErrorTracker.getCapturedSpecialError();
 		if (captured) {
 			const specialError = resolveAppPageSpecialError(captured);
@@ -480,8 +484,8 @@ async function renderAppPageLifecycle(options) {
 			revalidateSeconds
 		}));
 	}
+	let dynamicUsedDuringRender = options.consumeDynamicUsage();
 	const draftCookie = options.getDraftModeCookieHeader();
-	const dynamicUsedDuringRender = options.consumeDynamicUsage();
 	let dynamicUsedBeforeContextCleanup = dynamicUsedDuringRender;
 	const safeHtmlStream = deferUntilStreamConsumed(htmlStream, () => {
 		dynamicUsedBeforeContextCleanup = dynamicUsedBeforeContextCleanup || options.consumeDynamicUsage();
@@ -575,6 +579,7 @@ async function renderAppPageLifecycle(options) {
 			isrRscKey: options.isrRscKey,
 			isrSet: options.isrSet,
 			interceptionContext: options.interceptionContext,
+			omitPendingDynamicCacheState: options.omitPendingDynamicCacheState,
 			preserveClientResponseHeaders: !htmlResponsePolicy.shouldWriteToCache,
 			expireSeconds,
 			revalidateSeconds,

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

@@ -40,8 +40,11 @@ type BuildAppPageElementResult<TElement> = {
 };
 type AppPageInterceptMatch<TPage = unknown> = {
   interceptLayouts?: readonly unknown[] | null;
+  interceptLayoutSegments?: readonly (readonly string[])[] | null;
+  interceptBranchSegments?: readonly string[] | null;
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   matchedParams: AppPageParams;
+  sourceMatchedParams?: AppPageParams;
   page: TPage;
   __pageLoader?: (() => Promise<TPage>) | null;
   __loadState?: {
@@ -88,7 +91,10 @@ type ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts> = {
 type ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>;
 type ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>;
 type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
-  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker) => Promise<TElement>;
+  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker, buildOptions?: {
+    observeMetadataSearchParamsAccess?: boolean;
+    observePageSearchParamsAccess?: boolean;
+  }) => Promise<TElement>;
   cleanPathname: string;
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
@@ -98,6 +104,7 @@ type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
   layoutParamAccess?: AppLayoutParamAccessTracker;
   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>;
   searchParams: URLSearchParams;
   setNavigationContext: (context: {
     params: AppPageParams;

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

@@ -97,7 +97,7 @@ async function resolveAppPageInterceptMatch(options) {
 	return {
 		interceptOpts: options.toInterceptOpts(interceptState.intercept),
 		matchedParams: interceptState.intercept.matchedParams,
-		sourceParams: pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
+		sourceParams: pickRouteParams(interceptState.intercept.sourceMatchedParams ?? interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
 		sourceRoute: interceptState.sourceRoute
 	};
 }
@@ -145,12 +145,18 @@ async function resolveAppPageInterceptionRerenderTarget(options) {
 		isRscRequest: options.isRscRequest,
 		toInterceptOpts: options.toInterceptOpts
 	});
-	if (interceptState.kind === "source-route") return {
-		interceptOpts: options.toInterceptOpts(interceptState.intercept),
-		navigationParams: interceptState.intercept.matchedParams,
-		params: pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
-		route: interceptState.sourceRoute
-	};
+	if (interceptState.kind === "source-route") {
+		const sourceMatchedParams = interceptState.intercept.sourceMatchedParams ?? interceptState.intercept.matchedParams;
+		return {
+			interceptOpts: options.toInterceptOpts(interceptState.intercept),
+			navigationParams: {
+				...sourceMatchedParams,
+				...interceptState.intercept.matchedParams
+			},
+			params: pickRouteParams(sourceMatchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
+			route: interceptState.sourceRoute
+		};
+	}
 	return {
 		interceptOpts: interceptState.kind === "current-route" ? options.toInterceptOpts(interceptState.intercept) : void 0,
 		navigationParams: options.currentParams,
@@ -174,13 +180,19 @@ async function resolveAppPageIntercept(options) {
 	if (interceptState.kind === "source-route") {
 		const renderRoute = interceptState.sourceRoute;
 		const interceptOpts = options.toInterceptOpts(interceptState.intercept);
-		const renderParams = pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute));
+		const sourceMatchedParams = interceptState.intercept.sourceMatchedParams ?? interceptState.intercept.matchedParams;
+		const navigationParams = {
+			...sourceMatchedParams,
+			...interceptState.intercept.matchedParams
+		};
+		const renderSearchParams = options.resolveSearchParams ? await options.resolveSearchParams(renderRoute, options.searchParams) : options.searchParams;
+		const renderParams = pickRouteParams(sourceMatchedParams, options.getRouteParamNames(interceptState.sourceRoute));
 		options.setNavigationContext({
-			params: options.resolveNavigationParams(renderRoute, interceptState.intercept.matchedParams, options.cleanPathname, interceptOpts),
+			params: options.resolveNavigationParams(renderRoute, navigationParams, options.cleanPathname, interceptOpts),
 			pathname: options.cleanPathname,
-			searchParams: options.searchParams
+			searchParams: renderSearchParams
 		});
-		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, options.searchParams, options.layoutParamAccess);
+		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, renderSearchParams, options.layoutParamAccess);
 		return {
 			interceptOpts: void 0,
 			response: await options.renderInterceptResponse(renderRoute, interceptElement)

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

@@ -2,9 +2,9 @@ import { AppRouteSemanticIds } from "../routing/app-route-graph.js";
 import { AppElements, AppElementsInterception } from "./app-elements-wire.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { ThenableParamsObserver } from "../shims/thenable-params.js";
+import { Metadata, Viewport } from "../shims/metadata.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
-import { Metadata, Viewport } from "../shims/metadata.js";
 import { AppPageRenderIdentity } from "./app-page-render-identity.js";
 import { resolveAppPageChildSegments } from "./app-page-segment-state.js";
 import { ComponentType, ReactNode } from "react";
@@ -31,6 +31,8 @@ type AppPageRouteWiringSlot<TModule extends AppPageModule = AppPageModule, TErro
   /** Graph-owned semantic slot identity. */id?: string | null; /** Slot prop name passed to the owning layout (e.g. "modal" from @modal). */
   name: string;
   default?: TModule | null;
+  configLayouts?: readonly (TModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
   error?: TErrorModule | null;
   layout?: TModule | null;
   layoutIndex: number;
@@ -83,6 +85,8 @@ type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModule, TErr
   templates?: readonly (TModule | null | undefined)[] | null;
 };
 type AppPageSlotOverride<TModule extends AppPageModule = AppPageModule> = {
+  branchSegments?: readonly string[] | null;
+  layoutSegments?: readonly (readonly string[])[] | null;
   layoutModules?: readonly (TModule | null | undefined)[] | null;
   /**
    * The page module to render for this slot. Optional — when omitted, the
@@ -118,6 +122,7 @@ 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;
   searchParams?: unknown;
   slotOverrides?: Readonly<Record<string, AppPageSlotOverride<TModule>>> | null;
 };

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

@@ -8,7 +8,7 @@ import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead, renderMetadataToHtml } from "../shims/metadata.js";
 import { Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
-import { resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { probeReactServerSubtree } from "./app-page-probe.js";
 import { resolveAppPageChildSegments, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey } from "./app-page-segment-state.js";
 import { Fragment, Suspense } from "react";
@@ -16,6 +16,9 @@ import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/server/app-page-route-wiring.tsx
 const APP_PAGE_LAYOUT_PROBE_CHILD = /* @__PURE__ */ jsx(Fragment, {});
 const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
+function resolveSlotLayoutParams(routeSegments, treePosition, params) {
+	return resolveAppPageBranchParams(routeSegments, treePosition, params);
+}
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -293,7 +296,9 @@ function buildAppPageElements(options) {
 		const slotId = resolveAppPageSlotId(slot, layoutEntries[targetIndex]?.treePath ?? "/");
 		const slotOverride = resolveSlotOverride(slotKey, slotName);
 		const slotParams = getEffectiveSlotParams(slotKey, slotName);
-		const slotResetKey = resolveAppPageRouteStateKey(slot.routeSegments ?? [], slotParams);
+		const slotRouteSegments = slot.routeSegments ?? [];
+		const slotOwnerParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntries[targetIndex]?.treePosition ?? 0, options.matchedParams);
+		const slotResetKey = resolveAppPageRouteStateKey(slotRouteSegments, slotParams);
 		const overrideOrPageComponent = getDefaultExport(slotOverride?.pageModule) ?? getDefaultExport(slot.page);
 		const defaultComponent = getDefaultExport(slot.default);
 		if (!overrideOrPageComponent && defaultComponent && options.isRscRequest && options.mountedSlotIds?.has(slotId)) continue;
@@ -302,23 +307,40 @@ function buildAppPageElements(options) {
 			elements[slotId] = AppElementsWire.unmatchedSlotValue;
 			continue;
 		}
-		const slotThenableParams = options.makeThenableParams(slotParams);
-		const slotProps = { params: slotThenableParams };
+		const slotProps = { params: options.makeThenableParams(slotParams) };
 		if (options.searchParams !== void 0) slotProps.searchParams = options.searchParams;
 		if (slotOverride?.props) Object.assign(slotProps, slotOverride.props);
-		let slotElement = /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
+		let slotElement = options.createPageElement ? options.createPageElement(slotComponent, slotProps) : (() => {
+			return /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
+		})();
+		const hasSlotTreeOverride = slotOverride?.pageModule != null || slotOverride?.layoutModules !== void 0;
 		const interceptLayouts = slotOverride?.layoutModules ?? [];
 		for (let layoutIndex = interceptLayouts.length - 1; layoutIndex >= 0; layoutIndex--) {
 			const interceptLayoutComponent = getDefaultExport(interceptLayouts[layoutIndex]);
 			if (!interceptLayoutComponent) continue;
-			slotElement = /* @__PURE__ */ jsx(interceptLayoutComponent, {
-				params: slotThenableParams,
+			const InterceptLayoutComponent = interceptLayoutComponent;
+			const interceptLayoutParams = resolveSlotLayoutParams(slotOverride?.branchSegments ?? slotRouteSegments, slotOverride?.layoutSegments?.[layoutIndex]?.length ?? slotRouteSegments.length, slotParams);
+			slotElement = /* @__PURE__ */ jsx(InterceptLayoutComponent, {
+				params: options.makeThenableParams(interceptLayoutParams),
+				children: slotElement
+			});
+		}
+		if (!hasSlotTreeOverride) for (let layoutIndex = (slot.configLayouts?.length ?? 0) - 1; layoutIndex >= 0; layoutIndex--) {
+			const nestedLayoutComponent = getDefaultExport(slot.configLayouts?.[layoutIndex]);
+			if (!nestedLayoutComponent) continue;
+			const NestedLayoutComponent = nestedLayoutComponent;
+			const nestedLayoutParams = resolveSlotLayoutParams(slotRouteSegments, slot.configLayoutTreePositions?.[layoutIndex] ?? 0, slotParams);
+			slotElement = /* @__PURE__ */ jsx(NestedLayoutComponent, {
+				params: options.makeThenableParams({
+					...slotOwnerParams,
+					...nestedLayoutParams
+				}),
 				children: slotElement
 			});
 		}
 		const slotLayoutComponent = getDefaultExport(slot.layout);
 		if (slotLayoutComponent) slotElement = /* @__PURE__ */ jsx(slotLayoutComponent, {
-			params: slotThenableParams,
+			params: options.makeThenableParams(slotOwnerParams),
 			children: slotElement
 		});
 		const slotLoadingComponent = getDefaultExport(slot.loading);

package/dist/server/app-page-search-params-observation.d.ts

@@ -1,10 +1,12 @@
-import { ThenableParams } from "../shims/thenable-params.js";
+import { ThenableParams, ThenableParamsObserver } from "../shims/thenable-params.js";
 import { AppPageSearchParams } from "./app-page-head.js";
 
 //#region src/server/app-page-search-params-observation.d.ts
 type AppPageSearchParamsObservationOptions = {
+  markDynamic?: boolean;
   observeReactPromiseStatus?: boolean;
 };
+declare function createAppPageSearchParamsObserver(options?: AppPageSearchParamsObservationOptions): ThenableParamsObserver;
 declare function makeObservedAppPageSearchParamsThenable(pageSearchParams: AppPageSearchParams, options?: AppPageSearchParamsObservationOptions): ThenableParams<AppPageSearchParams>;
 //#endregion
-export { makeObservedAppPageSearchParamsThenable };
+export { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable };

package/dist/server/app-page-search-params-observation.js

@@ -1,15 +1,19 @@
-import { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope } from "../shims/headers.js";
+import { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope, throwIfStaticGenerationAccessError } from "../shims/headers.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 //#region src/server/app-page-search-params-observation.ts
-function markAppPageSearchParamsAccess() {
+function markAppPageSearchParamsAccess(markDynamic) {
+	throwIfStaticGenerationAccessError();
 	throwIfInsideCacheScope("searchParams");
-	markDynamicUsage();
+	if (markDynamic) markDynamicUsage();
 	markRenderRequestApiUsage("searchParams");
 }
-function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {}) {
-	const observer = { observeParamAccess() {
-		markAppPageSearchParamsAccess();
+function createAppPageSearchParamsObserver(options = {}) {
+	return { observeParamAccess() {
+		markAppPageSearchParamsAccess(options.markDynamic !== false);
 	} };
+}
+function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {}) {
+	const observer = createAppPageSearchParamsObserver(options);
 	if (options.observeReactPromiseStatus === true) return makeThenableParams(pageSearchParams, {
 		...observer,
 		observeReactPromiseStatus: true
@@ -17,4 +21,4 @@ function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {})
 	return makeThenableParams(pageSearchParams, observer);
 }
 //#endregion
-export { makeObservedAppPageSearchParamsThenable };
+export { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable };

package/dist/server/app-ppr-fallback-shell-render.d.ts

@@ -4,7 +4,7 @@ import { ReactNode } from "react";
 //#region src/server/app-ppr-fallback-shell-render.d.ts
 type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 type AppPageRenderableElement = ReactNode | Record<string, ReactNode>;
-declare function warmPprFallbackShellCaches(options: {
+type WarmPprFallbackShellCachesOptions = {
   element: AppPageRenderableElement;
   onError: AppPageBoundaryOnError;
   renderToReadableStream: (element: AppPageRenderableElement, options: {
@@ -12,6 +12,7 @@ declare function warmPprFallbackShellCaches(options: {
     signal?: AbortSignal;
   }) => ReadableStream<Uint8Array>;
   state: PprFallbackShellState;
-}): Promise<void>;
+};
+declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
 //#endregion
-export { warmPprFallbackShellCaches };
+export { WarmPprFallbackShellCachesOptions, warmPprFallbackShellCaches };

package/dist/server/app-route-handler-dispatch.js

@@ -24,6 +24,7 @@ function buildRouteHandlerPageCacheTags(pathname, extraTags, routeSegments) {
 async function runInRouteHandlerRevalidationContext(options, renderFn) {
 	await runWithRequestContext(createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
+			draftModeEnabled: false,
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",

package/dist/server/app-route-handler-execution.js

@@ -1,4 +1,4 @@
-import { setHeadersContext } from "../shims/headers.js";
+import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
@@ -8,6 +8,7 @@ import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidat
 function configureAppRouteStaticGenerationContext(options) {
 	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {
 		setHeadersContext(createStaticGenerationHeadersContext({
+			draftModeEnabled: options.draftModeSecret !== void 0 && isDraftModeRequest(options.request, options.draftModeSecret),
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",

package/dist/server/app-route-module-loader.d.ts

@@ -36,11 +36,13 @@ type LazyLoadableSlot = {
   page?: unknown;
   default?: unknown;
   layout?: unknown;
+  configLayouts?: readonly unknown[];
   loading?: unknown;
   error?: unknown;
   __loadPage?: LazyModuleThunk | null;
   __loadDefault?: LazyModuleThunk | null;
   __loadLayout?: LazyModuleThunk | null;
+  __loadConfigLayouts?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
   __loadError?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];