vinext 1.4.1 → 1.4.3

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

@@ -4,8 +4,8 @@ import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js"
 import { getCollectedFetchTags } from "../shims/fetch-cache.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { buildAppPageFontLinkHeader, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
-import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
 import { buildAppPageLinkHeader, createAppPageSsrErrorHandler, isAppSsrRenderResult } from "./app-page-stream.js";
+import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
 import { consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 //#region src/server/app-page-cache-render.ts

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

@@ -15,7 +15,7 @@ import { FetchCacheMode } from "../shims/fetch-cache-state.js";
 import "../shims/fetch-cache.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { WarmPprFallbackShellCachesOptions } from "./app-ppr-fallback-shell-render.js";
-import { ValidateAppPageDynamicParamsOptions } from "./app-page-request.js";
+import { AppPageInterceptState, ValidateAppPageDynamicParamsOptions } from "./app-page-request.js";
 import { ReactNode } from "react";
 import { ReactFormState } from "react-dom/client";
 //#region src/server/app-page-dispatch.d.ts
@@ -96,10 +96,17 @@ type AppPageModule = {
   revalidate?: unknown;
 };
 type AppPageDispatchSlot = {
+  configLayouts?: readonly (AppPageModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
   default?: AppPageModule | null;
+  layout?: AppPageModule | null;
+  layoutIndex?: number;
   loading?: AppPageModule | null;
   loadings?: readonly (AppPageModule | null | undefined)[] | null;
+  name?: string;
+  ownerTreePosition?: number | null;
   page?: AppPageModule | null;
+  routeSegments?: readonly string[] | null;
   slotPatternParts?: readonly string[] | null;
   slotParamNames?: readonly string[] | null;
 };
@@ -159,6 +166,7 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, options?: {
     isForceStatic?: boolean;
     isUncacheableRender?: boolean;
+    routeTreeOnlyPrefetchShell?: boolean;
     /** Layouts the navigating client holds, which the render may leave out. */
     mountedLayouts?: ReadonlySet<string> | null;
     observeMetadataSearchParamsAccess?: boolean;
@@ -184,6 +192,8 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   ensureRouteLoaded?: (route: TRoute) => unknown;
   fetchCache?: FetchCacheMode | null;
   findIntercept: (pathname: string) => AppPageDispatchIntercept | null;
+  /** This request's intercept, which dispatch resolves once before rendering. */
+  interceptState?: AppPageInterceptState<TRoute, unknown>;
   formState?: ReactFormState | null;
   actionError?: unknown;
   actionFailed?: boolean;

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

@@ -1,7 +1,7 @@
 import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import "../utils/protocol-headers.js";
 import { VINEXT_INTERCEPTION_ID_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
-import { VINEXT_MOUNTED_LAYOUTS_HEADER } from "./headers.js";
+import { VINEXT_MOUNTED_LAYOUTS_HEADER, VINEXT_PARAMS_HEADER } from "./headers.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { beginRouteCacheability, isRouteCacheabilityIdentityProbe, isRouteCacheabilityProbe, markRouteCacheabilityPatternDynamic, readRouteCacheabilityState } from "../shims/cacheability-classification.js";
@@ -21,16 +21,17 @@ import { resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildRscRedirectFlightStream } from "./app-rsc-redirect-flight.js";
 import { buildAppPageSpecialErrorResponse, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
 import { resolveAppPageLayoutHttpAccessBoundary, resolveAppPageParentHttpAccessBoundary, resolveAppPageRootHttpAccessBoundaryTreePosition } from "./app-page-boundary.js";
+import { resolveAppPageNavigationParams } from "./app-page-navigation-params.js";
+import { createAppPageRscErrorTracker } from "./app-page-stream.js";
 import { isAppClientReference } from "./app-render-dependency.js";
 import { resolveAppPageTraceOperation } from "./app-page-tracing.js";
-import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
-import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
-import { createAppPageRscErrorTracker } from "./app-page-stream.js";
 import { getDefaultHttpAccessFallbackModule } from "./default-http-access-fallback-modules.js";
+import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
-import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
+import { resolveAppPageInterceptSegmentConfig } from "./app-page-intercept-segment-config.js";
+import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptState, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
 import { applyIneligibleRouteCachePolicy, renderAppPageLifecycle } from "./app-page-render.js";
 //#region src/server/app-page-dispatch.ts
 function getActiveLoadingTreePositions(route) {
@@ -146,12 +147,48 @@ function hasNoManifestAdmissionState(routePattern) {
 	}, admission.representation, admission.routePathname) === null;
 }
 async function dispatchAppPage(options) {
-	const dispatch = () => runWithFetchDedupe(() => dispatchAppPageInner(options));
+	const dispatch = () => runWithFetchDedupe(async () => dispatchAppPageInner(await withResolvedIntercept(options)));
 	let response;
 	if (!options.pprFallbackShell || !options.pprRuntime) response = await dispatch();
 	else response = await options.pprRuntime.run(options.pprFallbackShell, dispatch);
 	return options.isRscRequest ? response : traceResponseStart(response);
 }
+/**
+* Resolves the request's intercept once, for the render and its cache reads.
+*
+* Next.js renders an interception as its own route even when its source is the
+* matched route (`app/shots/[id]` beside `app/shots/@modal/(.)[id]`, from
+* `/shots/1` to `/shots/2`). vinext renders that through the matched route's
+* own page render, so the interception's segment config replaces the route's
+* before that render reads it.
+*/
+async function withResolvedIntercept(options) {
+	const interceptState = await resolveAppPageInterceptState({
+		cleanPathname: options.cleanPathname,
+		currentRoute: options.route,
+		findIntercept: options.findIntercept,
+		getSourceRoute: options.getSourceRoute,
+		interceptState: options.interceptState,
+		isRscRequest: options.isRscRequest
+	});
+	if (interceptState.kind !== "current-route") return {
+		...options,
+		interceptState
+	};
+	const config = resolveAppPageInterceptSegmentConfig(options.route, toInterceptOptions(options.interceptionContext, interceptState.intercept));
+	return {
+		...options,
+		interceptState,
+		dynamicConfig: config.dynamicConfig,
+		dynamicStaleTimeSeconds: config.dynamicStaleTimeSeconds,
+		fetchCache: config.fetchCacheMode,
+		hasAnyGenerateStaticParams: config.hasAnyGenerateStaticParams,
+		hasGenerateStaticParams: config.hasGenerateStaticParams,
+		isEdgeRuntime: config.isEdgeRuntime,
+		isStaticGenerationEdgeRuntime: config.isStaticGenerationEdgeRuntime,
+		revalidateSeconds: config.revalidateSeconds
+	};
+}
 async function dispatchAppPageInner(options) {
 	const route = options.route;
 	beginRouteCacheability("app-page", route.pattern);
@@ -206,6 +243,7 @@ async function dispatchAppPageInner(options) {
 			isDynamicError,
 			isForceDynamic,
 			isForceStatic,
+			isPrerender,
 			isProduction: options.isProduction,
 			isProgressiveActionRender: options.isProgressiveActionRender === true,
 			isRscRequest: options.isRscRequest,
@@ -255,7 +293,8 @@ async function dispatchAppPageInner(options) {
 	const isOnDemandRevalidate = _isOnDemandRevalidate();
 	const shouldReadCache = isStoredRender && !isOnDemandRevalidate;
 	const isCacheCandidate = isCacheEligibleRender && isStaticEligible && options.pprFallbackShell === void 0 && !isNeverStoredPath;
-	const isUncacheableRender = !(isCacheEligibleRender && isStaticEligible) && options.pprFallbackShell === void 0 && (options.pprRuntime === void 0 || !options.isProduction);
+	const routeTreeOnlyPrefetchShell = options.pprFallbackShell === void 0 && (options.pprRuntime === void 0 || !options.isProduction);
+	const isUncacheableRender = !(isCacheEligibleRender && isStaticEligible) && routeTreeOnlyPrefetchShell;
 	const mountedLayouts = isUncacheableRender && options.isRscRequest && (options.renderMode ?? "navigation") === "navigation" && options.interceptionContext === null && options.isProgressiveActionRender !== true ? parseMountedLayoutsHeader(options.request.headers.get(VINEXT_MOUNTED_LAYOUTS_HEADER)) : null;
 	if (shouldReadCache && isStaticEligible) {
 		traceOperation = resolveAppPageTraceOperation({
@@ -280,6 +319,7 @@ async function dispatchAppPageInner(options) {
 				getSourceRoute(sourceRouteIndex) {
 					return options.getSourceRoute(sourceRouteIndex);
 				},
+				interceptState: options.interceptState,
 				isRscRequest: options.isRscRequest,
 				toInterceptOpts(intercept) {
 					return toInterceptOptions(options.interceptionContext, intercept);
@@ -320,9 +360,10 @@ async function dispatchAppPageInner(options) {
 			isDynamicRscRequest: options.pprRuntime !== void 0 && options.isRscRequest && options.request.headers.get("Next-Router-Prefetch") !== "1" && options.renderedConcreteUrlPaths?.has(options.cleanPathname) !== true,
 			renderFreshPageForCache: async ({ renderDocument }) => {
 				const revalidationTarget = await resolveCacheRenderTarget();
-				const revalidationDynamicConfig = options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0);
-				const revalidationConfigRevalidateSeconds = options.resolveRouteRevalidateSeconds?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? currentRevalidateSeconds : null);
-				const revalidationRouteRevalidateSeconds = revalidationTarget.route === route ? void 0 : revalidationConfigRevalidateSeconds ?? (revalidationDynamicConfig === "force-static" || revalidationDynamicConfig === "error" || options.isProduction && options.pprRuntime === void 0 && options.resolveRouteStaticEligible(revalidationTarget.route) ? Infinity : null);
+				const revalidationInterceptConfig = revalidationTarget.interceptOpts ? resolveAppPageInterceptSegmentConfig(revalidationTarget.route, revalidationTarget.interceptOpts) : null;
+				const revalidationDynamicConfig = revalidationInterceptConfig ? revalidationInterceptConfig.dynamicConfig : options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0);
+				const revalidationConfigRevalidateSeconds = revalidationInterceptConfig ? revalidationTarget.route === route ? currentRevalidateSeconds : revalidationInterceptConfig.revalidateSeconds : options.resolveRouteRevalidateSeconds?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? currentRevalidateSeconds : null);
+				const revalidationRouteRevalidateSeconds = revalidationTarget.route === route ? void 0 : revalidationConfigRevalidateSeconds ?? (revalidationDynamicConfig === "force-static" || revalidationDynamicConfig === "error" || options.isProduction && options.pprRuntime === void 0 && (revalidationInterceptConfig?.isStaticEligible ?? options.resolveRouteStaticEligible(revalidationTarget.route)) ? Infinity : null);
 				const revalidationRouteHead = {
 					observeSearchParams: revalidationDynamicConfig !== "force-static",
 					searchParams: new URLSearchParams(),
@@ -332,7 +373,7 @@ async function dispatchAppPageInner(options) {
 				return runAppPageRevalidationContext({
 					cleanPathname: options.cleanPathname,
 					displayPathname: options.displayPathname,
-					currentFetchCacheMode: options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
+					currentFetchCacheMode: revalidationInterceptConfig ? revalidationInterceptConfig.fetchCacheMode : options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
 					currentFetchRevalidate: revalidationConfigRevalidateSeconds,
 					draftModeSecret: options.draftModeSecret,
 					dynamicConfig: revalidationDynamicConfig,
@@ -347,6 +388,7 @@ async function dispatchAppPageInner(options) {
 						isForceStatic: revalidationDynamicConfig === "force-static",
 						observeMetadataSearchParamsAccess: revalidationDynamicConfig !== "force-static",
 						observePageSearchParamsAccess: revalidationDynamicConfig !== "force-static",
+						routeTreeOnlyPrefetchShell,
 						serveStreamingMetadata: placeGeneratedMetadataInBody,
 						placeStreamedMetadataInHead: true,
 						onHeadPrepared(head) {
@@ -459,6 +501,7 @@ async function dispatchAppPageInner(options) {
 				isDynamicError,
 				isForceDynamic,
 				isForceStatic,
+				isPrerender,
 				isProduction: options.isProduction,
 				isProgressiveActionRender: options.isProgressiveActionRender === true,
 				isRscRequest: options.isRscRequest,
@@ -475,9 +518,9 @@ async function dispatchAppPageInner(options) {
 	}
 	const fallbackShellResponse = options.pprRuntime ? await options.pprRuntime.tryServe(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) : null;
 	if (fallbackShellResponse) return fallbackShellResponse;
-	let interceptDynamicConfig;
-	let interceptDynamicConfigResolved = false;
-	let isInterceptSourceKnownDynamic = false;
+	let interceptConfig = null;
+	let isInterceptKnownDynamic = false;
+	let isInterceptRequestIndependent = false;
 	const renderedRouteHead = {
 		observeSearchParams: !isForceStatic,
 		searchParams: pageSearchParams,
@@ -489,27 +532,29 @@ async function dispatchAppPageInner(options) {
 	};
 	const interceptResult = await resolveAppPageIntercept({
 		async buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams) {
-			const sourceDynamicConfig = interceptDynamicConfigResolved ? interceptDynamicConfig : options.resolveRouteDynamicConfig?.(interceptRoute);
-			if (sourceDynamicConfig === "force-static" || sourceDynamicConfig === "error") {
+			interceptConfig ??= resolveAppPageInterceptSegmentConfig(interceptRoute, interceptOpts);
+			const interceptDynamicConfig = interceptConfig.dynamicConfig;
+			if (interceptDynamicConfig === "force-static" || interceptDynamicConfig === "error") {
 				const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
 				setHeadersContext(createStaticGenerationHeadersContext({
 					draftModeEnabled: isDraftMode,
 					draftModeSecret: options.draftModeSecret,
-					dynamicConfig: sourceDynamicConfig,
+					dynamicConfig: interceptDynamicConfig,
 					routeKind: "page",
 					routePattern: interceptRoute.pattern
 				}));
 			} else setHeadersContext(requestHeadersContext);
-			const sourceRevalidateSeconds = options.resolveRouteRevalidateSeconds?.(interceptRoute) ?? null;
-			isInterceptSourceKnownDynamic = sourceDynamicConfig === "force-dynamic" || sourceRevalidateSeconds === 0;
-			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(interceptRoute) ?? null);
-			setCurrentFetchRevalidate(sourceRevalidateSeconds);
-			setCurrentForceDynamicFetchDefault(sourceDynamicConfig === "force-dynamic");
+			isInterceptKnownDynamic = interceptDynamicConfig === "force-dynamic" || interceptConfig.revalidateSeconds === 0;
+			isInterceptRequestIndependent = interceptDynamicConfig === "force-static" || interceptDynamicConfig === "error";
+			setCurrentFetchCacheMode(interceptConfig.fetchCacheMode);
+			setCurrentFetchRevalidate(interceptConfig.revalidateSeconds);
+			setCurrentForceDynamicFetchDefault(interceptDynamicConfig === "force-dynamic");
 			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, {
-				isForceStatic: sourceDynamicConfig === "force-static",
-				observeMetadataSearchParamsAccess: sourceDynamicConfig !== "force-static",
-				observePageSearchParamsAccess: sourceDynamicConfig !== "force-static",
+				isForceStatic: interceptDynamicConfig === "force-static",
+				observeMetadataSearchParamsAccess: interceptDynamicConfig !== "force-static",
+				observePageSearchParamsAccess: interceptDynamicConfig !== "force-static",
 				isUncacheableRender,
+				routeTreeOnlyPrefetchShell,
 				serveStreamingMetadata: placeGeneratedMetadataInBody,
 				placeStreamedMetadataInHead: options.renderWholeDocument === true,
 				onHeadPrepared
@@ -526,18 +571,20 @@ async function dispatchAppPageInner(options) {
 		getSourceRoute(sourceRouteIndex) {
 			return options.getSourceRoute(sourceRouteIndex);
 		},
+		interceptState: options.interceptState,
 		isRscRequest: options.isRscRequest,
 		resolveNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts) {
 			return resolveAppPageNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts);
 		},
-		renderInterceptResponse(sourceRoute, interceptElement) {
+		renderInterceptResponse(sourceRoute, interceptElement, navigationParams) {
 			const interceptOnError = options.createRscOnErrorHandler(options.cleanPathname, sourceRoute.pattern);
 			const interceptStream = options.renderToReadableStream(interceptElement, { onError: interceptOnError });
 			const interceptHeaders = new Headers({
 				"Content-Type": VINEXT_RSC_CONTENT_TYPE,
 				Vary: VINEXT_RSC_VARY_HEADER
 			});
-			if (!(options.pprRuntime !== void 0 || options.resolveRouteStaticEligible(sourceRoute)) || isDraftMode || isInterceptSourceKnownDynamic) interceptHeaders.set("Cache-Control", resolveUncacheableCacheControl(options.isProduction));
+			if (Object.keys(navigationParams).length > 0) interceptHeaders.set(VINEXT_PARAMS_HEADER, encodeURIComponent(JSON.stringify(navigationParams)));
+			if (!(options.pprRuntime !== void 0 || interceptConfig?.isStaticEligible === true) || isDraftMode || isInterceptKnownDynamic || options.isProduction && !isInterceptRequestIndependent) interceptHeaders.set("Cache-Control", resolveUncacheableCacheControl(options.isProduction));
 			mergeMiddlewareResponseHeaders(interceptHeaders, options.middlewareContext.headers);
 			applyRscCompatibilityIdHeader(interceptHeaders);
 			applyRscDeploymentIdHeader(interceptHeaders);
@@ -546,11 +593,10 @@ async function dispatchAppPageInner(options) {
 				headers: interceptHeaders
 			});
 		},
-		async resolveSearchParams(sourceRoute, searchParams) {
+		async resolveSearchParams(sourceRoute, searchParams, interceptOpts) {
 			await options.ensureRouteLoaded?.(sourceRoute);
-			interceptDynamicConfig = options.resolveRouteDynamicConfig?.(sourceRoute);
-			interceptDynamicConfigResolved = true;
-			return interceptDynamicConfig === "force-static" ? new URLSearchParams() : searchParams;
+			interceptConfig = resolveAppPageInterceptSegmentConfig(sourceRoute, interceptOpts);
+			return interceptConfig.dynamicConfig === "force-static" ? new URLSearchParams() : searchParams;
 		},
 		searchParams: options.searchParams,
 		setNavigationContext: options.setNavigationContext,
@@ -568,6 +614,7 @@ async function dispatchAppPageInner(options) {
 				observeMetadataSearchParamsAccess: !isForceStatic,
 				observePageSearchParamsAccess: !isForceStatic,
 				isUncacheableRender,
+				routeTreeOnlyPrefetchShell,
 				mountedLayouts: interceptResult.interceptOpts ? null : mountedLayouts,
 				serveStreamingMetadata: placeGeneratedMetadataInBody,
 				placeStreamedMetadataInHead: options.renderWholeDocument === true,

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

@@ -66,6 +66,8 @@ export type AppPagePageRequest<TModule extends AppPageModule = AppPageModule> =
   isForceStatic?: boolean;
   /** The render can never be stored (see buildAppPageElements). */
   isUncacheableRender?: boolean;
+  /** A loading shell without a loading boundary is the route tree (see buildAppPageElements). */
+  routeTreeOnlyPrefetchShell?: boolean;
   /** Layouts the navigating client holds (see buildAppPageElements). */
   mountedLayouts?: ReadonlySet<string> | null;
   /** Observe page metadata `searchParams` access for cache-safety classification. */
@@ -116,24 +118,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 +135,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 +165,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
 /**
@@ -107,7 +107,7 @@ function traceAppPageInterceptLayoutModules(modules, branchSegments, layoutSegme
 async function buildPageElements(options) {
 	const { route, params, routePath, displayPathname = routePath, pageRequest, globalErrorModule, rootNotFoundModule, rootForbiddenModule, rootUnauthorizedModule, metadataRoutes } = options;
 	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
-	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, isUncacheableRender = false, mountedLayouts = null, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production", onHeadPrepared } = pageRequest;
+	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, isUncacheableRender = false, routeTreeOnlyPrefetchShell = false, mountedLayouts = null, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production", onHeadPrepared } = pageRequest;
 	const pageModule = route.page;
 	const isSiblingIntercept = opts?.interceptSlotKey === "__vinext_page_intercept" && !!opts?.interceptPage;
 	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
@@ -414,6 +414,7 @@ async function buildPageElements(options) {
 			globalErrorModule: globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE,
 			isRscRequest,
 			isUncacheableRender,
+			routeTreeOnlyPrefetchShell,
 			interceptionId: opts?.interceptionId ?? null,
 			mountedLayouts,
 			mountedSlotIds,
@@ -429,6 +430,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 +489,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 +614,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 {};