vinext 1.4.0 → 1.4.2

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,
@@ -280,6 +318,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 +359,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 +372,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,
@@ -459,6 +499,7 @@ async function dispatchAppPageInner(options) {
 				isDynamicError,
 				isForceDynamic,
 				isForceStatic,
+				isPrerender,
 				isProduction: options.isProduction,
 				isProgressiveActionRender: options.isProgressiveActionRender === true,
 				isRscRequest: options.isRscRequest,
@@ -475,9 +516,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,26 +530,27 @@ 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,
 				serveStreamingMetadata: placeGeneratedMetadataInBody,
 				placeStreamedMetadataInHead: options.renderWholeDocument === true,
@@ -526,18 +568,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 +590,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,
@@ -692,7 +735,6 @@ async function dispatchAppPageInner(options) {
 			return renderPageSpecialError(options, specialError, serveStreamingMetadata, interceptResult.interceptOpts, renderOptions?.isCacheCandidate === true, renderOptions?.caughtDocument, renderedRouteHead);
 		},
 		renderToReadableStream: options.renderToReadableStream,
-		hasCustomGlobalError: options.hasCustomGlobalError,
 		prerenderToReadableStream: options.prerenderToReadableStream,
 		routePattern: route.pattern,
 		scriptNonce: options.scriptNonce,

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

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

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

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

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

@@ -1,7 +1,7 @@
 import { VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
 import { copyLinkHeaderProvenance, getFrameworkLinkHeader, markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation, toPathAbsolutePathname } from "./app-rsc-cache-busting.js";
 import { isHTTPAccessFallbackError, isThrownNavigationError } from "../shims/navigation-errors.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
@@ -298,9 +298,11 @@ function toHeaderSafeUrlReference(location) {
 * header-safe, so a protocol-relative or scheme-relative target still resolves
 * against the page each client fetched. A relative target resolves against the
 * request's path to a path-only form, which the client resolves against its
-* own origin. Resolving against two placeholder origins tells these apart the
-* way the URL parser does, never depends on the request's origin, and cannot
-* mistake an absolute target naming one placeholder for a relative one.
+* own origin; a resolved pathname that begins with "//" keeps a "/." prefix
+* so that form stays a path rather than naming another host. Resolving
+* against two placeholder origins tells these apart the way the URL parser
+* does, never depends on the request's origin, and cannot mistake an absolute
+* target naming one placeholder for a relative one.
 */
 function resolveRedirectTargets(location, requestUrl) {
 	try {
@@ -310,9 +312,10 @@ function resolveRedirectTargets(location, requestUrl) {
 			headerUrl: toHeaderSafeUrlReference(location)
 		};
 		const { pathname, search, hash } = first.resolved;
+		const target = `${toPathAbsolutePathname(pathname)}${search}${hash}`;
 		return {
-			digestUrl: `${pathname}${search}${hash}`,
-			headerUrl: `${pathname}${search}${hash}`
+			digestUrl: target,
+			headerUrl: target
 		};
 	} catch {
 		return {

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

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

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

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

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

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