vinext 0.1.6 → 0.1.8

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

@@ -1,17 +1,27 @@
 import { matchRoutePattern } from "../routing/route-pattern.js";
 import { AppElementsWire } from "./app-elements-wire.js";
-import { APP_RSC_RENDER_MODE_NAVIGATION, shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
+import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
 import "./app-elements.js";
 import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
+import { resolveAppPageBranchParams } from "./app-page-params.js";
 import { resolveActiveParallelRouteHeadInputs, resolveAppPageHead } from "./app-page-head.js";
-import { makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
+import { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath } from "./app-page-route-wiring.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
 import "./app-rsc-route-matching.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { createElement } from "react";
 //#region src/server/app-page-element-builder.ts
+function resolveInterceptLayoutParams(branchSegments, layoutSegments, params) {
+	return resolveAppPageBranchParams(branchSegments, layoutSegments.length, params, layoutSegments);
+}
+const REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+function isReactOwnedPageComponent(component) {
+	if (typeof component !== "function") return true;
+	const candidate = component;
+	return candidate.$$typeof === REACT_CLIENT_REFERENCE || candidate.prototype?.isReactComponent != null;
+}
 /**
 * Build the App Router element tree for a matched route.
 *
@@ -30,7 +40,8 @@ import { createElement } from "react";
 */
 async function buildPageElements(options) {
 	const { route, params, routePath, displayPathname = routePath, pageRequest, globalErrorModule, rootNotFoundModule, rootForbiddenModule, rootUnauthorizedModule, metadataRoutes } = options;
-	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION } = pageRequest;
+	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
+	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false } = pageRequest;
 	const pageModule = route.page;
 	const isSiblingIntercept = opts?.interceptSlotKey === "__vinext_page_intercept" && !!opts?.interceptPage;
 	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
@@ -64,44 +75,68 @@ async function buildPageElements(options) {
 		};
 	}
 	const { hasDynamicMetadata, metadata: resolvedMetadata, pageSearchParams, viewport: resolvedViewport } = await resolveAppPageHead({
+		applyFileBasedMetadata: options.applyFileBasedMetadata,
 		basePath: options.basePath ?? "",
 		layoutModules: route.layouts,
 		layoutTreePositions: route.layoutTreePositions,
 		metadataRoutes,
-		pageModule: effectivePageModule ?? null,
-		parallelRoutes: resolveActiveParallelRouteHeadInputs({
+		pageModule: isSiblingIntercept ? null : effectivePageModule ?? null,
+		parallelRoutes: [...resolveActiveParallelRouteHeadInputs({
+			interceptBranchSegments: opts?.interceptBranchSegments ?? null,
 			interceptLayouts: opts?.interceptLayouts ?? null,
+			interceptLayoutSegments: opts?.interceptLayoutSegments ?? null,
 			interceptPage: opts?.interceptPage ?? null,
 			interceptParams: opts?.interceptParams ?? null,
 			interceptSlotKey: opts?.interceptSlotKey ?? null,
+			layoutTreePositions: route.layoutTreePositions,
 			params,
 			routeSegments: route.routeSegments ?? [],
+			slotParams: slotParamOverrides,
 			slots: route.slots ?? null
-		}),
+		}), ...isSiblingIntercept ? [{
+			layoutModules: opts?.interceptLayouts ?? [],
+			layoutParams: (opts?.interceptLayoutSegments ?? []).map((segments) => resolveInterceptLayoutParams(opts?.interceptBranchSegments ?? segments, segments, effectiveParams)),
+			pageModule: effectivePageModule ?? null,
+			params: effectiveParams,
+			routeSegments: opts?.interceptSourcePageSegments ?? route.routeSegments ?? []
+		}] : []],
 		params: effectiveParams,
 		routePath: route.pattern,
 		routeSegments: route.routeSegments ?? null,
-		searchParams
+		searchParams,
+		searchParamsObserver: observeMetadataSearchParamsAccess ? createAppPageSearchParamsObserver() : void 0
 	});
 	const pageProps = { params: makeThenableParams(effectiveParams) };
-	let pageSearchParamsThenable;
-	if (searchParams) {
-		pageSearchParamsThenable = !shouldSuppressLoadingBoundaries(renderMode) && Boolean(route.loading?.default) ? makeObservedAppPageSearchParamsThenable(pageSearchParams) : makeThenableParams(pageSearchParams);
-		pageProps.searchParams = pageSearchParamsThenable;
-	}
+	const hasRequestSearchParams = Object.keys(pageSearchParams).length > 0;
+	const createPageElement = (PageComponent, props) => {
+		if (isReactOwnedPageComponent(PageComponent)) {
+			const invocationProps = { ...props };
+			if (searchParams) invocationProps.searchParams = observePageSearchParamsAccess ? makeObservedAppPageSearchParamsThenable(pageSearchParams, { markDynamic: hasRequestSearchParams }) : makeThenableParams(pageSearchParams);
+			return createElement(PageComponent, invocationProps);
+		}
+		const ServerPageComponent = PageComponent;
+		const PageInvoker = () => {
+			const invocationProps = { ...props };
+			if (searchParams) invocationProps.searchParams = observePageSearchParamsAccess ? makeObservedAppPageSearchParamsThenable(pageSearchParams) : makeThenableParams(pageSearchParams);
+			return ServerPageComponent(invocationProps);
+		};
+		return createElement(PageInvoker);
+	};
+	const pageSearchParamsThenable = searchParams ? makeThenableParams(pageSearchParams) : void 0;
 	const mountedSlotIds = mountedSlotsHeader ? new Set(mountedSlotsHeader.split(" ")) : null;
 	const slotOverrides = buildSlotOverrides(route, params, routePath, opts);
 	const metadataPlacement = hasDynamicMetadata && shouldServeStreamingMetadata(pageRequest.request.headers.get("user-agent") ?? "", options.htmlLimitedBots) ? "body" : "head";
-	let siblingInterceptElement = isSiblingIntercept && EffectivePageComponent ? createElement(EffectivePageComponent, pageProps) : null;
-	if (isSiblingIntercept && siblingInterceptElement !== null && opts?.interceptLayouts?.length) {
-		const siblingThenableParams = makeThenableParams(effectiveParams);
-		for (let i = opts.interceptLayouts.length - 1; i >= 0; i--) {
-			const LayoutComponent = opts.interceptLayouts[i]?.default;
-			if (LayoutComponent) siblingInterceptElement = createElement(LayoutComponent, { params: siblingThenableParams }, siblingInterceptElement);
+	let siblingInterceptElement = isSiblingIntercept && EffectivePageComponent ? createPageElement(EffectivePageComponent, pageProps) : null;
+	if (isSiblingIntercept && siblingInterceptElement !== null && opts?.interceptLayouts?.length) for (let i = opts.interceptLayouts.length - 1; i >= 0; i--) {
+		const LayoutComponent = opts.interceptLayouts[i]?.default;
+		if (LayoutComponent) {
+			const interceptLayoutSegments = opts.interceptLayoutSegments?.[i] ?? [];
+			siblingInterceptElement = createElement(LayoutComponent, { params: makeThenableParams(resolveInterceptLayoutParams(opts.interceptBranchSegments ?? interceptLayoutSegments, interceptLayoutSegments, effectiveParams)) }, siblingInterceptElement);
 		}
 	}
 	return buildAppPageElements({
-		element: isSiblingIntercept ? siblingInterceptElement : EffectivePageComponent ? createElement(EffectivePageComponent, pageProps) : null,
+		element: isSiblingIntercept ? siblingInterceptElement : EffectivePageComponent ? createPageElement(EffectivePageComponent, pageProps) : null,
+		createPageElement,
 		globalErrorModule: globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE,
 		isRscRequest,
 		layoutParamAccess: options.layoutParamAccess,
@@ -142,7 +177,9 @@ async function buildPageElements(options) {
 function buildSlotOverrides(route, routeParams, routePath, opts) {
 	const overrides = {};
 	if (opts && opts.interceptSlotKey && opts.interceptPage && opts.interceptSlotKey !== "__vinext_page_intercept") overrides[opts.interceptSlotKey] = {
+		branchSegments: opts.interceptBranchSegments ?? null,
 		layoutModules: opts.interceptLayouts || null,
+		layoutSegments: opts.interceptLayoutSegments ?? null,
 		pageModule: opts.interceptPage,
 		params: opts.interceptParams || routeParams
 	};

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

@@ -1,31 +1,45 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppPageParams } from "./app-page-boundary.js";
+import { ThenableParamsObserver } from "../shims/thenable-params.js";
 import { Metadata, Viewport } from "../shims/metadata.js";
+import { applyFileBasedMetadata } from "./file-based-metadata.js";
 
 //#region src/server/app-page-head.d.ts
 type AppPageSearchParams = Record<string, string | string[]>;
 type AppPageHeadModule = Record<string, unknown>;
+type ApplyAppPageFileBasedMetadata = typeof applyFileBasedMetadata;
 type AppPageHeadParallelRoute<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  layoutParams?: readonly AppPageParams[] | null;
   layoutModule?: TModule | null;
   layoutModules?: readonly (TModule | null | undefined)[] | null;
+  layoutTreePositions?: readonly number[] | null;
   pageModule?: TModule | null;
   params?: AppPageParams | null;
   routeSegments?: readonly string[] | null;
 };
 type AppPageHeadSlot<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  configLayouts?: readonly (TModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
   layout?: TModule | null;
+  layoutIndex?: number;
   page?: TModule | null;
+  routeSegments?: readonly string[] | null;
 };
 type ResolveActiveParallelRouteHeadInputsOptions<TModule extends AppPageHeadModule = AppPageHeadModule> = {
   interceptLayouts?: readonly (TModule | null | undefined)[] | null;
+  interceptBranchSegments?: readonly string[] | null;
+  interceptLayoutSegments?: readonly (readonly string[])[] | null;
   interceptPage?: TModule | null;
   interceptParams?: AppPageParams | null;
   interceptSlotKey?: string | null;
+  layoutTreePositions?: readonly number[] | null;
   params: AppPageParams;
   routeSegments: readonly string[];
+  slotParams?: Readonly<Record<string, AppPageParams>> | null;
   slots?: Record<string, AppPageHeadSlot<TModule>> | null;
 };
 type ResolveAppPageHeadOptions<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  applyFileBasedMetadata?: ApplyAppPageFileBasedMetadata;
   /**
    * Configured next.config `basePath`. Threaded into `applyFileBasedMetadata`
    * so file-based metadata route URLs (icon, opengraph-image, manifest, ...)
@@ -43,6 +57,7 @@ type ResolveAppPageHeadOptions<TModule extends AppPageHeadModule = AppPageHeadMo
   routePath: string;
   routeSegments?: readonly string[] | null;
   searchParams?: URLSearchParams | null;
+  searchParamsObserver?: ThenableParamsObserver;
 };
 type ResolveAppPageHeadResult = {
   hasDynamicMetadata: boolean;
@@ -59,4 +74,4 @@ declare function resolveActiveParallelRouteHeadInputs<TModule extends AppPageHea
 declare function collectAppPageSearchParams(searchParams: URLSearchParams | null | undefined): AppPageSearchParamsCollection;
 declare function resolveAppPageHead<TModule extends AppPageHeadModule>(options: ResolveAppPageHeadOptions<TModule>): Promise<ResolveAppPageHeadResult>;
 //#endregion
-export { AppPageSearchParams, collectAppPageSearchParams, resolveActiveParallelRouteHeadInputs, resolveAppPageHead };
+export { AppPageSearchParams, ApplyAppPageFileBasedMetadata, collectAppPageSearchParams, resolveActiveParallelRouteHeadInputs, resolveAppPageHead };

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-method.js

@@ -1,6 +1,6 @@
 import { methodNotAllowedResponse } from "./http-error-responses.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
-import { isPossibleAppRouteActionRequest } from "./app-route-handler-policy.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 //#region src/server/app-page-method.ts
 function isNonGetOrHead(method) {
 	const normalizedMethod = method.toUpperCase();

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)